From 72ff3986347e7d15b79ce1b39e0cf3bdc6be39c5 Mon Sep 17 00:00:00 2001 From: ganjihong Date: Tue, 25 Aug 2026 13:45:30 +0800 Subject: [PATCH 1/4] =?UTF-8?q?docs(backend):=20=E4=B8=BA=20build123d=5Fad?= =?UTF-8?q?apter=20=E6=B7=BB=E5=8A=A0=E4=B8=AD=E6=96=87=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../engine/cdsl_engine/build123d_adapter.py | 64 +++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/backend/engine/cdsl_engine/build123d_adapter.py b/backend/engine/cdsl_engine/build123d_adapter.py index 0e81abcd..511f117d 100644 --- a/backend/engine/cdsl_engine/build123d_adapter.py +++ b/backend/engine/cdsl_engine/build123d_adapter.py @@ -11,26 +11,33 @@ from .runtime_types import AxisSpec, HoleSpec, PlaneSpec, TopologyRecord, Vector def _vector(value: list[float] | tuple[float, float, float]) -> Vector: + # 将三元坐标（list 或 tuple）转换为 build123d 的 Vector 对象。 return Vector(float(value[0]), float(value[1]), float(value[2])) def _arc_midpoint(edge: dict[str, Any], start: Vector, end: Vector, center: Vector) -> Vector: + # 计算圆弧中点（配合 Edge.make_three_point_arc 三点画弧），支持显式法向与顺时针/逆时针方向。 + # 1. 半径：优先取 edge.radius_mm，缺省时由圆心到起点的距离推算。 radius = float(edge.get("radius_mm") or (start - center).length) first = start - center second = end - center + # 2. 起点或终点与圆心重合时，圆弧退化为线段，中点取两端中点。 if first.length <= 1e-9 or second.length <= 1e-9: return (start + end) / 2 + # 3. 确定圆弧所在平面法向：优先显式 normal，其次由两半径向量叉积推得，最后回退到 +Z。 normal = _vector(edge.get("normal") or [0, 0, 1]) if normal.length <= 1e-9: normal = first.cross(second) if normal.length <= 1e-9: normal = Vector(0, 0, 1) normal = normal.normalized() + # 4. 未指定旋转方向：取两条半径单位向量之和（角平分线）指向圆弧中点。 if "clockwise" not in edge: bisector = first.normalized() + second.normalized() if bisector.length <= 1e-9: bisector = normal.cross(first) return center + bisector.normalized() * radius + # 5. 指定了方向：按有符号扫掠角规整到 (−π, π]，再沿首半径旋转半角得到中点。 sweep = math.atan2(normal.dot(first.cross(second)), first.dot(second)) if bool(edge["clockwise"]): if sweep >= 0: @@ -47,34 +54,43 @@ class Build123dGeometryAdapter: @staticmethod def plane(spec: PlaneSpec) -> Plane: + # 将运行时平面定义 PlaneSpec 转换为 build123d 的 Plane。 return Plane(origin=_vector(spec.origin_mm), x_dir=_vector(spec.x_dir), z_dir=_vector(spec.normal)) @staticmethod def axis(spec: AxisSpec) -> Axis: + # 将运行时轴定义 AxisSpec 转换为 build123d 的 Axis。 return Axis(origin=_vector(spec.origin_mm), direction=_vector(spec.direction)) @staticmethod def _wire(edges: list[dict[str, Any]]) -> Wire: + # 将边字典列表（直线/圆弧）组装成 build123d 的 Wire 线框。 built: list[Edge] = [] for edge in edges: start = _vector(edge["start_mm"]) end = _vector(edge["end_mm"]) if edge.get("type") == "arc" and edge.get("center_mm") is not None: + # 圆弧边：由起点、中点、终点三点构造圆弧。 center = _vector(edge["center_mm"]) built.append(Edge.make_three_point_arc(start, _arc_midpoint(edge, start, end, center), end)) else: + # 直线边：直接连接首尾。 built.append(Edge.make_line(start, end)) return Wire(built) def _circle_wire(self, center: list[float], radius: float, plane_spec: PlaneSpec) -> Wire: + # 在草图工作平面上，按局部二维圆心与半径生成整圆 Wire（圆心由工作平面原点 + x/y 方向线性组合得到）。 origin = Vector(*plane_spec.origin_mm) + Vector(*plane_spec.x_dir) * float(center[0]) + Vector(*plane_spec.y_dir) * float(center[1]) circle_plane = Plane(origin=origin, x_dir=Vector(*plane_spec.x_dir), z_dir=Vector(*plane_spec.normal)) return Wire.make_circle(radius, circle_plane) def _faces_from_circles(self, entities: list[dict[str, Any]], plane_spec: PlaneSpec) -> list[Face]: + # 由草图中的实体圆生成面，按圆间包含关系识别孔洞并跳过落入孔洞区的圆。 + # 1. 筛选非构造圆；没有实体圆时直接返回空列表。 circles = [item for item in entities if item.get("type") == "circle" and not item.get("construction")] if not circles: return [] + # 2. 逐个生成整圆 Wire，非法半径（≤0）的圆跳过。 entries = [] for item in circles: radius = float(item.get("radius_mm") or 0) @@ -84,6 +100,7 @@ class Build123dGeometryAdapter: entries.append({"center": center, "radius": radius, "wire": self._circle_wire(center, radius, plane_spec)}) faces: list[Face] = [] for entry in entries: + # 3. 统计当前圆被多少个更大圆完整包含；被奇数层包含说明其处于孔洞区，跳过不建面。 containing = sum( math.dist(entry["center"], other["center"]) + entry["radius"] < other["radius"] - 1e-8 for other in entries @@ -91,6 +108,7 @@ class Build123dGeometryAdapter: ) if containing % 2: continue + # 4. 收集直接包在自身内部的圆作为孔洞，且它们只能被当前这一层包含。 holes = [ other["wire"] for other in entries @@ -101,11 +119,14 @@ class Build123dGeometryAdapter: if candidate is not other ) == containing + 1 ] + # 5. 以当前圆为外轮廓建面，必要时打孔。 face = Face(entry["wire"]) faces.append(face.make_holes(holes) if holes else face) return faces def faces_for_sketch(self, sketch: dict[str, Any]) -> list[Face]: + # 从草图数据解析出可拉伸/旋转的轮廓面，按三种数据来源依次回退。 + # 1. 优先使用预计算的轮廓区域 contour_regions_mm（外轮廓 + 孔洞列表）。 regions = sketch.get("contour_regions_mm") or [] if regions: result: list[Face] = [] @@ -117,23 +138,28 @@ class Build123dGeometryAdapter: holes = [self._wire(hole) for hole in region.get("holes") or [] if len(hole) >= 2] result.append(face.make_holes(holes) if holes else face) return result + # 2. 退化：仅有单组轮廓边时，直接作为外轮廓建面。 edges = sketch.get("contour_edges_mm") or [] if len(edges) >= 2: return [Face(self._wire(edges))] + # 3. 最终回退：由工作平面与实体圆生成面（圆环/孔洞处理见 _faces_from_circles）。 plane = PlaneSpec.from_mapping(sketch.get("workplane") or {}) return self._faces_from_circles(sketch.get("entities") or [], plane) @staticmethod def extrude(face: Face, direction: Vector3) -> Solid: + # 沿给定方向向量拉伸一个面，生成实体。 return Solid.extrude(face, _vector(direction)) @staticmethod def body_center(body: Any) -> Vector3: + # 取主体包围盒的中心坐标，作为体心的近似。 bbox = body.bounding_box() return ((bbox.min.X + bbox.max.X) / 2, (bbox.min.Y + bbox.max.Y) / 2, (bbox.min.Z + bbox.max.Z) / 2) @staticmethod def body_span(body: Any, direction: Vector3) -> float: + # 计算主体在指定方向上的最大跨度：8 个包围盒角点沿方向投影后取极差。 unit = _vector(direction).normalized() bbox = body.bounding_box() values = [ @@ -146,6 +172,7 @@ class Build123dGeometryAdapter: @staticmethod def vertex_coordinates(vertex: Any) -> Vector3: + # 提取顶点的三维坐标元组。 return (float(vertex.X), float(vertex.Y), float(vertex.Z)) @staticmethod @@ -157,10 +184,13 @@ class Build123dGeometryAdapter: boundary samples let the runtime prove that precondition instead of silently constructing a wrong prismatic solid. """ + # 采样轮廓面的代表性点：面心 + 每条边的 0/0.25/0.5/0.75 参数点， + # 用于后续校验目标面到轮廓的距离是否处处一致。 points = [face.center()] for edge in face.edges(): for fraction in (0.0, 0.25, 0.5, 0.75): points.append(edge.position_at(fraction)) + # 去重：彼此距离在 1e-6 内的采样点只保留一个，减少重复求交。 unique: list[Vector] = [] for point in points: if not any((point - current).length <= 1e-6 for current in unique): @@ -169,10 +199,12 @@ class Build123dGeometryAdapter: @staticmethod def _forward_intersection_distance(target: Any, point: Vector, direction: Vector) -> float | None: + # 从 point 沿 direction 发一条射线，求与目标的第一个正向交点距离。 try: intersections = target.find_intersection_points(Axis(point, direction)) or [] except Exception as error: raise ValueError("extent target does not support ray intersection") from error + # 只保留方向一致（点积 > 0）的交点，返回其中最近距离；无交点则返回 None。 distances = [ (hit_point - point).dot(direction) for hit_point, _normal in intersections @@ -182,6 +214,7 @@ class Build123dGeometryAdapter: def uniform_intersection_distance(self, target: Any, faces: Iterable[Face], direction: Vector3) -> float: """Return a proven uniform positive target distance for a profile set.""" + # 对所有轮廓采样点求到目标的距离，各点距离必须一致，简单拉伸才能精确表达终止条件。 unit_direction = _vector(direction).normalized() distances: list[float] = [] for face in faces: @@ -199,34 +232,44 @@ class Build123dGeometryAdapter: @staticmethod def revolve(face: Face, angle_deg: float, axis: AxisSpec) -> Solid: + # 绕给定轴将面旋转指定角度，生成回转实体。 return Solid.revolve(face, angle_deg, Build123dGeometryAdapter.axis(axis)) @staticmethod def fuse(body: Any | None, solid: Solid) -> Any: + # 布尔并：没有既有主体时，直接以该实体作为新主体。 return solid if body is None else body.fuse(solid) @staticmethod def cut(body: Any, tool: Any) -> Any: + # 从主体上减去工具实体。 return body.cut(tool) @staticmethod def sphere(radius_mm: float, center_mm: Vector3) -> Solid: + # 以给定球心与半径生成球体实体。 return Solid.make_sphere(radius_mm, Plane(origin=_vector(center_mm))) def hole_tool(self, spec: HoleSpec, starts: Iterable[Vector3], inward: Vector3, through_depth_mm: float) -> Solid: """Build a neutral ``HoleSpec`` into one OCC cutting tool.""" + # 将孔规格 HoleSpec 转成一个可直接切除的 OCC 工具体。 + # 1. 深度：通孔取贯穿深度（保证穿透），盲孔取规格中的深度。 depth = through_depth_mm if spec.end_condition != "blind" else spec.depth_mm result: Solid | None = None for start in starts: + # 2. 每个孔位：以起点为原点、向内方向为轴向，先生成主孔圆柱。 plane = Plane(origin=_vector(start), z_dir=_vector(inward)) tool = Solid.make_cylinder(spec.diameter_mm / 2, depth, plane) + # 3. 沉孔（counterbore）：在主孔上并一个更大直径、更浅的短圆柱。 if spec.counterbore: diameter, bore_depth = spec.counterbore tool = tool.fuse(Solid.make_cylinder(diameter / 2, bore_depth, plane)) + # 4. 锪孔（countersink）：按锥角与口径差推得锥深，并一个上大下小的圆锥。 if spec.countersink: diameter, angle = spec.countersink sink_depth = ((diameter - spec.diameter_mm) / 2) / math.tan(angle / 2) tool = tool.fuse(Solid.make_cone(diameter / 2, spec.diameter_mm / 2, sink_depth, plane)) + # 5. 汇总所有孔位的工具实体。 result = self.fuse(result, tool) if result is None: raise ValueError("hole has no positions") @@ -234,6 +277,7 @@ class Build123dGeometryAdapter: @staticmethod def fillet(body: Any, radius_mm: float, edges: Iterable[Edge]) -> Any: + # 对指定边以给定半径做圆角。 return body.fillet(radius_mm, list(edges)) @staticmethod @@ -244,8 +288,10 @@ class Build123dGeometryAdapter: global edge set or source stable IDs, and is consequently safe after a body mutation invalidates earlier topology objects. """ + # 从种子边出发，沿“共顶点且切线平行”的边链扩展，得到相切连续的一整组边。 edges = list(body.edges()) selected = [edge for edge in seeds] + # 1. 用 is_same 把种子边映射到主体边列表的下标集合。 selected_indexes = { index for index, edge in enumerate(edges) @@ -255,6 +301,7 @@ class Build123dGeometryAdapter: return [] def shared_vertex(first: Edge, second: Edge) -> tuple[float, float] | None: + # 找两条边共用的端点，返回各自在该端点处的参数位置；无共用端点返回 None。 first_ends = [(0.0, vertex) for vertex in first.vertices()[:1]] + [(1.0, vertex) for vertex in first.vertices()[-1:]] second_ends = [(0.0, vertex) for vertex in second.vertices()[:1]] + [(1.0, vertex) for vertex in second.vertices()[-1:]] for first_parameter, first_vertex in first_ends: @@ -263,8 +310,10 @@ class Build123dGeometryAdapter: return first_parameter, second_parameter return None + # 共顶点且端点处切线平行（方向无关）的边即构成相切连续链。 # Edges sharing a vertex whose tangents are parallel (orientation is # irrelevant) are a tangent-continuous chain. + # 2. BFS 扩展：新加入的边作为候选种子，继续寻找与其相切的下一条边。 pending = list(selected_indexes) while pending: current_index = pending.pop() @@ -274,27 +323,33 @@ class Build123dGeometryAdapter: shared = shared_vertex(edges[current_index], candidate) if shared is None: continue + # 比较两条边在共用端点处的切线方向（取绝对值以忽略方向）。 first_tangent = edges[current_index].tangent_at(shared[0]).normalized() second_tangent = candidate.tangent_at(shared[1]).normalized() if abs(abs(first_tangent.dot(second_tangent)) - 1.0) <= angular_tolerance: selected_indexes.add(candidate_index) pending.append(candidate_index) + # 3. 按下标映射回边对象列表。 return [edge for index, edge in enumerate(edges) if index in selected_indexes] @staticmethod def chamfer(body: Any, distance_mm: float, distance_2_mm: float | None, edges: Iterable[Edge], face: Face | None = None) -> Any: + # 对指定边做倒角；distance_2_mm 提供时形成非对称倒角。 return body.chamfer(distance_mm, distance_2_mm, list(edges), face=face) @staticmethod def mirror(body: Any, plane: PlaneSpec) -> Any: + # 沿给定平面镜像主体。 return body.mirror(Build123dGeometryAdapter.plane(plane)) @staticmethod def export(body: Any, path: str) -> None: + # 将主体导出为 STEP 文件。 export_step(body, path) @staticmethod def body_geometry(body: Any) -> dict[str, Any]: + # 汇总主体基本几何信息：包围盒与体积。 bbox = body.bounding_box() return { "bbox_mm": [bbox.min.X, bbox.min.Y, bbox.min.Z, bbox.max.X, bbox.max.Y, bbox.max.Z], @@ -303,6 +358,7 @@ class Build123dGeometryAdapter: @staticmethod def topology_records(body: Any, feature_id: str, body_id: str) -> list[TopologyRecord]: + # 从主体导出全部面/边/顶点拓扑记录，供后续特征选择与引用。 records: list[TopologyRecord] = [] faces = list(body.faces()) edges = list(body.edges()) @@ -310,17 +366,20 @@ class Build123dGeometryAdapter: def index_for(shape: Any, candidates: list[Any]) -> int | None: """Map a subshape returned by a face/edge back to body topology.""" + # 用 is_same 把面/边的子形状映射回主体拓扑列表的下标。 for index, candidate in enumerate(candidates): if shape.is_same(candidate): return index return None + # 1. 建立邻接索引：每条边关联的面集合（edge_faces）。 edge_faces: list[set[int]] = [set() for _edge in edges] for face_index, face in enumerate(faces): for edge in face.edges(): edge_index = index_for(edge, edges) if edge_index is not None: edge_faces[edge_index].add(face_index) + # 2. 建立邻接索引：每个顶点关联的边集合（vertex_edges）。 vertex_edges: list[set[int]] = [set() for _vertex in vertices] for edge_index, edge in enumerate(edges): for vertex in edge.vertices(): @@ -329,6 +388,7 @@ class Build123dGeometryAdapter: vertex_edges[vertex_index].add(edge_index) def edge_signature(edge_index: int) -> str: + # 边的特征签名：几何类型 + 长度 + 相邻面数，用作面邻接指纹。 edge = edges[edge_index] return ":".join(( str(edge.geom_type).split(".")[-1].lower(), @@ -336,6 +396,8 @@ class Build123dGeometryAdapter: str(len(edge_faces[edge_index])), )) + # 3. 导出面记录：含包围盒、中心、法向、面积、曲面类型与邻接签名； + # 平面面额外写入规范化法向与平面偏移，便于后续按平面匹配。 for index, face in enumerate(faces): bbox = face.bounding_box() center = face.center() @@ -361,6 +423,7 @@ class Build123dGeometryAdapter: record_id=f"{body_id}:face:{index}", kind="face", feature_id=feature_id, body_id=body_id, value=face, geometry=geometry, )) + # 4. 导出边记录：含包围盒、中心、长度、曲线类型与相邻面数；端点坐标可用时附加。 for index, edge in enumerate(edges): bbox = edge.bounding_box() center = edge.center() @@ -378,6 +441,7 @@ class Build123dGeometryAdapter: record_id=f"{body_id}:edge:{index}", kind="edge", feature_id=feature_id, body_id=body_id, value=edge, geometry=geometry, )) + # 5. 导出顶点记录：含坐标与关联边数。 for index, vertex in enumerate(vertices): point = [vertex.X, vertex.Y, vertex.Z] records.append(TopologyRecord( -- 2.52.0 From d0d697b4dee816e1e994d58244007445f2801750 Mon Sep 17 00:00:00 2001 From: ganjihong Date: Tue, 25 Aug 2026 13:47:31 +0800 Subject: [PATCH 2/4] =?UTF-8?q?style:=20=E6=B8=85=E7=90=86=20build123d=5Fa?= =?UTF-8?q?dapter=20=E4=B8=AD=E7=9A=84=E5=A4=9A=E4=BD=99=E7=A9=BA=E8=A1=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- backend/engine/cdsl_engine/build123d_adapter.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/backend/engine/cdsl_engine/build123d_adapter.py b/backend/engine/cdsl_engine/build123d_adapter.py index 511f117d..109d5c1c 100644 --- a/backend/engine/cdsl_engine/build123d_adapter.py +++ b/backend/engine/cdsl_engine/build123d_adapter.py @@ -9,12 +9,10 @@ from build123d import Axis, Edge, Face, Plane, Solid, Vector, Wire, export_step from .runtime_types import AxisSpec, HoleSpec, PlaneSpec, TopologyRecord, Vector3, canonical_plane_signature - def _vector(value: list[float] | tuple[float, float, float]) -> Vector: # 将三元坐标（list 或 tuple）转换为 build123d 的 Vector 对象。 return Vector(float(value[0]), float(value[1]), float(value[2])) - def _arc_midpoint(edge: dict[str, Any], start: Vector, end: Vector, center: Vector) -> Vector: # 计算圆弧中点（配合 Edge.make_three_point_arc 三点画弧），支持显式法向与顺时针/逆时针方向。 # 1. 半径：优先取 edge.radius_mm，缺省时由圆心到起点的距离推算。 -- 2.52.0 From 2f54551ba315d13e913e8a5d505615d94a272c6c Mon Sep 17 00:00:00 2001 From: ganjihong Date: Tue, 25 Aug 2026 13:50:27 +0800 Subject: [PATCH 3/4] =?UTF-8?q?style:=20=E7=A7=BB=E9=99=A4=E5=A4=9A?= =?UTF-8?q?=E4=BD=99=E7=A9=BA=E8=A1=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- backend/engine/cdsl_engine/build123d_adapter.py | 1 - 1 file changed, 1 deletion(-) diff --git a/backend/engine/cdsl_engine/build123d_adapter.py b/backend/engine/cdsl_engine/build123d_adapter.py index 109d5c1c..2db70042 100644 --- a/backend/engine/cdsl_engine/build123d_adapter.py +++ b/backend/engine/cdsl_engine/build123d_adapter.py @@ -46,7 +46,6 @@ def _arc_midpoint(edge: dict[str, Any], start: Vector, end: Vector, center: Vect radius_vector = first.normalized() * radius return center + radius_vector * math.cos(half) + normal.cross(radius_vector) * math.sin(half) - class Build123dGeometryAdapter: """All B-rep construction and mutation lives in this adapter.""" -- 2.52.0 From 886390843013708ba39e725e8ad3d59789b94b71 Mon Sep 17 00:00:00 2001 From: ganjihong Date: Wed, 26 Aug 2026 14:39:04 +0800 Subject: [PATCH 4/4] =?UTF-8?q?fix(json=5Fto=5Fcdsl):=20=E4=BF=AE=E5=A4=8D?= =?UTF-8?q?=E5=8F=82=E8=80=83=E5=B9=B3=E9=9D=A2=E4=B8=8A=E6=97=8B=E8=BD=AC?= =?UTF-8?q?=E8=BD=AE=E5=BB=93=E7=9A=84=E5=B7=A5=E4=BD=9C=E5=B9=B3=E9=9D=A2?= =?UTF-8?q?=E9=87=8D=E5=BB=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- json_to_cdsl/evidence_v2_to_cdsl.py | 127 +++++++++++++++++++++++++++- 1 file changed, 126 insertions(+), 1 deletion(-) diff --git a/json_to_cdsl/evidence_v2_to_cdsl.py b/json_to_cdsl/evidence_v2_to_cdsl.py index 251d48a5..1012ad55 100644 --- a/json_to_cdsl/evidence_v2_to_cdsl.py +++ b/json_to_cdsl/evidence_v2_to_cdsl.py @@ -184,9 +184,22 @@ def _workplane(sketch: dict[str, Any]) -> dict[str, Any]: A conservative XY fallback keeps the record valid when the exporter did not provide a usable matrix. """ + workplane = _workplane_from_matrix(sketch) + if workplane is not None: + return workplane + return {"origin_mm": [0.0, 0.0, 0.0], "x_dir": [1.0, 0.0, 0.0], "y_dir": [0.0, 1.0, 0.0], "normal": [0.0, 0.0, 1.0]} + + +def _workplane_from_matrix(sketch: dict[str, Any]) -> dict[str, Any] | None: + """Parse the exporter's model-to-sketch matrix into a workplane. + + Returns None when no usable rigid rotation can be extracted (missing + matrix or a non-orthonormal frame). The caller then decides between a + rebuilt workplane and the conservative XY fallback. + """ matrix = sketch.get("model_to_sketch_transform") if not isinstance(matrix, list) or len(matrix) != 16 or not all(isinstance(item, (int, float)) for item in matrix): - return {"origin_mm": [0.0, 0.0, 0.0], "x_dir": [1.0, 0.0, 0.0], "y_dir": [0.0, 1.0, 0.0], "normal": [0.0, 0.0, 1.0]} + return None # The exporter serializes MathTransform in row-major form. rotation = [matrix[0:3], matrix[4:7], matrix[8:11]] translation = [matrix[3], matrix[7], matrix[11]] @@ -195,9 +208,69 @@ def _workplane(sketch: dict[str, Any]) -> dict[str, Any]: x_dir = _normalize([inverse_rotation[row][0] for row in range(3)]) y_dir = _normalize([inverse_rotation[row][1] for row in range(3)]) normal = _normalize(_cross(x_dir, y_dir)) + # A rigid model-to-sketch rotation keeps the sketch axes orthogonal. The + # exporter sometimes emits a non-orthogonal matrix for profiles placed on + # a copied reference plane; only trust a frame that is truly orthonormal. + if abs(x_dir[0] * y_dir[0] + x_dir[1] * y_dir[1] + x_dir[2] * y_dir[2]) > 1e-9: + return None return {"origin_mm": [_mm(value) for value in origin_m], "x_dir": x_dir, "y_dir": y_dir, "normal": normal} +def _workplane_is_orthonormal(workplane: dict[str, Any]) -> bool: + """True when a workplane's sketch axes describe an orthonormal frame.""" + x_dir = workplane.get("x_dir") + y_dir = workplane.get("y_dir") + if not x_dir or not y_dir: + return False + return abs(x_dir[0] * y_dir[0] + x_dir[1] * y_dir[1] + x_dir[2] * y_dir[2]) <= 1e-9 + + +def _workplane_rebuilt(parent_plane: dict[str, Any] | None, axis_direction: list[float] | None) -> dict[str, Any] | None: + """Rebuild a workplane from the parent reference plane and the revolve axis. + + When the exporter's matrix is unusable, the profile still lies on its + parent reference plane and the revolve axis runs along the sketch V axis. + The captured axis direction is world space, so V maps directly onto it and + U is completed by the cross product to keep a right-handed frame. + """ + if not parent_plane or not axis_direction: + return None + normal = _normalize(list(parent_plane.get("normal") or [])) + y_dir = _normalize(list(axis_direction)) + if abs(normal[0] * y_dir[0] + normal[1] * y_dir[1] + normal[2] * y_dir[2]) > 0.9: + # The axis would lie parallel to the plane normal and the revolve + # would degenerate to zero volume; do not trust this rebuild. + return None + x_dir = _normalize(_cross(y_dir, normal)) + origin_mm = list(parent_plane.get("origin_mm") or [0.0, 0.0, 0.0]) + return {"origin_mm": origin_mm, "x_dir": x_dir, "y_dir": y_dir, "normal": normal} + + +def _axis_in_world(axis: dict[str, Any], workplane: dict[str, Any]) -> dict[str, Any]: + """Transform a revolve axis captured in sketch-local coordinates to world space.""" + origin = axis.get("origin_mm") + direction = axis.get("direction") + if not origin or not direction or not workplane.get("x_dir"): + return axis + origin_mm = workplane.get("origin_mm") or [0.0, 0.0, 0.0] + x_dir = workplane["x_dir"] + y_dir = workplane.get("y_dir") or [0.0, 1.0, 0.0] + normal = workplane.get("normal") or [0.0, 0.0, 1.0] + world_origin = [ + origin_mm[index] + origin[0] * x_dir[index] + origin[1] * y_dir[index] + origin[2] * normal[index] + for index in range(3) + ] + world_direction = _normalize([ + direction[0] * x_dir[index] + direction[1] * y_dir[index] + direction[2] * normal[index] + for index in range(3) + ]) + return { + **axis, + "origin_mm": [round(value, 9) for value in world_origin], + "direction": world_direction if math.sqrt(sum(c * c for c in world_direction)) > 1e-12 else list(direction), + } + + def _workplane_from_plane_reference(reference: Any) -> dict[str, Any] | None: """Build a workplane from an exporter-captured planar face signature.""" if not isinstance(reference, dict): @@ -892,6 +965,25 @@ def convert_evidence(evidence: dict[str, Any], *, source_name: str, step_path: P sketch_id_by_name = {str(feature.get("name")): sketch_id_by_source[source_id] for feature in sketch_features if (source_id := _identity_key(feature)) and feature.get("name") is not None} sketch_workplanes_by_parent_source: dict[str, tuple[str, dict[str, Any]]] = {} sketch_workplanes_by_parent_name: dict[str, tuple[str, dict[str, Any]]] = {} + # sketch source id -> the parent reference-plane source id it is drawn on + sketch_parent_plane_by_source: dict[str, str] = {} + # sketch source id -> the world-space direction of its revolve axis + sketch_axis_direction_by_source: dict[str, list[float]] = {} + # sketch source ids whose exporter matrix did not form an orthonormal frame + sketch_matrix_unreliable: set[str] = set() + sketch_record_by_id: dict[str, dict[str, Any]] = {} + # Prescan the revolve features so each profile's workplane can be rebuilt + # from the axis direction captured on its own revolve feature. + for feature in features: + if _feature_family(feature) not in {"Revolution", "RevCut"}: + continue + props, _ = _record_values(feature) + axis, _ = _axis_from_reference(props.get("Axis")) + if not axis or not axis.get("direction"): + continue + for parent in _record_parents(feature): + if str(parent.get("effective_type") or "") in SKETCH_TYPES and (sketch_source_id := _identity_key(parent)): + sketch_axis_direction_by_source.setdefault(sketch_source_id, list(axis["direction"])) sketches = [] for feature in sketch_features: source_id = _identity_key(feature) @@ -901,10 +993,15 @@ def convert_evidence(evidence: dict[str, Any], *, source_name: str, step_path: P workplane = _workplane(sketch) record = {"id": sketch_id_by_source[source_id], "name": str(feature.get("name") or sketch_id_by_source[source_id]), "role": "profile", "workplane": workplane, "profile": _analytic_profile(sketch)} sketches.append(record) + sketch_record_by_id[record["id"]] = record + if not _workplane_is_orthonormal(workplane): + sketch_matrix_unreliable.add(source_id) for parent in _record_parents(feature): parent_source_id = _identity_key(parent) if parent_source_id: sketch_workplanes_by_parent_source.setdefault(parent_source_id, (record["id"], workplane)) + if _feature_family(parent) == "RefPlane": + sketch_parent_plane_by_source[source_id] = parent_source_id if parent.get("name") is not None: sketch_workplanes_by_parent_name.setdefault(str(parent["name"]), (record["id"], workplane)) @@ -944,6 +1041,11 @@ def convert_evidence(evidence: dict[str, Any], *, source_name: str, step_path: P cdsl_features: list[dict[str, Any]] = [] previous_id: str | None = None diagnostics: list[dict[str, Any]] = [] + # Sketch source ids whose workplane was successfully rebuilt once their + # parent reference plane was resolved. Their revolve axis is expressed in + # sketch-local coordinates and must be transformed to world space too. + sketch_fix_applied: set[str] = set() + sketch_source_by_id = {sketch_id: source_id for source_id, sketch_id in sketch_id_by_source.items()} for feature in model_features: source_id = _identity_key(feature) @@ -985,6 +1087,14 @@ def convert_evidence(evidence: dict[str, Any], *, source_name: str, step_path: P selectors.append(axis_selector) if props.get("Axis") and any("no captured semantic selections" in item for item in unresolved): unresolved = [item for item in unresolved if "no captured semantic selections" not in item] + # When the profile workplane was rebuilt, the captured revolve axis + # is still in sketch-local coordinates; map it to world space so + # the cut lands on the resolved parent reference plane. + if sketch_id and (axis_source_id := sketch_source_by_id.get(sketch_id)) in sketch_fix_applied: + sketch_workplane = sketch_record_by_id.get(sketch_id) + axis = params.get("axis") + if isinstance(axis, dict) and sketch_workplane is not None: + params["axis"] = _axis_in_world(axis, sketch_workplane["workplane"]) elif family == "HoleWzd": atomic_id = "hole_wizard" params, positions = _hole_params(props, methods) @@ -1065,6 +1175,21 @@ def convert_evidence(evidence: dict[str, Any], *, source_name: str, step_path: P if "unresolved" not in params["plane"]: more_unresolved = [item for item in more_unresolved if item != "reference plane orientation was not captured"] unresolved = [item for item in unresolved if item != "reference plane orientation was not captured"] + plane = params.get("plane") + if isinstance(plane, dict) and "origin_mm" in plane and "unresolved" not in plane: + # Profiles whose exporter matrix was unusable are rebuilt from + # this resolved reference plane (normal + origin) and the axis + # direction of the profile's own revolve feature. + for sketch_source_id, ref_source_id in sketch_parent_plane_by_source.items(): + if ref_source_id != source_id or sketch_source_id not in sketch_matrix_unreliable: + continue + rebuilt = _workplane_rebuilt(plane, sketch_axis_direction_by_source.get(sketch_source_id)) + if rebuilt is None: + continue + sketch_record = sketch_record_by_id.get(sketch_id_by_source.get(sketch_source_id) or "") + if sketch_record is not None: + sketch_record["workplane"] = rebuilt + sketch_fix_applied.add(sketch_source_id) for reference in params.get("references", []): if reference not in selectors: selectors.append(reference) -- 2.52.0