"""轮廓求解器：参数化草图描述 → entities + contour_edges_mm。 LLM 只需输出离散决策（type, radius, width …）， 求解器负责生成精确的实体和轮廓边坐标。 架构：注册表模式 —— 每个轮廓类型对应一个生成器函数， 按 "type" 字符串索引。新增形状只需 3 步： 1. 写 def solver_xxx(profile, meta) -> (entities, contour) 2. 注册: SHAPE_GENERATORS["xxx"] = solver_xxx 3. 在 convert 脚本中输出对应的 profile 支持的 profile 类型： - circle: 单个圆 - annulus: 同心圆环 - circles: 多圆（引擎自动判断加/切除） - circle_grid: 矩形圆孔阵列（行列+间距） - rectangle: 矩形 - rectangle_with_circles: 矩形 + 内圆孔/岛 - rectangle_with_fillets: 带圆角的矩形（4角倒圆），可选内圆 - rectangle_with_symmetric_notches: 对称槽板（矩形+4个U形缺口） - obround: 槽形 / 键槽（2平行线 + 2半圆） - polygon: N边多边形（顶点列表） - ibone: 工字形凸耳（12线+4弧+4孔） - circle_with_arc_notches: 圆+均匀圆弧凹口 - circular_sector_slot: 圆弧扇区+中心矩形槽 - circle_with_radial_tabs: 圆+径向矩形凸耳（带圆角） - filleted_rect_side_slots: 圆角矩形+两侧中心U形槽 - d_shape: D形（半圆+弦线） - partial_ring: 部分圆环（同心弧+径向线） - partial_ring_with_arc_island: 扇区环 + 弦上偏移弧岛（保留材料岛） - concentric_arc_profile: 同心圆弧轮廓（多段弧+圆心标记） - patterned_cutouts: 母形 + 规则布局的多区域切口 - compound_patterned_cutouts: 多组母形/布局合并为一个切除草图 """ from __future__ import annotations import math from copy import deepcopy from typing import Any # ═══════════════════════════════════════════════════════════════ # 基础几何原语 # ═══════════════════════════════════════════════════════════════ def _circle(center: list[float], radius_mm: float, construction: bool = False) -> dict[str, Any]: return { "type": "circle", "center": [float(center[0]), float(center[1])], "radius_mm": float(radius_mm), "construction": construction, } def _line(start: list[float], end: list[float], construction: bool = False) -> dict[str, Any]: return { "type": "line", "start": [float(start[0]), float(start[1])], "end": [float(end[0]), float(end[1])], "construction": construction, } def _contour_line(start_mm: list[float], end_mm: list[float]) -> dict[str, Any]: return { "type": "line", "start_mm": [ float(start_mm[0]), float(start_mm[1]), float(start_mm[2]) if len(start_mm) > 2 else 0.0, ], "end_mm": [ float(end_mm[0]), float(end_mm[1]), float(end_mm[2]) if len(end_mm) > 2 else 0.0, ], } def _contour_arc( start_mm: list[float], end_mm: list[float], center_mm: list[float], radius_mm: float | None, ) -> dict[str, Any]: return { "type": "arc", "start_mm": [ float(start_mm[0]), float(start_mm[1]), float(start_mm[2]) if len(start_mm) > 2 else 0.0, ], "end_mm": [ float(end_mm[0]), float(end_mm[1]), float(end_mm[2]) if len(end_mm) > 2 else 0.0, ], "center_mm": [ float(center_mm[0]), float(center_mm[1]), float(center_mm[2]) if len(center_mm) > 2 else 0.0, ], "radius_mm": float(radius_mm) if radius_mm is not None else None, } # ═══════════════════════════════════════════════════════════════ # 3D 坐标转换 # ═══════════════════════════════════════════════════════════════ def _to_3d(workplane: dict[str, Any], u: float, v: float) -> list[float]: """将2D局部坐标 (u,v) 映射到3D世界坐标。""" origin = workplane.get("origin_mm") or [0, 0, 0] x_dir = workplane.get("x_dir") or [1, 0, 0] normal = workplane.get("normal") or [0, 0, 1] y_dir = [ normal[1] * x_dir[2] - normal[2] * x_dir[1], normal[2] * x_dir[0] - normal[0] * x_dir[2], normal[0] * x_dir[1] - normal[1] * x_dir[0], ] return [ origin[0] + u * x_dir[0] + v * y_dir[0], origin[1] + u * x_dir[1] + v * y_dir[1], origin[2] + u * x_dir[2] + v * y_dir[2], ] def _transform_contours(contour: list[dict[str, Any]], wp: dict[str, Any]) -> list[dict[str, Any]]: """将轮廓边的2D坐标映射为3D世界坐标。""" result: list[dict[str, Any]] = [] x_dir = wp.get("x_dir") or [1, 0, 0] normal = wp.get("normal") or [0, 0, 1] for e in contour: e2 = deepcopy(e) if e["type"] == "line": e2["start_mm"] = _to_3d(wp, e["start_mm"][0], e["start_mm"][1]) e2["end_mm"] = _to_3d(wp, e["end_mm"][0], e["end_mm"][1]) elif e["type"] == "arc": e2["start_mm"] = _to_3d(wp, e["start_mm"][0], e["start_mm"][1]) e2["end_mm"] = _to_3d(wp, e["end_mm"][0], e["end_mm"][1]) e2["center_mm"] = _to_3d(wp, e["center_mm"][0], e["center_mm"][1]) e2["normal"] = list(normal) result.append(e2) return result # ═══════════════════════════════════════════════════════════════ # 矩形 / 圆辅助 # ═══════════════════════════════════════════════════════════════ def _build_rect_bounds(profile: dict[str, Any]) -> tuple[float, float, float, float]: """从 profile 中提取矩形的 (x0, y0, x1, y1) 边界。""" center = profile.get("center") w = float(profile.get("width_mm") or 0) h = float(profile.get("height_mm") or 0) if center and w > 0 and h > 0: cx, cy = float(center[0]), float(center[1]) return cx - w / 2, cy - h / 2, cx + w / 2, cy + h / 2 mn = profile.get("min_mm") mx = profile.get("max_mm") if mn and mx: return float(mn[0]), float(mn[1]), float(mx[0]), float(mx[1]) raise ValueError("rectangle profile needs (center+width+height) or (min+max)") def _rect_lines_and_contour( x0: float, y0: float, x1: float, y1: float, ) -> tuple[list[dict], list[dict]]: p00, p10, p11, p01 = [x0, y0, 0.0], [x1, y0, 0.0], [x1, y1, 0.0], [x0, y1, 0.0] entities = [ _line([x0, y0], [x1, y0]), _line([x1, y0], [x1, y1]), _line([x1, y1], [x0, y1]), _line([x0, y1], [x0, y0]), ] contour = [ _contour_line(p00, p10), _contour_line(p10, p11), _contour_line(p11, p01), _contour_line(p01, p00), ] return entities, contour def _build_circle_entities(items: list[dict]) -> list[dict]: entities: list[dict] = [] for item in items: center = item.get("center") or [0.0, 0.0] r = float(item.get("radius_mm") or 0) if r <= 0: raise ValueError("circle radius must be > 0") entities.append(_circle(center, r, construction=False)) return entities def _filleted_rect_contour( x0: float, y0: float, x1: float, y1: float, r: float, ) -> tuple[list[dict], list[dict]]: """生成带圆角矩形的实体线和轮廓边（4直线 + 4圆弧）。""" if r <= 0: return _rect_lines_and_contour(x0, y0, x1, y1) cx0, cx1 = x0 + r, x1 - r cy0, cy1 = y0 + r, y1 - r entities = [ _line([cx0, y0], [cx1, y0]), _line([x0, cy0], [x0, cy1]), _line([cx0, y1], [cx1, y1]), _line([x1, cy0], [x1, cy1]), ] contour = [ _contour_line([x0, cy0, 0.0], [x0, cy1, 0.0]), _contour_arc([x0, cy1, 0.0], [cx0, y1, 0.0], [cx0, cy1, 0.0], r), _contour_line([cx0, y1, 0.0], [cx1, y1, 0.0]), _contour_arc([cx1, y1, 0.0], [x1, cy1, 0.0], [cx1, cy1, 0.0], r), _contour_line([x1, cy1, 0.0], [x1, cy0, 0.0]), _contour_arc([x1, cy0, 0.0], [cx1, y0, 0.0], [cx1, cy0, 0.0], r), _contour_line([cx1, y0, 0.0], [cx0, y0, 0.0]), _contour_arc([cx0, y0, 0.0], [x0, cy0, 0.0], [cx0, cy0, 0.0], r), ] return entities, contour # ═══════════════════════════════════════════════════════════════ # 形状生成器（每个是一个独立函数，按 type 注册） # ═══════════════════════════════════════════════════════════════ _Ctx = dict[str, Any] def _gen_circle(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: center = profile.get("center") or [0.0, 0.0] r = float(profile.get("radius_mm") or 0) if r <= 0: raise ValueError("circle radius must be > 0") entities = [_circle(center, r)] cx, cy, c3d = float(center[0]), float(center[1]), [float(center[0]), float(center[1]), 0.0] contour = [ _contour_arc([cx + r, cy, 0.0], [cx, cy + r, 0.0], c3d, r), _contour_arc([cx, cy + r, 0.0], [cx - r, cy, 0.0], c3d, r), _contour_arc([cx - r, cy, 0.0], [cx, cy - r, 0.0], c3d, r), _contour_arc([cx, cy - r, 0.0], [cx + r, cy, 0.0], c3d, r), ] return entities, contour def _gen_annulus(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: center = profile.get("center") or [0.0, 0.0] inner_r = float(profile.get("inner_radius_mm") or 0) outer_r = float(profile.get("outer_radius_mm") or 0) if inner_r <= 0 or outer_r <= 0: raise ValueError("annulus radii must be > 0") if inner_r >= outer_r: raise ValueError("inner_radius >= outer_radius") return [_circle(center, inner_r), _circle(center, outer_r)], [] def _gen_circles(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: items = profile.get("items") or [] if not items: raise ValueError("circles items must be non-empty") return _build_circle_entities(items), [] def _gen_circle_grid(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: """矩形圆孔阵列：由起点圆心 + 间距 + 行列数生成。 参数: radius_mm: 孔半径 count_x / count_y: 列数、行数 spacing_x_mm / spacing_y_mm: 圆心间距 origin_mm: 第一孔圆心 [u,v]（默认沿 +u/+v 铺开） 或 center_mm: 阵列几何中心（与 origin_mm 二选一） 覆盖: b006（4×5 通孔阵列） """ r = float(profile["radius_mm"]) nx = int(profile["count_x"]) ny = int(profile["count_y"]) sx = float(profile["spacing_x_mm"]) sy = float(profile["spacing_y_mm"]) if r <= 0 or nx < 1 or ny < 1: raise ValueError("circle_grid: invalid radius/counts") if profile.get("center_mm") is not None: cc = profile["center_mm"] u0 = float(cc[0]) - (nx - 1) * sx / 2.0 v0 = float(cc[1]) - (ny - 1) * sy / 2.0 else: origin = profile.get("origin_mm") or [0.0, 0.0] u0, v0 = float(origin[0]), float(origin[1]) items = [ {"center": [u0 + i * sx, v0 + j * sy], "radius_mm": r} for j in range(ny) for i in range(nx) ] return _build_circle_entities(items), [] def _gen_rectangle(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: x0, y0, x1, y1 = _build_rect_bounds(profile) return _rect_lines_and_contour(x0, y0, x1, y1) def _gen_rect_with_circles(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: boundary = profile.get("boundary") or {} circle_items = profile.get("circles") or [] btype = boundary.get("type") or "rectangle" if btype in ("rectangle", "rectangle_with_fillets"): if btype == "rectangle": x0, y0, x1, y1 = _build_rect_bounds(boundary) ent, con = _rect_lines_and_contour(x0, y0, x1, y1) else: fr = float(boundary.get("fillet_radius_mm") or 0) x0, y0, x1, y1 = _build_rect_bounds(boundary) ent, con = _filleted_rect_contour(x0, y0, x1, y1, fr) ent.extend(_build_circle_entities(circle_items)) return ent, con raise ValueError(f"rectangle_with_circles: unsupported boundary type {btype!r}") def _gen_rect_with_fillets(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: fr = float(profile.get("fillet_radius_mm") or 0) x0, y0, x1, y1 = _build_rect_bounds(profile) ent, con = _filleted_rect_contour(x0, y0, x1, y1, fr) ent.extend(_build_circle_entities(profile.get("circles") or [])) return ent, con def _gen_obround(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: center = profile.get("center") length = float(profile.get("length_mm") or 0) width = float(profile.get("width_mm") or 0) if length <= 0 or width <= 0: raise ValueError("obround needs positive length/width") r = width / 2 cx, cy = (float(center[0]), float(center[1])) if center else (0.0, 0.0) offset = max(0, (length - width) / 2) left_cx, right_cx = cx - offset, cx + offset if offset < 0.001: c3d = [cx, cy, 0.0] contour = [ _contour_arc([cx + r, cy, 0.0], [cx, cy + r, 0.0], c3d, r), _contour_arc([cx, cy + r, 0.0], [cx - r, cy, 0.0], c3d, r), _contour_arc([cx - r, cy, 0.0], [cx, cy - r, 0.0], c3d, r), _contour_arc([cx, cy - r, 0.0], [cx + r, cy, 0.0], c3d, r), ] return [_circle([cx, cy], r)], contour top_y, bot_y = cy + r, cy - r left_c3d, right_c3d = [left_cx, cy, 0.0], [right_cx, cy, 0.0] contour = [ _contour_arc([right_cx, top_y, 0.0], [right_cx + r, cy, 0.0], right_c3d, r), _contour_arc([right_cx + r, cy, 0.0], [right_cx, bot_y, 0.0], right_c3d, r), _contour_line([right_cx, bot_y, 0.0], [left_cx, bot_y, 0.0]), _contour_arc([left_cx, bot_y, 0.0], [left_cx - r, cy, 0.0], left_c3d, r), _contour_arc([left_cx - r, cy, 0.0], [left_cx, top_y, 0.0], left_c3d, r), _contour_line([left_cx, top_y, 0.0], [right_cx, top_y, 0.0]), ] entities = [ _line([left_cx, bot_y], [right_cx, bot_y]), _line([left_cx, top_y], [right_cx, top_y]), _circle([left_cx, cy], r), _circle([right_cx, cy], r), ] return entities, contour def _gen_polygon(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: vertices = profile.get("vertices") or [] if len(vertices) >= 3: pts_2d = [(float(v[0]), float(v[1])) for v in vertices] entities, contour = [], [] for i in range(len(pts_2d)): s, e = pts_2d[i], pts_2d[(i + 1) % len(pts_2d)] entities.append(_line(list(s), list(e))) contour.append(_contour_line([s[0], s[1], 0.0], [e[0], e[1], 0.0])) return entities, contour # 015133: no vertices in profile -> use entities from compiler_context ents = meta.get("_entities") or [] if not ents: raise ValueError("polygon needs at least 3 vertices or existing entities in sketch") contour = [] for e in ents: t = e.get("type", "") if t == "line": s = e.get("start", [0, 0]) ed = e.get("end", [0, 0]) contour.append(_contour_line([float(s[0]), float(s[1]), 0.0], [float(ed[0]), float(ed[1]), 0.0])) elif t == "arc": contour.append(_contour_line( [float(e["start"][0]), float(e["start"][1]), 0.0], [float(e["end"][0]), float(e["end"][1]), 0.0])) return list(ents), contour def _gen_ibone(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: """工字形凸耳：12线 + 4弧 + 4孔""" bw, bh = float(profile["body_width_mm"]), float(profile["body_height_mm"]) fw, fh = float(profile["flange_width_mm"]), float(profile["flange_height_mm"]) cr = float(profile["corner_radius_mm"]) hr = float(profile.get("hole_radius_mm") or 0) hw, hfw, ar = bw / 2, fw / 2, bw / 2 - cr av_bot, av_top = fh - cr, bh - fh + cr segs = [ ("L", hfw, 0, -hfw, 0), ("L", -hfw, 0, -hfw, fh - cr), ("A", -hfw, fh - cr, -ar, fh, -ar, fh - cr, cr), ("L", -ar, fh, -hw, fh), ("L", -hw, fh, -hw, bh - fh), ("L", -hw, bh - fh, -ar, bh - fh), ("A", -ar, bh - fh, -hfw, bh - fh + cr, -ar, bh - fh + cr, cr), ("L", -hfw, bh - fh + cr, -hfw, bh), ("L", -hfw, bh, hfw, bh), ("L", hfw, bh, hfw, bh - fh + cr), ("A", hfw, bh - fh + cr, ar, bh - fh, ar, bh - fh + cr, cr), ("L", ar, bh - fh, hw, bh - fh), ("L", hw, bh - fh, hw, fh), ("L", hw, fh, ar, fh), ("A", ar, fh, hfw, fh - cr, ar, fh - cr, cr), ("L", hfw, fh - cr, hfw, 0), ] entities, contour = [], [] for s in segs: if s[0] == "L": _, u1, v1, u2, v2 = s entities.append(_line([u1, v1], [u2, v2])) contour.append(_contour_line([u1, v1, 0.0], [u2, v2, 0.0])) else: _, u1, v1, u2, v2, cu, cv, r = s contour.append(_contour_arc([u1, v1, 0.0], [u2, v2, 0.0], [cu, cv, 0.0], r)) if hr > 0: for cu, cv in [(-ar, av_bot), (ar, av_bot), (-ar, av_top), (ar, av_top)]: entities.append(_circle([cu, cv], hr)) return entities, contour def _gen_rect_symmetric_notches(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: """对称槽板：矩形+4个U形缺口（简化多边形 或 精确弧边）""" w, h = float(profile["width_mm"]), float(profile["height_mm"]) n = profile.get("notch") or {} n_ys, n_ye = float(n["y_start"]), float(n["y_end"]) n_depth = float(n["depth_mm"]) n_ir = float(n.get("inner_radius_mm") or 0) n_cr = float(n.get("corner_radius_mm") or 0) hw = w / 2 inner_u = hw - n_depth if n_ir > 0 and n_cr > 0: icu, icv = hw - n_depth / 2, (n_ys + n_ye) / 2 entities, contour = [], [] for u1, v1, u2, v2 in [ (hw, 0, hw, n_ys), (hw, n_ye, hw, h - n_ye), (hw, h - n_ys, hw, h), (-hw, h, -hw, h - n_ys), (-hw, h - n_ye, -hw, n_ye), (-hw, n_ys, -hw, 0), (-hw, 0, hw, 0), (hw, h, -hw, h), ]: entities.append(_line([u1, v1], [u2, v2])) contour.append(_contour_line([u1, v1, 0.0], [u2, v2, 0.0])) def _notch(sign_u, y_bot, y_top): u = sign_u * hw ec = sign_u * (hw - n_cr) icu2 = sign_u * icu contour.append(_contour_arc( [u, y_bot, 0.0], [ec, y_bot + n_cr, 0.0], [ec, y_bot, 0.0], n_cr)) av = y_bot + n_cr au = icu2 - sign_u * math.sqrt(max(0.0, n_ir ** 2 - (av - icv) ** 2)) contour.append(_contour_line([ec, av, 0.0], [au, av, 0.0])) bv = y_top - n_cr bu = icu2 - sign_u * math.sqrt(max(0.0, n_ir ** 2 - (bv - icv) ** 2)) contour.append(_contour_arc( [au, av, 0.0], [bu, bv, 0.0], [icu2, icv, 0.0], n_ir)) contour.append(_contour_line([bu, bv, 0.0], [ec, bv, 0.0])) contour.append(_contour_arc( [ec, bv, 0.0], [u, y_top, 0.0], [ec, y_top, 0.0], n_cr)) _notch(+1, n_ys, n_ye) _notch(+1, h - n_ye, h - n_ys) _notch(-1, n_ys, n_ye) _notch(-1, h - n_ye, h - n_ys) return entities, contour # 简化多边形（5 参数） verts = [ (hw, 0), (hw, n_ys), (inner_u, n_ys), (inner_u, n_ye), (hw, n_ye), (hw, h - n_ye), (inner_u, h - n_ye), (inner_u, h - n_ys), (hw, h - n_ys), (hw, h), (-hw, h), (-hw, h - n_ys), (-inner_u, h - n_ys), (-inner_u, h - n_ye), (-hw, h - n_ye), (-hw, n_ye), (-inner_u, n_ye), (-inner_u, n_ys), (-hw, n_ys), (-hw, 0), ] entities, contour = [], [] pts = [(float(v[0]), float(v[1])) for v in verts] for i in range(len(pts)): s, e = pts[i], pts[(i + 1) % len(pts)] entities.append(_line(list(s), list(e))) contour.append(_contour_line([s[0], s[1], 0.0], [e[0], e[1], 0.0])) return entities, contour def _gen_revolve_chamfer(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: """旋转切除的梯形截面（5顶点，相对轴顶点定义）。""" ah = float(profile["axis_height_mm"]) tw = float(profile["top_width_mm"]) bw = float(profile["bottom_width_mm"]) wi = float(profile.get("wall_inset_mm") or 0) si = float(profile.get("step_inset_mm") or 0) side = profile.get("on_axis_side", "left") sign = -1 if side == "left" else 1 v0 = (sign * tw, -wi); v1 = (0.0, 0.0); v2 = (0.0, -ah) v3 = (sign * bw, -ah); v4 = (sign * tw, -si) entities, contour = [], [] for s, e in [(v0, v1), (v1, v2), (v2, v3), (v3, v4), (v4, v0)]: entities.append(_line(list(s), list(e))) contour.append(_contour_line([s[0], s[1], 0.0], [e[0], e[1], 0.0])) return entities, contour def _gen_revolve_chamfer_slanted(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: """旋转切除的斜底梯形截面（5顶点）。 与 revolve_chamfer 的区别：底部为斜边（轴底→壁底不是水平线）。 参数: axis_height_mm: 轴侧总高度（V1→V2） top_width_mm: 顶部宽度（轴→外壁） wall_inset_mm: 顶部台阶深度（V0→V4 的 V 偏移） wall_height_mm: 壁段高度（V4→V3） wall_width_mm: 壁距轴的距离 on_axis_side: "left"(U负) 或 "right"(U正) """ ah = float(profile["axis_height_mm"]) tw = float(profile["top_width_mm"]) wi = float(profile.get("wall_inset_mm") or 0) wh = float(profile["wall_height_mm"]) ww = float(profile["wall_width_mm"]) side = profile.get("on_axis_side", "left") sign = -1 if side == "left" else 1 v0 = (sign * tw, 0.0) # 顶部外侧 v1 = (0.0, 0.0) # 轴顶点 v2 = (0.0, -ah) # 轴底部 v3 = (sign * ww, -wi - wh) # 壁底部（斜边连接到 V2） v4 = (sign * ww, -wi) # 壁顶部（台阶） entities, contour = [], [] for s, e in [(v0, v1), (v1, v2), (v2, v3), (v3, v4), (v4, v0)]: entities.append(_line(list(s), list(e))) contour.append(_contour_line([s[0], s[1], 0.0], [e[0], e[1], 0.0])) return entities, contour # ═══════════════════════════════════════════════════════════════ # 弧边复合轮廓生成器（按"015133 手册"方法注册） # ═══════════════════════════════════════════════════════════════ def _gen_circle_with_arc_notches(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: """圆+圆弧凹口：大圆上均匀分布的弧形缺口。 参数: outer_radius_mm: 大圆半径 notch_radius_mm: 每个凹口的圆弧半径 notch_angles_deg: 凹口所在的角度列表（度，从+u顺时针） 默认 [0, 90, 180, 270]（十字槽） 例: [0,90,180,270] → 十字形，[45,135,225,315] → 斜十字 覆盖文件: 48, 49, 50, 82 """ import math R = float(profile["outer_radius_mm"]) r = float(profile["notch_radius_mm"]) angles_deg = profile.get("notch_angles_deg", [0, 90, 180, 270]) # 每个凹口在大圆上占据的半角宽度 delta = math.acos(max(-1.0, min(1.0, 1.0 - r * r / (2.0 * R * R)))) angles_rad = [math.radians(a) for a in sorted(angles_deg)] entities, contour = [], [] n = len(angles_rad) for i in range(n): prev_end = angles_rad[i - 1] + delta # 上一个凹口离开点 curr_enter = angles_rad[i] - delta # 当前凹口入口 # 大弧：从上一个凹口离开点到当前凹口入口（顺时针） ps_u, ps_v = R * math.cos(prev_end), R * math.sin(prev_end) pe_u, pe_v = R * math.cos(curr_enter), R * math.sin(curr_enter) contour.append(_contour_arc( [ps_u, ps_v, 0.0], [pe_u, pe_v, 0.0], [0.0, 0.0, 0.0], R, )) # 凹口弧：从入口→出口，中心在外圆上 curr_exit = angles_rad[i] + delta nc_u = R * math.cos(angles_rad[i]) nc_v = R * math.sin(angles_rad[i]) pn_enter_u = R * math.cos(curr_enter) pn_enter_v = R * math.sin(curr_enter) pn_exit_u = R * math.cos(curr_exit) pn_exit_v = R * math.sin(curr_exit) # 凹口弧：从出口回到入口（与大弧方向相反） contour.append(_contour_arc( [pn_exit_u, pn_exit_v, 0.0], [pn_enter_u, pn_enter_v, 0.0], [nc_u, nc_v, 0.0], r, )) entities.extend(_build_circle_entities(profile.get("circles") or [])) return entities, contour def _gen_circular_sector_slot(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: """圆弧扇区槽：一段大圆弧 + 两条径向线 + 一个矩形槽口。 形状：一个扇形（大圆弧 + 两侧径向线），中心开矩形槽。 由两条大弧（上/下）、两条径向线、一个中央矩形槽组成。 参数: arc_radius_mm: 大弧半径（圆心在原点） slot_half_width_mm: 槽口半宽（从圆心起的径向距离） chord_half_mm: 弧弦线半长（弧的跨距，决定弧幅度） 覆盖文件: 87, 88, 89, 90 """ import math R = float(profile["arc_radius_mm"]) hw = float(profile["slot_half_width_mm"]) ch = float(profile["chord_half_mm"]) # 弧端点：在圆上，到中心轴的垂直距离为 ch # 弧端点在圆 R 上，距离中心轴 ch，其角度为 asin(ch/R) half_angle = math.asin(max(-1.0, min(1.0, ch / R))) # 弧端点坐标（圆上，2 个象限） arc_x = R * math.cos(half_angle) arc_y = R * math.sin(half_angle) if ch >= 0 else -R * math.sin(-half_angle) # 4 个关键点（顺时针） # 下弧: x 从 -arc_x 到 +arc_x, y = -ch (在圆上 y = ±arc_y ≈ ±ch) # 右上角弧段 arc_x_neg_angle = R * math.cos(-half_angle) arc_y_neg = R * math.sin(-half_angle) p_bot_right = (arc_x_neg_angle, arc_y_neg) # 右下（圆上，负半角） p_bot_left = (arc_x, arc_y) # 右下（圆上，正半角）... 等等 # 直接按 87 的几何定义：下弧从 (+xs, -ch) 到 (-xs, -ch)，上弧从 (-xs, +ch) 到 (+xs, +ch) # xs 由圆 R 和 ch 确定 xs = math.sqrt(max(0, R * R - ch * ch)) contour = [ # 下弧：从 (xs, -ch) 到 (-xs, -ch)，圆心原点，半径 R（顺时针） _contour_arc([xs, -ch, 0.0], [-xs, -ch, 0.0], [0.0, 0.0, 0.0], R), # 左侧线：(-xs, -ch) → (-xs, +ch) ... # 不对，夹着槽口 ] # 重新按 87 的实际边序列构建 # [0] line (-27.5, -13)→(-27.5, +13) → 槽口左竖线 # [1] line (-27.5, +13)→(-37.83, +13) → 径向连接 # [2] arc r=40 c=(0,0) s=(+37.83, +13)→(-37.83, +13) → 上弧 # [3] line (+27.5, +13)→(+37.83, +13) → 径向连接（右侧） # [4] line (+27.5, -13)→(+27.5, +13) → 槽口右竖线 # [5] line (+27.5, -13)→(+37.83, -13) → 径向连接 # [6] arc r=40 c=(0,0) s=(-37.83, -13)→(+37.83, -13) → 下弧 # [7] line (-27.5, -13)→(-37.83, -13) → 径向连接 # 参数化: # slot_half = 27.5 (槽口半宽) # chord_half = 13 (弧端点的 w 坐标，确定弧的跨度) # arc_radius = 40 # arc_x_end = sqrt(R² - ch²) = sqrt(1600 - 169) ≈ 37.83 sh = hw # slot half axe = math.sqrt(max(0.0, R * R - ch * ch)) # arc x-endpoint contour = [ # 槽口竖线（从左下到左上） _contour_line([-sh, -ch, 0.0], [-sh, ch, 0.0]), # 连接到弧（从槽口左上到弧左下） _contour_line([-sh, ch, 0.0], [-axe, ch, 0.0]), # 上弧（从弧左下到弧右下，经过原点顶） _contour_arc([axe, ch, 0.0], [-axe, ch, 0.0], [0.0, 0.0, 0.0], R), # 连接到槽口（从弧右下到槽口右上） _contour_line([sh, ch, 0.0], [axe, ch, 0.0]), # 槽口竖线（从右上到右下） _contour_line([sh, ch, 0.0], [sh, -ch, 0.0]), # 连接到弧（从槽口右下到弧右上） _contour_line([sh, -ch, 0.0], [axe, -ch, 0.0]), # 下弧（从弧右上到弧左上，经过原点底） _contour_arc([-axe, -ch, 0.0], [axe, -ch, 0.0], [0.0, 0.0, 0.0], R), # 连接到槽口（从弧左上到槽口左下） _contour_line([-sh, -ch, 0.0], [-axe, -ch, 0.0]), ] entities = [ _line([-sh, -ch], [-sh, ch]), _line([-sh, ch], [-axe, ch]), _line([sh, ch], [axe, ch]), _line([sh, ch], [sh, -ch]), _line([sh, -ch], [axe, -ch]), _line([-sh, -ch], [-axe, -ch]), ] entities.extend(_build_circle_entities(profile.get("circles") or [])) return entities, contour def _gen_circle_with_radial_tabs(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: """圆+径向凸耳：大圆弧上有矩形凸起。 形状：一个大圆被两侧的矩形凸耳取代部分弧段。 简化表示为直边多边形（忽略 r=1 的圆角，体积误差 <1%）。 参数: outer_radius_mm: 大圆半径 tab_u_half_mm: 凸耳半宽（弧线方向，从根部到内缘） tab_v_offset_mm: 凸耳离弧线的垂直距离（即凸耳顶部距弧线的v偏移） 覆盖文件: 91, 92, 93, 94, 95 """ import math R = float(profile["outer_radius_mm"]) tu = float(profile.get("tab_u_half_mm") or 0) tv = float(profile.get("tab_v_offset_mm") or 0) # 凸耳根部在圆上的角度 angle = math.asin(min(1.0, max(0.0, tv / R))) # 弧上根部点（右侧） root_u = R * math.cos(angle) root_v = R * math.sin(angle) # 凸耳内缘 inner_u = root_u - tu inner_v = root_v * 0.9 # 略浅于弧线 # 构建轮廓：大弧(上) → 右凸耳 → 大弧(下) → 左凸耳 → 闭合 contour = [] # 上弧：从左侧根部到右侧根部（经过顶点） contour.append(_contour_arc( [root_u, root_v, 0.0], [-root_u, root_v, 0.0], [0.0, 0.0, 0.0], R)) # 右侧凸耳（多边形：根部→内顶→内底→根部） contour.append(_contour_line([root_u, root_v, 0.0], [inner_u, inner_v, 0.0])) contour.append(_contour_line([inner_u, inner_v, 0.0], [inner_u, -inner_v, 0.0])) contour.append(_contour_line([inner_u, -inner_v, 0.0], [root_u, -root_v, 0.0])) # 下弧：从右侧底部到左侧底部（经过底点） contour.append(_contour_arc( [-root_u, -root_v, 0.0], [root_u, -root_v, 0.0], [0.0, 0.0, 0.0], R)) # 左侧凸耳（镜像） contour.append(_contour_line([-root_u, -root_v, 0.0], [-inner_u, -inner_v, 0.0])) contour.append(_contour_line([-inner_u, -inner_v, 0.0], [-inner_u, inner_v, 0.0])) contour.append(_contour_line([-inner_u, inner_v, 0.0], [-root_u, root_v, 0.0])) entities = [ _line([root_u, root_v], [inner_u, inner_v]), _line([inner_u, inner_v], [inner_u, -inner_v]), _line([inner_u, -inner_v], [root_u, -root_v]), _line([-root_u, -root_v], [-inner_u, -inner_v]), _line([-inner_u, -inner_v], [-inner_u, inner_v]), _line([-inner_u, inner_v], [-root_u, root_v]), ] entities.extend(_build_circle_entities(profile.get("circles") or [])) return entities, contour def _gen_filleted_rect_side_slots(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: """圆角矩形+两侧中心凹槽。 形状：圆角矩形，左右两侧中心各有一个 U 形凹槽（半圆槽）。 参数: half_width_mm: 矩形半宽（不含圆角） half_height_mm: 矩形半高（不含圆角） corner_radius_mm: 四角圆角半径 slot_radius_mm: 两侧中心凹槽半径（默认 5.0） circles: 可选内部圆（孔洞），[{center:[x,y], radius_mm:r}, …] 覆盖文件: 58, 63, 64, 65, 66 """ hw = float(profile["half_width_mm"]) hh = float(profile["half_height_mm"]) cr = float(profile["corner_radius_mm"]) sr = float(profile.get("slot_radius_mm") or cr * 0.5) # 注意: v=-Z, 所以 v 正方向朝 Z 负 # 矩形范围: u=[-hw,hw], v=[-hh,+hh] 对应 z=[+hh,-hh] # 上边 (z=+hh): v=-hh, 下边 (z=-hh): v=+hh entities, contour = [], [] top_v, bot_v = -hh, hh # 上边 v=-hh, 下边 v=+hh # 上边（直线，从左上角到右上角） contour.append(_contour_line( [-(hw - cr), top_v, 0.0], [(hw - cr), top_v, 0.0])) entities.append(_line([-(hw - cr), top_v], [(hw - cr), top_v])) # 右上圆角（逆时针绕 center: 从顶点到右侧） contour.append(_contour_arc( [(hw - cr), top_v, 0.0], [hw, top_v + cr, 0.0], [(hw - cr), top_v + cr, 0.0], cr)) # 右边上半（从圆角到凹槽上方） contour.append(_contour_line( [hw, top_v + cr, 0.0], [hw, -sr, 0.0])) entities.append(_line([hw, top_v + cr], [hw, -sr])) # 右侧中心凹槽（半圆向内的 U 形凹口） contour.append(_contour_arc( [hw, sr, 0.0], [hw, -sr, 0.0], [hw, 0.0, 0.0], sr)) # 右边下半（从凹槽下方到右下角） contour.append(_contour_line( [hw, sr, 0.0], [hw, bot_v - cr, 0.0])) entities.append(_line([hw, sr], [hw, bot_v - cr])) # 右下圆角 contour.append(_contour_arc( [hw, bot_v - cr, 0.0], [(hw - cr), bot_v, 0.0], [(hw - cr), bot_v - cr, 0.0], cr)) # 下边 contour.append(_contour_line( [(hw - cr), bot_v, 0.0], [-(hw - cr), bot_v, 0.0])) entities.append(_line([(hw - cr), bot_v], [-(hw - cr), bot_v])) # 左下圆角 contour.append(_contour_arc( [-(hw - cr), bot_v, 0.0], [-hw, bot_v - cr, 0.0], [-(hw - cr), bot_v - cr, 0.0], cr)) # 左边下半 contour.append(_contour_line( [-hw, bot_v - cr, 0.0], [-hw, sr, 0.0])) entities.append(_line([-hw, bot_v - cr], [-hw, sr])) # 左侧中心凹槽 contour.append(_contour_arc( [-hw, -sr, 0.0], [-hw, sr, 0.0], [-hw, 0.0, 0.0], sr)) # 左边上半 contour.append(_contour_line( [-hw, -sr, 0.0], [-hw, top_v + cr, 0.0])) entities.append(_line([-hw, -sr], [-hw, top_v + cr])) # 左上圆角 contour.append(_contour_arc( [-hw, top_v + cr, 0.0], [-(hw - cr), top_v, 0.0], [-(hw - cr), top_v + cr, 0.0], cr)) entities.extend(_build_circle_entities(profile.get("circles") or [])) return entities, contour # ═══════════════════════════════════════════════════════════════ # 更多弧边复合轮廓生成器 # ═══════════════════════════════════════════════════════════════ def _gen_d_shape(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: """D形（半圆+弦线）：一条直线 + 一条大圆弧，形如字母 D。 参数: radius_mm: 大弧半径（圆心在原点） chord_sign: 弦线方向，"left"=弦在 x>0 侧，"right"=弦在 x<0 侧 默认 "left"（弦线在 +x 侧，弧形开口朝 -x） 覆盖文件: 144358 """ import math R = float(profile["radius_mm"]) side = profile.get("chord_sign", "left") sign = 1 if side == "left" else -1 # chord at x=cx (cx^2 + y^2 = R^2) # For side="left": chord at x = sqrt(R^2 - y_len^2) ... # Actually, from 144358 data: arc r=41 c=(0,0) from (34,22.9) to (34,-22.9) # So the chord is at x=34, v ranges from -22.9 to 22.9 # v_max = sqrt(R^2 - x^2) = sqrt(41^2 - 34^2) = sqrt(1681-1156) = sqrt(525) ≈ 22.91 ✓ v_max = math.sqrt(max(0.0, R * R - (R - 7) * (R - 7))) # 实际上，chord x 可以根据 radius 推导 # 使用 chord_x 参数如果存在，否则用近似 chord_x = float(profile.get("chord_x_mm") or R * 0.83) # 默认在半径 83% 处 v_half = math.sqrt(max(0.0, R * R - chord_x * chord_x)) cx = sign * chord_x # 弦线 x 坐标 contour = [ # 弦线（从下到上） _contour_line([cx, -v_half, 0.0], [cx, v_half, 0.0]), # 大弧（从右上到左下，即从左到右沿弧线） _contour_arc([cx, v_half, 0.0], [cx, -v_half, 0.0], [0.0, 0.0, 0.0], R), ] entities = [ _line([cx, -v_half], [cx, v_half]), ] entities.extend(_build_circle_entities(profile.get("circles") or [])) return entities, contour def _gen_partial_ring(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: """部分圆环（同心圆弧+径向直线）：两段同心弧 + 两条径向线。 形状像一个扇区环 (sector annulus)，由内外两段同心弧和两侧径向线组成。 参数: inner_radius_mm: 内弧半径 outer_radius_mm: 外弧半径 half_angle_deg: 弧的半角度（两侧各 half_angle 度，总张角 2*half_angle） 覆盖文件: 177126 """ import math ir = float(profile["inner_radius_mm"]) oR = float(profile["outer_radius_mm"]) h_deg = float(profile.get("half_angle_deg") or 45.0) h_rad = math.radians(h_deg) # 内弧端点 iu_pos = ir * math.cos(h_rad) iv_pos = ir * math.sin(h_rad) iu_neg = ir * math.cos(-h_rad) iv_neg = ir * math.sin(-h_rad) # 外弧端点 ou_pos = oR * math.cos(h_rad) ov_pos = oR * math.sin(h_rad) ou_neg = oR * math.cos(-h_rad) ov_neg = oR * math.sin(-h_rad) contour = [ # 右侧径向线（从内弧到外弧，+h角度） _contour_line([iu_pos, iv_pos, 0.0], [ou_pos, ov_pos, 0.0]), # 外弧（从 +h 到 -h） _contour_arc([ou_neg, ov_neg, 0.0], [ou_pos, ov_pos, 0.0], [0.0, 0.0, 0.0], oR), # 左侧径向线（从外弧到内弧，-h角度） _contour_line([ou_neg, ov_neg, 0.0], [iu_neg, iv_neg, 0.0]), # 内弧（从 -h 到 +h） _contour_arc([iu_pos, iv_pos, 0.0], [iu_neg, iv_neg, 0.0], [0.0, 0.0, 0.0], ir), ] entities = [ _line([iu_pos, iv_pos], [ou_pos, ov_pos]), _line([ou_neg, ov_neg], [iu_neg, iv_neg]), ] entities.extend(_build_circle_entities(profile.get("circles") or [])) return entities, contour def _gen_partial_ring_with_arc_island(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: """扇区环 + 外弦上的等宽弧岛（岛不切除，作为区域内孔）。 每个 replica 生成一块「外轮廓=扇区环、内孔=偏移弧岛」的区域。 岛外弧端点落在扇区外弧弦上，横坐标取 ±inner·cos(half_angle)（相对角平分线）。 参数: inner_radius_mm / outer_radius_mm / half_angle_deg: 扇区环 island_radius_mm: 岛外弧半径 island_gap_mm: 岛内外弧径向间距（等宽） center_angles_deg 或 replicas[{center_angle_deg}]: 各扇区角平分线方向（度） 覆盖: b005 """ ir = float(profile["inner_radius_mm"]) oR = float(profile["outer_radius_mm"]) h_deg = float(profile.get("half_angle_deg") or 45.0) island_r = float(profile["island_radius_mm"]) gap = float(profile.get("island_gap_mm") or 1.0) if ir <= 0 or oR <= ir or island_r <= gap: raise ValueError("partial_ring_with_arc_island: invalid radii") replicas = profile.get("replicas") if replicas: angles = [float(r["center_angle_deg"]) for r in replicas] else: angles = [float(a) for a in (profile.get("center_angles_deg") or [0.0])] h = math.radians(h_deg) entities: list[_Ctx] = [] regions: list[dict[str, Any]] = [] for ca_deg in angles: ca = math.radians(ca_deg) a0, a1 = ca - h, ca + h def polar(r: float, ang: float) -> list[float]: return [r * math.cos(ang), r * math.sin(ang), 0.0] # 扇区环外轮廓（逆时针：外弧 a0→a1，径向，内弧 a1→a0，径向） ou0, ou1 = polar(oR, a0), polar(oR, a1) iu0, iu1 = polar(ir, a0), polar(ir, a1) outer = [ _contour_arc(ou0, ou1, [0.0, 0.0, 0.0], oR), _contour_line(ou1, iu1), _contour_arc(iu1, iu0, [0.0, 0.0, 0.0], ir), _contour_line(iu0, ou0), ] entities.extend([ _line(ou0[:2], ou1[:2]), _line(ou1[:2], iu1[:2]), _line(iu1[:2], iu0[:2]), _line(iu0[:2], ou0[:2]), ]) # 外弦中点与弦向单位向量；岛端点 = M ± inner·cos(h)·chord_dir ux, uy = math.cos(ca), math.sin(ca) mx = oR * ux * math.cos(h) my = oR * uy * math.cos(h) cdx, cdy = -uy, ux span = ir * math.cos(h) e1 = [mx + span * cdx, my + span * cdy, 0.0] e2 = [mx - span * cdx, my - span * cdy, 0.0] # 岛心在角平分线上：|E - t·u| = island_r，取距原点较近根 dot = e1[0] * ux + e1[1] * uy e2n = e1[0] * e1[0] + e1[1] * e1[1] disc = max(0.0, dot * dot - (e2n - island_r * island_r)) t1, t2 = dot - math.sqrt(disc), dot + math.sqrt(disc) t = t1 if abs(t1) <= abs(t2) else t2 cx, cy = t * ux, t * uy c3 = [cx, cy, 0.0] def inward(pt: list[float]) -> list[float]: vx, vy = cx - pt[0], cy - pt[1] L = math.hypot(vx, vy) or 1.0 return [pt[0] + vx / L * gap, pt[1] + vy / L * gap, 0.0] i1, i2 = inward(e1), inward(e2) ri = island_r - gap # 岛孔：外弧 e1→e2（经外侧鼓包）再经内弧返回；与扇区同向时作孔需反向 # 外弧走短弧中指向外侧（远离原点）的那条 hole = [ _contour_arc(e1, e2, c3, island_r), _contour_line(e2, i2), _contour_arc(i2, i1, c3, ri), _contour_line(i1, e1), ] entities.extend([ _line(e1[:2], e2[:2]), _line(e2[:2], i2[:2]), _line(i2[:2], i1[:2]), _line(i1[:2], e1[:2]), ]) regions.append({"outer": outer, "holes": [hole]}) meta["_regions"] = regions return entities, [] def _gen_arc_chain(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: """弧链轮廓：多段首尾相连的弧形成闭合轮廓（各弧可有不同圆心）。 用于 revolve 特征的截面草图，由多段圆弧端到端连接组成。 参数: arcs: 弧描述列表 [{radius_mm, center:[u,v], start_angle_deg, end_angle_deg}, ...] （每个弧从 start_angle 到 end_angle，起点与上一条弧终点重合） 覆盖文件: 020543 """ import math arc_list = profile.get("arcs") or [] if not arc_list or len(arc_list) < 2: raise ValueError("arc_chain needs at least 2 arcs") entities, contour = [], [] for arc_desc in arc_list: r = float(arc_desc["radius_mm"]) center = arc_desc.get("center") or [0.0, 0.0] cu, cv = float(center[0]), float(center[1]) sa = math.radians(float(arc_desc["start_angle_deg"])) ea = math.radians(float(arc_desc["end_angle_deg"])) su = cu + r * math.cos(sa) sv = cv + r * math.sin(sa) eu = cu + r * math.cos(ea) ev = cv + r * math.sin(ea) contour.append(_contour_arc( [su, sv, 0.0], [eu, ev, 0.0], [cu, cv, 0.0], r, )) entities.extend(_build_circle_entities(profile.get("circles") or [])) return entities, contour def _gen_radial_slot(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: """径向槽：两段同心圆弧 + 两端圆角，形如弧形环段。 用于 extrude_cut 在圆柱壁面上开弧形槽口。 参数: inner_radius_mm: 内弧半径 outer_radius_mm: 外弧半径 start_angle_deg: 槽起始角度（度，从工作平面 x_dir 方向逆时针测量） end_angle_deg: 槽终止角度 覆盖文件: 020543 (sk_02, sk_03, sk_04) """ import math ir = float(profile["inner_radius_mm"]) oR = float(profile["outer_radius_mm"]) sa_deg = float(profile["start_angle_deg"]) ea_deg = float(profile["end_angle_deg"]) fr = (oR - ir) / 2.0 # 端盖圆角半径 sa = math.radians(sa_deg) ea = math.radians(ea_deg) entities, contour = [], [] # 角度从工作平面 x_dir 方向测量 → u = r·cos(θ), v = r·sin(θ) # 1. 内弧（从 start→end） isu = ir * math.cos(sa); isv = ir * math.sin(sa) ieu = ir * math.cos(ea); iev = ir * math.sin(ea) contour.append(_contour_arc( [isu, isv, 0.0], [ieu, iev, 0.0], [0.0, 0.0, 0.0], ir, )) # 2. 终端圆角（半圆，从内弧终点到外弧终点） fc_u = (ir + oR) / 2.0 fcu_s = fc_u * math.cos(ea); fcv_s = fc_u * math.sin(ea) osu = oR * math.cos(sa); osv = oR * math.sin(sa) oeu = oR * math.cos(ea); oev = oR * math.sin(ea) contour.append(_contour_arc( [ieu, iev, 0.0], [oeu, oev, 0.0], [fcu_s, fcv_s, 0.0], fr, )) # 3. 外弧（从 end→start，反向） contour.append(_contour_arc( [oeu, oev, 0.0], [osu, osv, 0.0], [0.0, 0.0, 0.0], oR, )) # 4. 起始端圆角（从外弧起点到内弧起点） fcu_e = fc_u * math.cos(sa); fcv_e = fc_u * math.sin(sa) contour.append(_contour_arc( [osu, osv, 0.0], [isu, isv, 0.0], [fcu_e, fcv_e, 0.0], fr, )) entities.extend(_build_circle_entities(profile.get("circles") or [])) return entities, contour # ═══════════════════════════════════════════════════════════════ # 程序化重复切口 # ═══════════════════════════════════════════════════════════════ def _poly_contour(vertices: list[tuple[float, float]]) -> list[_Ctx]: """把按顺序给出的二维顶点变成闭合直线轮廓。""" return [ _contour_line( [vertices[i][0], vertices[i][1], 0.0], [vertices[(i + 1) % len(vertices)][0], vertices[(i + 1) % len(vertices)][1], 0.0], ) for i in range(len(vertices)) ] def _transform_pattern_contour( contour: list[_Ctx], x_mm: float, y_mm: float, angle_deg: float, scale: float = 1.0, ) -> list[_Ctx]: """旋转、缩放并平移一个二维轮廓。""" a = math.radians(angle_deg) ca, sa = math.cos(a), math.sin(a) def point(p: list[float]) -> list[float]: x, y = float(p[0]) * scale, float(p[1]) * scale return [x_mm + x * ca - y * sa, y_mm + x * sa + y * ca, 0.0] result: list[_Ctx] = [] for edge in contour: item = deepcopy(edge) item["start_mm"] = point(edge["start_mm"]) item["end_mm"] = point(edge["end_mm"]) if edge.get("center_mm") is not None: item["center_mm"] = point(edge["center_mm"]) if edge.get("radius_mm") is not None: item["radius_mm"] = float(edge["radius_mm"]) * scale result.append(item) return result def _pattern_motif_contour(motif: _Ctx) -> list[_Ctx]: """从少量命名尺寸生成一个切口母形。""" kind = str(motif.get("type") or "") if kind == "circle": radius = float(motif["radius_mm"]) return _gen_circle({"type": "circle", "radius_mm": radius}, {})[1] if kind in ("square", "rectangle"): width = float(motif["width_mm"]) height = float(motif.get("height_mm") or width) return _rect_lines_and_contour(-width / 2.0, -height / 2.0, width / 2.0, height / 2.0)[1] if kind == "obround": length = float(motif["length_mm"]) width = float(motif["width_mm"]) return _gen_obround( {"type": "obround", "center": [0.0, 0.0], "length_mm": length, "width_mm": width}, {}, )[1] if kind == "cross": size = float(motif["size_mm"]) arm = float(motif["arm_width_mm"]) half, arm_half = size / 2.0, arm / 2.0 vertices = [ (-arm_half, -half), (arm_half, -half), (arm_half, -arm_half), (half, -arm_half), (half, arm_half), (arm_half, arm_half), (arm_half, half), (-arm_half, half), (-arm_half, arm_half), (-half, arm_half), (-half, -arm_half), (-arm_half, -arm_half), ] return _poly_contour(vertices) if kind == "d_shape_polygon": stem = float(motif["stem_length_mm"]) nose = float(motif["nose_depth_mm"]) half_height = float(motif["half_height_mm"]) segments = int(motif.get("arc_segments") or 14) vertices = [(-stem, -half_height), (-stem, half_height), (0.0, half_height)] # 右半椭圆；首尾端点已由直线给出，内部取样由引擎固化。 for i in range(1, segments): angle = math.pi / 2.0 - math.pi * i / segments vertices.append((nose * math.cos(angle), half_height * math.sin(angle))) vertices.append((0.0, -half_height)) return _poly_contour(vertices) if kind == "regular_hexagon": radius = float(motif["radius_mm"]) return _poly_contour([ ( radius * math.cos(math.radians(60.0 * i)), radius * math.sin(math.radians(60.0 * i)), ) for i in range(6) ]) if kind == "skew_hexagon": # 该族来自六边形母形的非对称离散模板；只保留一个名义半径， # 其余稳定比例由引擎固化，不把六个顶点写进 CDSL。 radius = float(motif["nominal_radius_mm"]) return _poly_contour([ (radius, 0.0), (radius * 0.317014, radius * 0.682, ), (-radius * 0.5, radius * 0.682), (-radius * 1.183014, 0.0), (-radius * 0.408494, -radius * 0.774519), (radius * 0.317014, -radius * 0.774519), ]) if kind == "triangle": radius = float(motif["radius_mm"]) return _poly_contour([ ( radius * math.cos(math.radians(120.0 * i)), radius * math.sin(math.radians(120.0 * i)), ) for i in range(3) ]) if kind == "teardrop_polygon": if motif.get("left_width_mm") is not None: left = float(motif["left_width_mm"]) right = float(motif["right_width_mm"]) tip = float(motif["tip_height_mm"]) bottom = -float(motif["bottom_depth_mm"]) shoulder = float(motif["shoulder_height_mm"]) return _poly_contour([ (0.0, tip), (right, shoulder), (right, bottom), (-left, bottom), (-left, shoulder), ]) width = float(motif["width_mm"]) height = float(motif["height_mm"]) shoulder = float(motif.get("shoulder_fraction") or 0.58) half = width / 2.0 top = height / 2.0 bottom = -height / 2.0 shoulder_y = bottom + height * shoulder return _poly_contour([ (0.0, top), (half, shoulder_y), (half, bottom), (-half, bottom), (-half, shoulder_y), ]) if kind == "trapezoid": bottom = float(motif["bottom_width_mm"]) top = float(motif["top_width_mm"]) height = float(motif["height_mm"]) hh = height / 2.0 return _poly_contour([ (-bottom / 2.0, -hh), (bottom / 2.0, -hh), (top / 2.0, hh), (-top / 2.0, hh), ]) if kind == "annular_sector_polygon": inner = float(motif["inner_radius_mm"]) outer = float(motif["outer_radius_mm"]) half_angle = float(motif["half_angle_deg"]) segments = int(motif.get("arc_segments") or 8) outer_pts = [ ( outer * math.cos(math.radians(-half_angle + 2.0 * half_angle * i / segments)), outer * math.sin(math.radians(-half_angle + 2.0 * half_angle * i / segments)), ) for i in range(segments + 1) ] inner_pts = [ ( inner * math.cos(math.radians(half_angle - 2.0 * half_angle * i / segments)), inner * math.sin(math.radians(half_angle - 2.0 * half_angle * i / segments)), ) for i in range(segments + 1) ] return _poly_contour(outer_pts + inner_pts) raise ValueError(f"patterned_cutouts: unsupported motif type {kind!r}") def _pattern_placements(layout: _Ctx) -> list[tuple[float, float, float, float]]: """展开语义布局，返回 (x, y, rotation_deg, scale)。""" kind = str(layout.get("type") or "") orientation = str(layout.get("orientation") or "fixed") orientation_offset = float(layout.get("orientation_offset_deg") or 0.0) def orient(angle: float) -> float: if orientation == "radial": return angle + orientation_offset if orientation == "tangential": return angle + 90.0 + orientation_offset if orientation == "snapped_radial": snap = float(layout.get("orientation_snap_deg") or 45.0) return round(angle / snap) * snap + orientation_offset return orientation_offset if kind in ("ring", "angular"): radius = float(layout.get("radius_mm") or 0.0) count = int(layout["count"]) start = float(layout.get("start_angle_deg") or 0.0) step = float(layout.get("angle_step_deg") or (360.0 / count)) angular_only = kind == "angular" return [ ( 0.0 if angular_only else radius * math.cos(math.radians(start + i * step)), 0.0 if angular_only else radius * math.sin(math.radians(start + i * step)), orient(start + i * step), 1.0, ) for i in range(count) ] if kind == "concentric_rings": result: list[tuple[float, float, float, float]] = [] for ring in layout.get("rings") or []: merged = dict(layout) merged.update(ring) merged["type"] = "ring" result.extend(_pattern_placements(merged)) return result if kind == "disc_grid": nx, ny = int(layout["count_x"]), int(layout["count_y"]) sx, sy = float(layout["spacing_x_mm"]), float(layout["spacing_y_mm"]) center = layout.get("center_mm") or [0.0, 0.0] x0 = float(center[0]) - (nx - 1) * sx / 2.0 y0 = float(center[1]) - (ny - 1) * sy / 2.0 limit = layout.get("max_center_radius_mm") points = [ (x0 + i * sx, y0 + j * sy) for j in range(ny) for i in range(nx) ] if limit is not None: points = [(x, y) for x, y in points if math.hypot(x, y) <= float(limit) + 1e-9] return [(x, y, orientation_offset, 1.0) for x, y in points] if kind == "open_arc": radius = float(layout["radius_mm"]) count = int(layout["count"]) start, end = float(layout["start_angle_deg"]), float(layout["end_angle_deg"]) step = 0.0 if count == 1 else (end - start) / (count - 1) return [ ( radius * math.cos(math.radians(start + i * step)), radius * math.sin(math.radians(start + i * step)), orient(start + i * step), 1.0, ) for i in range(count) ] if kind == "spiral": count = int(layout["count"]) start_radius = float(layout["start_radius_mm"]) radius_step = float(layout["radius_step_mm"]) start_angle = float(layout.get("start_angle_deg") or 0.0) angle_step = float(layout["angle_step_deg"]) result = [] for i in range(count): radius = start_radius + i * radius_step angle = start_angle + i * angle_step result.append(( radius * math.cos(math.radians(angle)), radius * math.sin(math.radians(angle)), orient(angle), 1.0, )) return result if kind == "cross_lines": count = int(layout["count_per_axis"]) spacing = float(layout["spacing_mm"]) start = -(count - 1) * spacing / 2.0 result = [] for i in range(count): value = start + i * spacing result.append((value, 0.0, orientation_offset, 1.0)) result.append((0.0, value, orientation_offset + 90.0, 1.0)) return result if kind == "x_field": levels = int(layout["levels"]) spacing = float(layout["spacing_mm"]) start = -(levels - 1) * spacing / 2.0 result = [] for i in range(levels): value = start + i * spacing if abs(value) < 1e-9: rotation = 135.0 + orientation_offset if orientation == "diagonal_axes" else orientation_offset result.append((0.0, 0.0, rotation, 1.0)) else: for y in (value, -value): if orientation == "diagonal_axes": rotation = (135.0 if value * y > 0 else 45.0) + orientation_offset else: angle = math.degrees(math.atan2(y, value)) rotation = orient(angle) result.append((value, y, rotation, 1.0)) return result if kind == "twin_strips": x_offset = float(layout["x_offset_mm"]) count = int(layout["count_y"]) y_start = float(layout["y_start_mm"]) y_end = float(layout["y_end_mm"]) step = 0.0 if count == 1 else (y_end - y_start) / (count - 1) return [ (x, y_start + j * step, orientation_offset, 1.0) for j in range(count) for x in (-x_offset, x_offset) ] if kind == "corner_clusters": levels = [float(v) for v in (layout.get("levels_mm") or [])] return [ (sx * x, sy * y, orientation_offset, 1.0) for sx in (-1.0, 1.0) for sy in (-1.0, 1.0) for y in levels for x in levels ] if kind == "diamond_field": radius = int(layout["manhattan_radius"]) spacing = float(layout["spacing_mm"]) return [ (i * spacing, j * spacing, orientation_offset, 1.0) for distance in range(radius + 1) for j in range(-radius, radius + 1) for i in range(-radius, radius + 1) if abs(i) + abs(j) == distance ] raise ValueError(f"patterned_cutouts: unsupported layout type {kind!r}") def _gen_patterned_cutouts(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: """一个母形 + 一个语义布局，运行时展开成多个独立切除区域。""" motif = profile.get("motif") or {} layout = profile.get("layout") or {} base = _pattern_motif_contour(motif) regions = [] for x, y, angle, scale in _pattern_placements(layout): regions.append({ "outer": _transform_pattern_contour(base, x, y, angle, scale), "holes": [], }) if not regions: raise ValueError("patterned_cutouts: layout produced no regions") meta["_regions"] = regions return [], [] def _gen_compound_patterned_cutouts(profile: _Ctx, meta: _Ctx) -> tuple[list[_Ctx], list[_Ctx]]: """把少量不同母形/布局的程序化图案合并到同一草图。""" regions: list[_Ctx] = [] for pattern in profile.get("patterns") or []: motif = pattern.get("motif") or {} layout = pattern.get("layout") or {} base = _pattern_motif_contour(motif) for x, y, angle, scale in _pattern_placements(layout): regions.append({ "outer": _transform_pattern_contour(base, x, y, angle, scale), "holes": [], }) if not regions: raise ValueError("compound_patterned_cutouts: patterns produced no regions") meta["_regions"] = regions return [], [] # ═══════════════════════════════════════════════════════════════ # 生成器注册表 —— 唯一索引点 # ═══════════════════════════════════════════════════════════════ SHAPE_GENERATORS: dict[str, Any] = { "circle": _gen_circle, "annulus": _gen_annulus, "circles": _gen_circles, "circle_grid": _gen_circle_grid, "rectangle": _gen_rectangle, "rectangle_with_circles": _gen_rect_with_circles, "rectangle_with_fillets": _gen_rect_with_fillets, "obround": _gen_obround, "polygon": _gen_polygon, "ibone": _gen_ibone, "rectangle_with_symmetric_notches": _gen_rect_symmetric_notches, "revolve_chamfer": _gen_revolve_chamfer, "revolve_chamfer_slanted": _gen_revolve_chamfer_slanted, # 弧边复合轮廓（按 015133 手册方法注册，同形异构通过参数复用） "circle_with_arc_notches": _gen_circle_with_arc_notches, "circular_sector_slot": _gen_circular_sector_slot, "circle_with_radial_tabs": _gen_circle_with_radial_tabs, "filleted_rect_side_slots": _gen_filleted_rect_side_slots, # 弧边形状 "d_shape": _gen_d_shape, "partial_ring": _gen_partial_ring, "partial_ring_with_arc_island": _gen_partial_ring_with_arc_island, "radial_slot": _gen_radial_slot, "patterned_cutouts": _gen_patterned_cutouts, "compound_patterned_cutouts": _gen_compound_patterned_cutouts, "arc_chain": _gen_arc_chain, "complex_arc_shape": _gen_polygon, # 从 compiler_context entities 重建 "unknown_shape": _gen_polygon, # 未分类形状也走 compiler_context 回退 } # ═══════════════════════════════════════════════════════════════ # 注册表功能：扩展、查询 # ═══════════════════════════════════════════════════════════════ def register_shape(ptype: str, generator: Any) -> None: """注册一个新的轮廓生成器。扩展用途。""" SHAPE_GENERATORS[ptype] = generator def list_registered_shapes() -> list[str]: """返回所有已注册的形状生成器名称。""" return sorted(SHAPE_GENERATORS.keys()) # ═══════════════════════════════════════════════════════════════ # 形状能力矩阵（供外部查询：哪些形状可自动检测，哪些需手动指定） # ═══════════════════════════════════════════════════════════════ _ShapeInfo = dict[str, Any] SHAPE_CAPABILITIES: dict[str, _ShapeInfo] = { "circle": {"detectable": True, "arity": "circle", "description": "单圆"}, "annulus": {"detectable": True, "arity": "circles", "description": "同心圆环"}, "circles": {"detectable": True, "arity": "circles", "description": "多圆（非同心）"}, "circle_grid": {"detectable": False, "arity": "circles", "description": "矩形圆孔阵列"}, "rectangle": {"detectable": True, "arity": "polygon", "description": "4线矩形"}, "rectangle_with_circles": {"detectable": True, "arity": "mixed", "description": "矩形+内圆孔"}, "rectangle_with_fillets": {"detectable": False, "arity": "mixed", "description": "圆角矩形（4弧+4线）"}, "obround": {"detectable": True, "arity": "mixed", "description": "槽形/键槽（2线+2半圆弧）"}, "polygon": {"detectable": True, "arity": "polygon", "description": "N边多边形"}, "ibone": {"detectable": False, "arity": "mixed", "description": "工字形凸耳（12线+4弧+4孔）"}, "rectangle_with_symmetric_notches": {"detectable": False,"arity": "mixed", "description": "对称槽板（矩形+4U形缺口）"}, "revolve_chamfer": {"detectable": True, "arity": "polygon", "description": "旋转梯形截面"}, "revolve_chamfer_slanted": {"detectable": True, "arity": "polygon", "description": "旋转斜底梯形截面"}, "circle_with_arc_notches": {"detectable": False, "arity": "mixed", "description": "圆+均匀弧形凹口"}, "circular_sector_slot": {"detectable": False, "arity": "mixed", "description": "圆弧扇区+中心矩形槽"}, "circle_with_radial_tabs": {"detectable": False, "arity": "mixed", "description": "圆+径向矩形凸耳"}, "filleted_rect_side_slots": {"detectable": False, "arity": "mixed", "description": "圆角矩形+两侧中心U形槽"}, "d_shape": {"detectable": True, "arity": "mixed", "description": "D形（半圆+弦线）"}, "partial_ring": {"detectable": True, "arity": "mixed", "description": "部分圆环（扇区环）"}, "partial_ring_with_arc_island": {"detectable": False, "arity": "mixed", "description": "扇区环+弦上偏移弧岛"}, "radial_slot": {"detectable": False, "arity": "mixed", "description": "径向弧形槽"}, "arc_chain": {"detectable": False, "arity": "arcs", "description": "多段弧链轮廓"}, "patterned_cutouts": {"detectable": False, "arity": "regions", "description": "程序化重复切口"}, "compound_patterned_cutouts": {"detectable": False, "arity": "regions", "description": "复合程序化重复切口"}, } # ═══════════════════════════════════════════════════════════════ # 主入口 # ═══════════════════════════════════════════════════════════════ def resolve_profile(sketch: dict[str, Any]) -> dict[str, Any]: """按 type 查找生成器，生成 entities + contour_edges_mm。 对于返回非空 contour 的生成器，会额外保留原始 sketch.entities 中的非 construction circle 实体（孔洞/圆岛），确保不丢失内部特征。 """ profile = sketch.get("profile") if not profile: return sketch ptype = profile.get("type") generator = SHAPE_GENERATORS.get(ptype) if generator is None: raise ValueError(f"sketch {sketch.get('id')}: unsupported profile type {ptype!r}") meta = {"id": sketch.get("id"), "name": sketch.get("name"), "_entities": sketch.get("entities"), "_contour": sketch.get("contour_edges_mm")} entities, contour = generator(profile, meta) out = deepcopy(sketch) # 保留原始草图中的非 construction circle 实体（这些是内部孔洞/圆岛） orig_ents = sketch.get("entities") or [] keep_circles = [ e for e in orig_ents if e.get("type") == "circle" and not e.get("construction") ] if keep_circles and contour: # 只对生成器产出 contour 的场合保留 circles（轮廓生成器 + 内部圆孔） entities = list(entities) + keep_circles out["entities"] = entities wp = sketch.get("workplane") if contour: out["contour_edges_mm"] = _transform_contours(contour, wp) if wp else contour regions = meta.get("_regions") or [] if regions: out["contour_regions_mm"] = [ { "outer": _transform_contours(reg["outer"], wp) if wp else reg["outer"], "holes": [ _transform_contours(hole, wp) if wp else hole for hole in (reg.get("holes") or []) ], } for reg in regions ] return out def resolve_all_sketches(cdsl: dict[str, Any]) -> dict[str, Any]: """对 CDSL 中所有带 profile 字段的草图进行解析。 支持 profile_from 字段：引用另一个草图的 profile，避免重复。 例：sk_05: {"profile_from": "sk_03"} → 使用 sk_03 的 profile。 """ geom = cdsl.get("geometry") or {} sketches = geom.get("sketches") or [] # 第一遍: 解析所有有自己 profile 的草图 resolved: dict[str, dict] = {} for sk in sketches: sid = sk.get("id") if sid is None: continue if "profile" in sk: resolved[sid] = resolve_profile(sk) # 第二遍: 解析 profile_from 引用（支持 profile_shift 偏移） for sk in sketches: sid = sk.get("id") pf = sk.get("profile_from") if pf and sid: src = resolved.get(pf) if src is None: raise ValueError( f"sketch {sid}: profile_from={pf!r} not found or not yet resolved" ) sk2 = deepcopy(sk) sk2["profile"] = deepcopy(src.get("profile")) sk2.pop("profile_from", None) # profile_shift: 对 polygon 顶点做 2D 偏移（同形异构共享） shift = sk.get("profile_shift") if shift and len(shift) == 2 and sk2["profile"].get("type") == "polygon": du, dv = float(shift[0]), float(shift[1]) for v in sk2["profile"]["vertices"]: v[0] = round(v[0] + du, 6) v[1] = round(v[1] + dv, 6) sk2.pop("profile_shift", None) resolved[sid] = resolve_profile(sk2) # 按原顺序输出 result = [] for sk in sketches: sid = sk.get("id") if sid and sid in resolved: result.append(resolved[sid]) else: result.append(deepcopy(sk)) out = deepcopy(cdsl) out.setdefault("geometry", {})["sketches"] = result return out