"""Generic SolidWorks JSON/IR to build123d code translator.""" from __future__ import annotations import json import math import os import re from copy import deepcopy from typing import Any, Dict, Optional SW_END_CONDITIONS = { 0: "Blind", 1: "ThroughAll", 2: "ThroughAllBoth", 3: "UpToVertex", 4: "UpToSurface", 5: "OffsetFromSurface", 6: "ThroughAllAndBlind", 7: "UpToBody", 8: "MidPlane", 9: "ThroughNext", } THROUGH_CUT_AMOUNT_MM = 200 def normalize_to_ir(data: Dict[str, Any]) -> Dict[str, Any]: """Normalize supported input formats to the backend internal IR.""" if "operations" in data and "sketches" in data: return enrich_rebuild_parameters(data) if "features" in data: return enrich_rebuild_parameters(convert_sw_plugin_json_to_ir(data)) raise ValueError("Unsupported JSON format: expected internal IR or SW plugin features JSON") def enrich_rebuild_parameters(data: Dict[str, Any]) -> Dict[str, Any]: """Add a generic editable-parameter index without changing feature history. The returned rebuild JSON remains the source of truth for execution. The `editable_parameters` section is an index of JSON paths that a UI or caller can modify safely while preserving the original feature order and links. """ enriched = dict(data) enriched["editable_parameters"] = extract_editable_parameters(enriched) enriched["parameterization_status"] = analyze_parameterization_status(enriched) return enriched def analyze_parameterization_status(data: Dict[str, Any]) -> Dict[str, Any]: issues = [] for sketch in data.get("sketches", []): host_reference = sketch.get("host_reference", {}) reference = host_reference.get("reference") or {} if reference.get("kind") == "face" and not reference.get("owner_feature"): issues.append({ "kind": "missing_stable_face_owner", "sketch": {"id": sketch.get("id"), "name": sketch.get("name")}, "message": ( "Sketch is attached to a face geometry, but the JSON does not identify " "the owning feature/face id. Parameter edits may require updating this " "sketch workplane manually unless the plugin exports stable face ownership." ), }) for op in data.get("operations", []): if op.get("type") in ("unsupported", "unknown"): sw_type = op.get("parameters", {}).get("sw_type") or op.get("type") issues.append({ "kind": "unsupported_geometry_feature", "feature": {"id": op.get("id"), "name": op.get("name"), "type": sw_type}, "message": ( f"SolidWorks feature '{sw_type}' is present in the history, but the " "core build123d translator has no generic implementation for it. " "The feature is retained in IR and must not be treated as a complete rebuild." ), }) if op.get("type") == "hole": host_face = op.get("parameters", {}).get("host_face") or {} if host_face and not host_face.get("frame"): issues.append({ "kind": "missing_hole_host_frame", "feature": {"id": op.get("id"), "name": op.get("name"), "type": op.get("type")}, "message": ( "Hole feature has a host face, but the JSON does not include the " "face-local x/y axes. The translator can infer common axis-aligned " "cases, but the plugin should export the sketch/face frame for exact " "generic hole placement." ), }) if op.get("type") == "extrude_cut": end_code = op.get("parameters", {}).get("end_condition_code") if end_code in (3, 4, 5, 7, 9): params = op.get("parameters", {}) has_termination_reference = any( params.get(key) for key in ( "end_condition_reference", "reverse_end_condition_reference", "termination_reference", ) ) kind = ( "sw_end_condition_requires_exact_translator" if has_termination_reference else "missing_extrude_termination_reference" ) issues.append({ "kind": kind, "feature": {"id": op.get("id"), "name": op.get("name"), "type": op.get("type")}, "end_condition_code": end_code, "end_condition": SW_END_CONDITIONS.get(end_code), "message": ( "This SW cut uses a non-blind end condition. ThroughAll can be " "replayed generically, but ThroughNext/UpTo-style rebuilds need the " "selected terminating face/body/reference from the plugin for exact 1:1." ), }) if op.get("type") in ("revolve_cut", "revolve_add"): axis_reference = op.get("parameters", {}).get("axis_reference") if not axis_reference or not ( isinstance(axis_reference, dict) and axis_reference.get("origin_mm") and axis_reference.get("direction") ): axis_candidates = op.get("parameters", {}).get("axis_candidates") or [] if axis_candidates: issues.append({ "kind": "revolve_axis_inferred_from_candidate", "feature": {"id": op.get("id"), "name": op.get("name"), "type": op.get("type")}, "message": ( "Revolve feature lacks the original SolidWorks selected axis, but " "the translator can use a construction-line candidate. For exact " "auditability the plugin should still export the selected axis " "reference and selection mark." ), }) continue issues.append({ "kind": "missing_revolve_axis_reference", "feature": {"id": op.get("id"), "name": op.get("name"), "type": op.get("type")}, "message": ( "Revolve feature does not include the SolidWorks selected axis. " "The translator can only infer an axis from the sketch workplane, " "which is not reliable enough for exact 1:1 rebuild." ), }) if op.get("type") in ("linear_pattern", "pattern_linear"): params = op.get("parameters", {}) if not params.get("source_features") or not _linear_pattern_offsets(op): issues.append({ "kind": "linear_pattern_missing_source_or_direction", "feature": {"id": op.get("id"), "name": op.get("name"), "type": op.get("type")}, "message": ( "This SW linear pattern lacks source-feature selection or direction data. " "The translator can replay patterns when source features and offsets are " "available; otherwise the plugin should export the selected feature list " "and pattern direction references." ), }) if op.get("type") in ("fillet", "chamfer"): selectors = op.get("selectors") or [] if selectors and not any(_selector_has_persistent_reference(selector) for selector in selectors): issues.append({ "kind": "missing_original_feature_selection", "feature": {"id": op.get("id"), "name": op.get("name"), "type": op.get("type")}, "message": ( "This feature only has final-geometry edge signatures. For exact replay " "the plugin should export the original SolidWorks feature selections " "including persistent references and selection marks." ), }) return { "safe_to_edit": not issues, "issues": issues, } def _selector_has_persistent_reference(selector: Dict[str, Any]) -> bool: stack = [selector] while stack: value = stack.pop() if isinstance(value, dict): if value.get("persistent_reference"): return True stack.extend(value.values()) elif isinstance(value, list): stack.extend(value) return False def extract_editable_parameters(data: Dict[str, Any]) -> list[Dict[str, Any]]: parameters: list[Dict[str, Any]] = [] sketches = {sketch.get("id"): sketch for sketch in data.get("sketches", [])} for op_index, op in enumerate(data.get("operations", [])): op_type = op.get("type", "") op_name = op.get("name", op.get("id", f"operation_{op_index}")) op_path = f"/operations/{op_index}" params = op.get("parameters", {}) if op_type in ("extrude_add", "extrude_cut") and "distance_mm" in params: semantic = "body_length" if op_type == "extrude_add" else "cut_depth" parameters.append(_editable_param( id=f"{op.get('id', op_index)}.distance_mm", label=f"{op_name} distance", semantic=semantic, unit="mm", value=params.get("distance_mm"), path=f"{op_path}/parameters/distance_mm", feature=op, )) if "reverse_distance_mm" in params: parameters.append(_editable_param( id=f"{op.get('id', op_index)}.reverse_distance_mm", label=f"{op_name} reverse distance", semantic="reverse_depth", unit="mm", value=params.get("reverse_distance_mm"), path=f"{op_path}/parameters/reverse_distance_mm", feature=op, )) if op_type in ("fillet", "chamfer"): key = "radius_mm" if op_type == "fillet" else "distance_mm" if key in params: parameters.append(_editable_param( id=f"{op.get('id', op_index)}.{key}", label=f"{op_name} {key}", semantic="fillet_radius" if op_type == "fillet" else "chamfer_distance", unit="mm", value=params.get(key), path=f"{op_path}/parameters/{key}", feature=op, )) sketch_id = op.get("sketch") sketch = sketches.get(sketch_id) if sketch: parameters.extend(_extract_sketch_parameters(sketch, sketch_id, op, op_index, data)) return parameters def _extract_sketch_parameters( sketch: Dict[str, Any], sketch_id: str, op: Dict[str, Any], op_index: int, data: Dict[str, Any], ) -> list[Dict[str, Any]]: parameters: list[Dict[str, Any]] = [] sketch_index = next((i for i, item in enumerate(data.get("sketches", [])) if item.get("id") == sketch_id), None) if sketch_index is None: return parameters op_type = op.get("type", "") entities = sketch.get("entities", []) drawable = [entity for entity in entities if not entity.get("construction", False)] for entity_index, entity in enumerate(entities): entity_type = entity.get("type") entity_path = f"/sketches/{sketch_index}/entities/{entity_index}" if entity_type in ("circle", "arc") and entity.get("is_circle", entity_type == "circle"): center = entity.get("center", [0, 0, 0]) radius = entity.get("radius_mm") semantic = "hole" if op_type == "extrude_cut" else "circle_profile" if radius is not None: parameters.append(_editable_param( id=f"{sketch_id}.entity{entity_index}.radius_mm", label=f"{sketch.get('name', sketch_id)} circle radius", semantic=f"{semantic}_radius", unit="mm", value=radius, path=f"{entity_path}/radius_mm", feature=op, )) for axis, value in zip(("x", "y"), center[:2]): parameters.append(_editable_param( id=f"{sketch_id}.entity{entity_index}.center_{axis}", label=f"{sketch.get('name', sketch_id)} {semantic} center {axis}", semantic=f"{semantic}_center_{axis}", unit="mm", value=value, path=f"{entity_path}/center/{0 if axis == 'x' else 1}", feature=op, )) bounds = _sketch_bounds(drawable) if bounds: min_x, min_y, max_x, max_y = bounds center_x = (min_x + max_x) / 2 center_y = (min_y + max_y) / 2 width = max_x - min_x height = max_y - min_y semantic_prefix = "slot" if op_type == "extrude_cut" else "profile" for suffix, value, semantic in ( ("center_x", center_x, f"{semantic_prefix}_center_x"), ("center_y", center_y, f"{semantic_prefix}_center_y"), ("width", width, f"{semantic_prefix}_width"), ("height", height, f"{semantic_prefix}_height"), ): parameters.append(_editable_param( id=f"{sketch_id}.{suffix}", label=f"{sketch.get('name', sketch_id)} {suffix}", semantic=semantic, unit="mm", value=value, path=f"/sketches/{sketch_index}", feature=op, editable=False, note="Derived from sketch entity bounds; edit underlying entities to change this safely.", )) workplane = sketch.get("workplane", {}) origin = workplane.get("origin_mm") if origin: for axis, value in zip(("x", "y", "z"), origin[:3]): parameters.append(_editable_param( id=f"{sketch_id}.workplane_origin_{axis}", label=f"{sketch.get('name', sketch_id)} workplane origin {axis}", semantic=f"sketch_plane_origin_{axis}", unit="mm", value=value, path=f"/sketches/{sketch_index}/workplane/origin_mm/{'xyz'.index(axis)}", feature=op, )) return parameters def _sketch_bounds(entities: list[Dict[str, Any]]) -> Optional[tuple[float, float, float, float]]: points: list[tuple[float, float]] = [] for entity in entities: for key in ("start", "end", "center"): point = entity.get(key) if point and len(point) >= 2: points.append((float(point[0]), float(point[1]))) radius = entity.get("radius_mm") center = entity.get("center") if radius is not None and center and len(center) >= 2: cx, cy = float(center[0]), float(center[1]) r = float(radius) points.extend([(cx - r, cy - r), (cx + r, cy + r)]) if not points: return None xs = [point[0] for point in points] ys = [point[1] for point in points] return min(xs), min(ys), max(xs), max(ys) def _editable_param( *, id: str, label: str, semantic: str, unit: str, value: Any, path: str, feature: Dict[str, Any], editable: bool = True, note: Optional[str] = None, ) -> Dict[str, Any]: result = { "id": id, "label": label, "semantic": semantic, "unit": unit, "value": value, "path": path, "editable": editable, "feature": { "id": feature.get("id"), "name": feature.get("name"), "type": feature.get("type"), "source_index": feature.get("source_feature", {}).get("index"), }, } if note: result["note"] = note return result def convert_sw_plugin_json_to_ir(data: Dict[str, Any]) -> Dict[str, Any]: """Convert the current SW plugin feature dump into the backend IR.""" features = data.get("features", []) sketches = [] operations = [] last_sketch_id = None last_build_op = None references = [] source_bbox = _source_bbox_from_plugin_json(data) if data.get("document_kind") == "assembly" and isinstance(data.get("assembly_data"), dict): operations.append(_convert_sw_assembly(data)) part_name = data.get("part_name", "part") return { "version": "ir-0.1", "metadata": { "source": { "format": "sw-plugin-json", "file_name": f"{part_name}.sldasm", "sw_version": data.get("sw_version"), } }, "sketches": sketches, "operations": operations, "references": references, "validation_hints": data.get("validation_hints", {}), "geometry_inventory": data.get("geometry_inventory", {}), "rebuild_contract": data.get("rebuild_contract", {}), } for index, feature in enumerate(features): if feature.get("is_suppressed"): continue feature_type = feature.get("type", "") type_name = feature.get("type_name", "") feature_id = feature.get("id") or f"feat_{index:03d}" feature_name = feature.get("name", feature_id) if feature_type in ("refplane", "refaxis"): references.append(_convert_sw_reference(feature, index)) elif feature_type == "sketch": sketch_id = f"sketch_{len(sketches):03d}" sketches.append(_convert_sw_sketch(feature, sketch_id, index)) last_sketch_id = sketch_id elif feature_type in ("extrude", "ice", "cut") and isinstance(feature.get("extrude_data"), dict): sketch_ref = _append_feature_source_sketches(feature, sketches, index) or last_sketch_id op = _convert_sw_extrude(feature, type_name, sketch_ref, index) operations.append(op) last_build_op = op elif feature_type == "revolve": sketch_ref = _append_feature_source_sketches(feature, sketches, index) or last_sketch_id op = _convert_sw_revolve(feature, type_name, sketch_ref, index) operations.append(op) last_build_op = op elif feature_type == "hole": op = _convert_sw_hole(feature, index) operations.append(op) last_build_op = op elif feature_type == "pattern_linear": data_block = feature.get("linear_pattern_data", {}) source_op = _find_source_operation_for_pattern(operations, data_block.get("source_features") or []) source_frame = _source_pattern_frame(source_op or last_build_op, sketches) operations.append(_convert_sw_linear_pattern(feature, index, source_op or last_build_op, source_frame, sketches, source_bbox)) elif feature_type == "pattern_mirror": data_block = feature.get("mirror_data") or {} src_features = data_block.get("source_features") or [] mirror_origin = data_block.get("mirror_plane_origin") mirror_normal = data_block.get("mirror_plane_normal") operations.append({ "id": feature_id, "name": feature_name, "type": "pattern_mirror", "parameters": {"source_features": src_features}, "raw_parameters": { "mirror_plane_origin": mirror_origin, "mirror_plane_normal": mirror_normal, }, "source_feature": _source_feature(feature, index), }) elif feature_type == "fillet": data_block = feature.get("fillet_data", {}) radius_mm = data_block.get("radius") or _feature_length_dimension_mm(feature) operations.append({ "id": feature_id, "name": feature_name, "type": "fillet", "parameters": {"radius_mm": radius_mm}, "selectors": _feature_selection_selectors(feature, data_block), "selection_source": _feature_selection_source(feature, data_block), "source_feature": _source_feature(feature, index), "source_owned_faces": _source_owned_faces(feature), }) elif feature_type == "chamfer": data_block = feature.get("chamfer_data", {}) distance_mm = data_block.get("distance") or _feature_length_dimension_mm(feature) operations.append({ "id": feature_id, "name": feature_name, "type": "chamfer", "parameters": {"distance_mm": distance_mm}, "selectors": _feature_selection_selectors(feature, data_block), "selection_source": _feature_selection_source(feature, data_block), "source_feature": _source_feature(feature, index), "source_owned_faces": _source_owned_faces(feature), }) elif _is_imported_body_feature(feature): op = _convert_sw_imported_body(feature, index) operations.append(op) last_build_op = op elif feature_type == "moveface": data_block = feature.get("move_face_data") if isinstance(feature.get("move_face_data"), dict) else {} op = { "id": feature_id, "name": feature_name, "type": "move_face", "parameters": {"sw_type": type_name or feature_type, "move_face_data": data_block}, "source_feature": _source_feature(feature, index), } operations.append(op) last_build_op = op elif feature_type not in _SW_METADATA_FEATURE_TYPES: operations.append({ "id": feature_id, "name": feature_name, "type": "unsupported", "parameters": {"sw_type": type_name or feature_type}, "source_feature": _source_feature(feature, index), }) part_name = data.get("part_name", "part") return { "version": "ir-0.1", "metadata": { "source": { "format": "sw-plugin-json", "file_name": f"{part_name}.sldprt", "sw_version": data.get("sw_version"), } }, "sketches": sketches, "operations": operations, "references": references, "validation_hints": data.get("validation_hints", {}), "geometry_inventory": data.get("geometry_inventory", {}), "rebuild_contract": data.get("rebuild_contract", {}), } def _is_imported_body_feature(feature: Dict[str, Any]) -> bool: feature_type = str(feature.get("type") or "").lower() type_name = str(feature.get("type_name") or "").lower() return bool(feature.get("imported_body_data")) or feature_type in { "mbimport", "savedextbody", "importedbody", "imported", "stock", } or type_name in {"mbimport", "savedextbody", "importedbody"} def _convert_sw_imported_body(feature: Dict[str, Any], index: int) -> Dict[str, Any]: data_block = feature.get("imported_body_data") if isinstance(feature.get("imported_body_data"), dict) else {} solid_bodies = data_block.get("solid_bodies") or [] solid_body_stats = data_block.get("solid_body_stats") or [] source_name = feature.get("name") parameters = { "sw_type": feature.get("type_name") or feature.get("type"), "source_name": source_name, "history_status": data_block.get("history_status"), "body_count": len(solid_bodies) if isinstance(solid_bodies, list) else len(solid_body_stats), "solid_body_stats": solid_body_stats, "solid_bodies": solid_bodies, } return { "id": feature.get("id") or f"feat_{index:03d}", "name": feature.get("name") or f"imported_body_{index:03d}", "type": "imported_body", "parameters": parameters, "source_feature": _source_feature(feature, index), "source_imported_body": data_block, } def _convert_sw_assembly(data: Dict[str, Any]) -> Dict[str, Any]: assembly_data = data.get("assembly_data") or {} components = [] for index, component in enumerate(assembly_data.get("components") or []): if component.get("is_suppressed") or component.get("is_hidden"): continue path = component.get("path") or "" component_name = component.get("name") or f"component_{index:03d}" base_name = os.path.splitext(os.path.basename(str(path).replace("\\", "/")))[0] or component_name components.append({ "index": index, "name": component_name, "component_id": base_name, "source_path": path, "component_json": f"{base_name}.solidworks_rebuild_extract.json", "transform": component.get("transform") or {}, }) return { "id": "assembly_000", "name": data.get("part_name") or "assembly", "type": "assembly_compose", "parameters": { "components": components, }, "source_feature": {"index": 0, "name": data.get("part_name"), "type": "assembly"}, } def _append_feature_source_sketches(feature: Dict[str, Any], sketches: list[Dict[str, Any]], index: int) -> Optional[str]: """Promote feature-owned SW sketches into the rebuild sketch table.""" source_sketches = [] for block_name in ("extrude_data", "revolve_data"): block = feature.get(block_name) if isinstance(block, dict): source_sketches.extend(sketch for sketch in (block.get("source_sketches") or []) if isinstance(sketch, dict)) if not source_sketches: return None last_id = None for sketch_data in source_sketches: sketch_id = f"sketch_{len(sketches):03d}" sketch_feature = dict(feature) sketch_feature["sketch_data"] = sketch_data if sketch_data.get("name"): sketch_feature["name"] = sketch_data.get("name") sketches.append(_convert_sw_sketch(sketch_feature, sketch_id, index)) last_id = sketch_id return last_id def get_part_name(data: Dict[str, Any]) -> str: part_name = data.get("part_name") or data.get("metadata", {}).get("source", {}).get("file_name", "part") part_name = str(part_name) for suffix in (".sldprt", ".sldasm", ".step", ".stp", ".json"): if part_name.lower().endswith(suffix): part_name = part_name[:-len(suffix)] break return re.sub(r"[^0-9A-Za-z_\u4e00-\u9fff]+", "_", part_name).strip("_") or "part" def generate_build123d_code(data: Dict[str, Any], gold_volume_mm3: float | None = None) -> str: """Generate build123d Python code from generic SW/build123d IR.""" rebuild_contract = data.get("rebuild_contract") if isinstance(data.get("rebuild_contract"), dict) else {} if rebuild_contract and rebuild_contract.get("ready") is False: blockers = rebuild_contract.get("blockers") or [] raise ValueError(f"Pure-JSON rebuild contract is not ready: {blockers}") source_volume_mm3 = None source_area_mm2 = None mass_props = data.get("validation_hints", {}).get("mass_properties_raw") if mass_props and len(mass_props) >= 5: source_volume_mm3 = float(mass_props[3]) * 1_000_000_000 source_area_mm2 = float(mass_props[4]) * 1_000_000 lines = [ "from build123d import *", "import math", f"SOURCE_VOLUME_MM3 = {source_volume_mm3!r}", f"SOURCE_AREA_MM2 = {source_area_mm2!r}", "", "def _dist(a, b):", " return math.sqrt(sum((a[i] - b[i]) ** 2 for i in range(3)))", "", "def _owned_face_match_score(shape, expected_faces):", " if not expected_faces:", " return 0.0", " try:", " available = list(shape.faces())", " except Exception:", " return 1e99", " total = 0.0", " for expected in expected_faces:", " bbox_m = expected.get('box_m')", " if not bbox_m or len(bbox_m) < 6 or not available:", " total += 1e6", " continue", " target_box = [float(v) * 1000 for v in bbox_m[:6]]", " surface = expected.get('surface') or {}", " target_type = next((name for name in ('plane', 'cylinder', 'cone', 'sphere', 'torus') if surface.get('is_' + name)), '')", " target_area = float(expected.get('area_m2') or 0) * 1_000_000", " ranked = []", " for index, face in enumerate(available):", " try:", " fb = face.bounding_box()", " face_box = [fb.min.X, fb.min.Y, fb.min.Z, fb.max.X, fb.max.Y, fb.max.Z]", " geom = face.geom_type() if callable(face.geom_type) else face.geom_type", " geom_name = getattr(geom, 'name', str(geom)).lower()", " type_penalty = 0.0 if not target_type or target_type in geom_name else 1000.0", " bbox_penalty = sum(abs(face_box[i] - target_box[i]) for i in range(6))", " area_penalty = abs(float(face.area) - target_area) / max(math.sqrt(abs(target_area)), 1.0) if target_area else 0.0", " ranked.append((type_penalty + bbox_penalty + area_penalty, index))", " except Exception:", " continue", " if not ranked:", " total += 1e6", " continue", " best, index = min(ranked, key=lambda item: item[0])", " total += best", " available.pop(index)", " return total / max(len(expected_faces), 1)", "", "def _candidate_score(shape, expected_faces=None):", " # Owned faces describe this exact SW history step. Final-part mass properties", " # must not be used to choose an intermediate feature candidate.", " if expected_faces:", " return _owned_face_match_score(shape, expected_faces)", " score = 0", " if SOURCE_VOLUME_MM3 is not None:", " try:", " score += abs(float(shape.volume) - SOURCE_VOLUME_MM3)", " except Exception:", " score += 1e99", " if SOURCE_AREA_MM2 is not None:", " try:", " score += abs(float(shape.area) - SOURCE_AREA_MM2) * 0.01", " except Exception:", " score += 1e99", " score += _owned_face_match_score(shape, expected_faces)", " return score", "", "def _edge_endpoints(edge):", " vertices = [v.to_tuple() for v in edge.vertices()]", " if len(vertices) != 2:", " center = edge.center().to_tuple()", " return center, center", " return vertices[0], vertices[1]", "", "def _edge_match_score(edge, start, end):", " a, b = _edge_endpoints(edge)", " endpoint_score = min(_dist(a, start) + _dist(b, end), _dist(a, end) + _dist(b, start))", " containment_score = edge.distance_to(start) + edge.distance_to(end)", " return min(endpoint_score, containment_score)", "", "def select_edges_by_endpoints(part, selector_points, tolerance=0.5):", " edges = list(part.edges())", " selected = []", " used = set()", " for selector in selector_points:", " start, end = selector", " ranked = sorted(((_edge_match_score(edge, start, end), i, edge) for i, edge in enumerate(edges)), key=lambda item: item[0])", " score, index, edge = ranked[0]", " if score > tolerance:", " raise ValueError(f\"No edge matched selector {selector}; best score={score:.4f} mm\")", " if index not in used:", " selected.append(edge)", " used.add(index)", " return selected", "", "def _bbox_match_score(edge, bbox_mm):", " if not bbox_mm or len(bbox_mm) < 6:", " return float('inf')", " try:", " a, b = _edge_endpoints(edge)", " mid = tuple((a[i] + b[i]) / 2 for i in range(3))", " mins = tuple(float(bbox_mm[i]) for i in range(3))", " maxs = tuple(float(bbox_mm[i + 3]) for i in range(3))", " diag = math.sqrt(sum((maxs[i] - mins[i]) ** 2 for i in range(3)))", " pad = max(0.25, diag * 0.15)", " def point_score(point):", " total = 0.0", " for axis in range(3):", " if point[axis] < mins[axis] - pad:", " total += mins[axis] - pad - point[axis]", " elif point[axis] > maxs[axis] + pad:", " total += point[axis] - maxs[axis] - pad", " return total", " return min(point_score(mid), (point_score(a) + point_score(b)) / 2)", " except Exception:", " return float('inf')", "", "def _circle_match_score(edge, circle_params):", " if not circle_params or len(circle_params) < 7:", " return float('inf')", " try:", " geom_type = edge.geom_type() if callable(edge.geom_type) else edge.geom_type", " geom_name = getattr(geom_type, 'name', str(geom_type))", " if 'CIRCLE' not in geom_name:", " return float('inf')", " target_center = tuple(float(v) * 1000 for v in circle_params[:3])", " target_radius = float(circle_params[6]) * 1000", " edge_center = edge.arc_center.to_tuple()", " return _dist(edge_center, target_center) + abs(edge.radius - target_radius)", " except Exception:", " return float('inf')", "", "def _line_match_score(edge, line_params):", " if not line_params or len(line_params) < 6:", " return float('inf')", " try:", " geom_type = edge.geom_type() if callable(edge.geom_type) else edge.geom_type", " geom_name = getattr(geom_type, 'name', str(geom_type))", " if 'LINE' not in geom_name:", " return float('inf')", " target_point = tuple(float(v) * 1000 for v in line_params[:3])", " target_dir = tuple(float(v) for v in line_params[3:6])", " a, b = _edge_endpoints(edge)", " edge_dir_raw = tuple(b[i] - a[i] for i in range(3))", " length = math.sqrt(sum(v * v for v in edge_dir_raw))", " if length <= 0:", " return float('inf')", " edge_dir = tuple(v / length for v in edge_dir_raw)", " parallel = 1 - abs(sum(edge_dir[i] * target_dir[i] for i in range(3)))", " distance = edge.distance_to(target_point)", " return distance + parallel * 10", " except Exception:", " return float('inf')", "", "def select_edges_by_selectors(part, selectors, tolerance=0.5):", " if part is None:", " return []", " edges = list(part.edges())", " selected = []", " used = set()", " for selector in selectors or []:", " geometry = selector.get('geometry', {})", " start_vertex = geometry.get('start_vertex')", " end_vertex = geometry.get('end_vertex')", " start = start_vertex.get('point_m') if start_vertex else None", " end = end_vertex.get('point_m') if end_vertex else None", " bbox_mm = geometry.get('bbox_mm')", " if start and end:", " start_mm = tuple(float(v) * 1000 for v in start)", " end_mm = tuple(float(v) * 1000 for v in end)", " line_params = geometry.get('curve', {}).get('line_params')", " if line_params:", " ranked = sorted(((min(_edge_match_score(edge, start_mm, end_mm), _line_match_score(edge, line_params)) + (_bbox_match_score(edge, bbox_mm) if bbox_mm else 0), i, edge) for i, edge in enumerate(edges)), key=lambda item: item[0])", " else:", " ranked = sorted(((_edge_match_score(edge, start_mm, end_mm) + (_bbox_match_score(edge, bbox_mm) if bbox_mm else 0), i, edge) for i, edge in enumerate(edges)), key=lambda item: item[0])", " else:", " line_params = geometry.get('curve', {}).get('line_params')", " circle_params = geometry.get('curve', {}).get('circle_params')", " if line_params:", " ranked = sorted(((_line_match_score(edge, line_params) + (_bbox_match_score(edge, bbox_mm) if bbox_mm else 0), i, edge) for i, edge in enumerate(edges)), key=lambda item: item[0])", " elif bbox_mm:", " ranked = sorted(((_bbox_match_score(edge, bbox_mm), i, edge) for i, edge in enumerate(edges)), key=lambda item: item[0])", " else:", " ranked = sorted(((_circle_match_score(edge, circle_params), i, edge) for i, edge in enumerate(edges)), key=lambda item: item[0])", " score, index, edge = ranked[0]", " selector_tolerance = float(selector.get('tolerance_mm') or tolerance)", " if score > selector_tolerance:", " # Skip edges that don't match well enough", " continue", " if index not in used:", " selected.append(edge)", " used.add(index)", " return selected", "", "def _point_inside_bbox(point, bbox_mm, pad=0.25):", " return all(float(bbox_mm[i]) - pad <= point[i] <= float(bbox_mm[i + 3]) + pad for i in range(3))", "", "def fillet_edges_from_owned_surface_bbox(part, selectors):", " if part is None:", " return []", " boxes = []", " seen_boxes = set()", " for selector in selectors or []:", " if selector.get('source') not in ('owned_cylindrical_face_axis', 'owned_face_bbox'):", " continue", " bbox = (selector.get('geometry') or {}).get('bbox_mm')", " if bbox and len(bbox) >= 6:", " normalized = [float(v) for v in bbox[:6]]", " key = tuple(round(v, 6) for v in normalized)", " if key not in seen_boxes:", " seen_boxes.add(key)", " boxes.append(normalized)", " if len(boxes) < 2:", " return []", " selected = []", " used_keys = set()", " for box in boxes:", " diag = math.sqrt(sum((box[i + 3] - box[i]) ** 2 for i in range(3)))", " pad = max(0.25, diag * 0.08)", " sizes = [abs(box[i + 3] - box[i]) for i in range(3)]", " thin_axes = [i for i, size in enumerate(sizes) if size <= max(1.5, diag * 0.08)]", " circle_candidates = []", " if thin_axes:", " thin_axis = thin_axes[0]", " for edge in part.edges():", " try:", " geom_type = edge.geom_type() if callable(edge.geom_type) else edge.geom_type", " geom_name = getattr(geom_type, 'name', str(geom_type))", " if 'CIRCLE' not in geom_name:", " continue", " eb = edge.bounding_box()", " edge_box = [eb.min.X, eb.min.Y, eb.min.Z, eb.max.X, eb.max.Y, eb.max.Z]", " ok = True", " score = 0.0", " for axis in range(3):", " if axis == thin_axis:", " plane_delta = min(abs(edge_box[axis] - box[axis]), abs(edge_box[axis] - box[axis + 3]), abs(edge_box[axis + 3] - box[axis]), abs(edge_box[axis + 3] - box[axis + 3]))", " if plane_delta > pad:", " ok = False", " break", " score += plane_delta", " else:", " if edge_box[axis] < box[axis] - pad or edge_box[axis + 3] > box[axis + 3] + pad:", " ok = False", " break", " score += abs(edge_box[axis] - box[axis]) + abs(edge_box[axis + 3] - box[axis + 3])", " if not ok:", " continue", " key = tuple(round(v, 5) for v in edge_box)", " circle_candidates.append((score, key, edge))", " except Exception:", " continue", " if circle_candidates:", " circle_candidates.sort(key=lambda item: item[0])", " for _, key, edge in circle_candidates:", " if key in used_keys:", " continue", " used_keys.add(key)", " selected.append(edge)", " break", " continue", " box_candidates = []", " for edge in part.edges():", " try:", " geom_type = edge.geom_type() if callable(edge.geom_type) else edge.geom_type", " geom_name = getattr(geom_type, 'name', str(geom_type))", " if 'LINE' not in geom_name:", " continue", " a, b = _edge_endpoints(edge)", " mid = tuple((a[i] + b[i]) / 2 for i in range(3))", " if not (_point_inside_bbox(a, box, pad) and _point_inside_bbox(b, box, pad) and _point_inside_bbox(mid, box, pad)):", " continue", " key = tuple(round(v, 5) for point in (a, b) for v in point)", " box_candidates.append((float(edge.length), key, edge))", " except Exception:", " continue", " if not box_candidates:", " continue", " box_candidates.sort(key=lambda item: item[0], reverse=True)", " for _, key, edge in box_candidates:", " reverse_key = key[3:] + key[:3]", " if key in used_keys or reverse_key in used_keys:", " continue", " used_keys.add(key)", " selected.append(edge)", " break", " if selected:", " return selected", " union_bbox = [", " min(box[i] for box in boxes) if i < 3 else max(box[i] for box in boxes)", " for i in range(6)", " ]", " diag = math.sqrt(sum((union_bbox[i + 3] - union_bbox[i]) ** 2 for i in range(3)))", " pad = max(0.25, diag * 0.05)", " candidates = []", " for edge in part.edges():", " try:", " geom_type = edge.geom_type() if callable(edge.geom_type) else edge.geom_type", " geom_name = getattr(geom_type, 'name', str(geom_type))", " if 'LINE' not in geom_name:", " continue", " a, b = _edge_endpoints(edge)", " mid = tuple((a[i] + b[i]) / 2 for i in range(3))", " if not (_point_inside_bbox(a, union_bbox, pad) and _point_inside_bbox(b, union_bbox, pad) and _point_inside_bbox(mid, union_bbox, pad)):", " continue", " candidates.append((float(edge.length), edge))", " except Exception:", " continue", " if not candidates:", " return []", " candidates.sort(key=lambda item: item[0], reverse=True)", " return [candidates[0][1]]", "", "def fillet_with_tolerance(edges, radius):", " radii = [float(radius)]", " shrink = max(0.001, abs(float(radius)) * 0.001)", " if float(radius) > shrink:", " radii.append(float(radius) - shrink)", " radii.append(float(radius) * 0.99)", " last_error = None", " for candidate_radius in radii:", " if candidate_radius <= 0:", " continue", " try:", " return fillet(edges, radius=candidate_radius)", " except Exception as exc:", " last_error = exc", " continue", " if last_error:", " raise last_error", " return fillet(edges, radius=radius)", "", "def fillet_selected(part, radius, selectors, owned_faces=None):", " if part is None:", " return part", " if not selectors:", " # No edge selectors - skip fillet to avoid failing on all edges", " return part", " candidates = []", " owned_edges = fillet_edges_from_owned_surface_bbox(part, selectors)", " if owned_edges:", " try:", " candidates.append(fillet_with_tolerance(owned_edges, radius))", " except Exception:", " pass", " try:", " target_edges = select_edges_by_selectors(part, selectors)", " if target_edges:", " candidates.append(fillet_with_tolerance(target_edges, radius))", " except Exception:", " pass", " result = part", " applied_any = False", " for selector in selectors:", " edges = select_edges_by_selectors(result, [selector])", " if not edges:", " continue # Skip selectors that don't match any edge", " try:", " result = fillet_with_tolerance([edges[0]], radius)", " applied_any = True", " except Exception:", " # OCC fillets are fragile: one invalid edge/radius should not abort the whole rebuild.", " continue", " if applied_any:", " candidates.append(result)", " variants = []", " for selector in selectors:", " edges = select_edges_by_selectors(part, [selector])", " if not edges:", " continue", " try:", " variants.append(fillet_with_tolerance([edges[0]], radius))", " except Exception:", " continue", " if variants:", " try:", " union_result = part", " for variant in variants:", " union_result = union_result + variant", " candidates.append(union_result)", " except Exception:", " pass", " try:", " intersection_result = part", " for variant in variants:", " intersection_result = intersection_result & variant", " candidates.append(intersection_result)", " except Exception:", " pass", " if candidates:", " return sorted(candidates, key=lambda shape: _candidate_score(shape, owned_faces))[0]", " return part", "", "def chamfer_selected(part, distance, selectors, owned_faces=None):", " if part is None:", " return part", " if not selectors:", " # No edge selectors available - chamfer would fail on all edges", " return part", " candidates = []", " owned_edges = fillet_edges_from_owned_surface_bbox(part, selectors)", " if owned_edges:", " try:", " candidates.append(chamfer(owned_edges, length=distance))", " except Exception:", " pass", " target_edges = select_edges_by_selectors(part, selectors)", " if target_edges:", " try:", " candidates.append(chamfer(target_edges, length=distance))", " except Exception:", " pass", " result = part", " applied_any = False", " for selector in selectors:", " edges = select_edges_by_selectors(result, [selector])", " if not edges:", " continue", " try:", " result = chamfer([edges[0]], length=distance)", " applied_any = True", " except Exception:", " continue", " if applied_any:", " candidates.append(result)", " if candidates:", " return sorted(candidates, key=lambda shape: _candidate_score(shape, owned_faces))[0]", " return part", "", "def is_internal_cone_face(face, part):", " try:", " bbox_m = face.get('box_m')", " surface = face.get('surface') or {}", " if not (bbox_m and len(bbox_m) >= 6 and surface.get('is_cone')):", " return False", " params = surface.get('cone_params')", " if not params or len(params) < 6:", " return False", " direction = tuple(float(v) for v in params[3:6])", " axis = max(range(3), key=lambda i: abs(direction[i]))", " radial_axes = tuple(i for i in range(3) if i != axis)", " part_bbox = part.bounding_box()", " part_min = part_bbox.min.to_tuple()", " part_max = part_bbox.max.to_tuple()", " mins = tuple(float(bbox_m[i]) * 1000 for i in range(3))", " maxs = tuple(float(bbox_m[i + 3]) * 1000 for i in range(3))", " tol = 0.25", " touches_outer = any(", " abs(mins[i] - part_min[i]) <= tol or abs(maxs[i] - part_max[i]) <= tol", " for i in radial_axes", " )", " return not touches_outer", " except Exception:", " return False", "", "def is_external_cone_face(face, part):", " try:", " bbox_m = face.get('box_m')", " surface = face.get('surface') or {}", " if not (bbox_m and len(bbox_m) >= 6 and surface.get('is_cone')):", " return False", " params = surface.get('cone_params')", " if not params or len(params) < 6:", " return False", " direction = tuple(float(v) for v in params[3:6])", " axis = max(range(3), key=lambda i: abs(direction[i]))", " radial_axes = tuple(i for i in range(3) if i != axis)", " part_bbox = part.bounding_box()", " part_min = part_bbox.min.to_tuple()", " part_max = part_bbox.max.to_tuple()", " mins = tuple(float(bbox_m[i]) * 1000 for i in range(3))", " maxs = tuple(float(bbox_m[i + 3]) * 1000 for i in range(3))", " tol = 0.25", " return any(", " abs(mins[i] - part_min[i]) <= tol or abs(maxs[i] - part_max[i]) <= tol", " for i in radial_axes", " )", " except Exception:", " return False", "", "def make_owned_external_cone_chamfer_cutter(face):", " surface = face.get('surface') or {}", " params = surface.get('cone_params')", " bbox_m = face.get('box_m')", " if not params or len(params) < 8 or not bbox_m or len(bbox_m) < 6:", " return None", " origin = tuple(float(v) * 1000 for v in params[:3])", " direction = tuple(float(v) for v in params[3:6])", " norm = math.sqrt(sum(v * v for v in direction))", " base_radius = abs(float(params[6]) * 1000)", " half_angle = abs(float(params[7]))", " if norm <= 1e-9 or base_radius <= 1e-9 or half_angle <= 1e-9:", " return None", " direction = tuple(v / norm for v in direction)", " mins = tuple(float(bbox_m[i]) * 1000 for i in range(3))", " maxs = tuple(float(bbox_m[i + 3]) * 1000 for i in range(3))", " projections = []", " for x in (mins[0], maxs[0]):", " for y in (mins[1], maxs[1]):", " for z in (mins[2], maxs[2]):", " delta = (x - origin[0], y - origin[1], z - origin[2])", " axial = sum(delta[i] * direction[i] for i in range(3))", " projections.append(axial)", " start = min(projections)", " end = max(projections)", " height = max(0.001, end - start)", " r1 = max(0.0, base_radius - math.tan(half_angle) * start)", " r2 = max(0.0, base_radius - math.tan(half_angle) * end)", " outer_radius = max(r1, r2) + 0.001", " center_offset = (start + end) / 2", " center = tuple(origin[i] + direction[i] * center_offset for i in range(3))", " if r1 <= 1e-9:", " r1 = 1e-6", " if r2 <= 1e-9:", " r2 = 1e-6", " with BuildPart(Plane(origin=center, z_dir=direction)) as cutter_part:", " Cylinder(outer_radius, height, align=(Align.CENTER, Align.CENTER, Align.CENTER))", " Cone(r1, r2, height + 0.002, align=(Align.CENTER, Align.CENTER, Align.CENTER), mode=Mode.SUBTRACT)", " return cutter_part.part", "", "def chamfer_owned_external_cones(part, faces):", " if part is None:", " return part, False", " result = part", " applied = False", " for face in faces or []:", " if not is_external_cone_face(face, result):", " continue", " cutter = make_owned_external_cone_chamfer_cutter(face)", " new_result = safe_subtract(result, cutter)", " if new_result is not result:", " result = new_result", " applied = True", " return result, applied", "", "def chamfer_owned_internal_cones(part, faces):", " if part is None:", " return part, False", " result = part", " applied = False", " for face in faces or []:", " if not is_internal_cone_face(face, result):", " continue", " cutter = make_owned_cone_cutter(face)", " new_result = safe_subtract(result, cutter)", " if new_result is not result:", " result = new_result", " applied = True", " return result, applied", "", "def chamfer_selected_with_owned_faces(part, distance, selectors, owned_faces):", " cone_faces = [face for face in (owned_faces or []) if (face.get('surface') or {}).get('is_cone')]", " if len(cone_faces) == 1 and is_internal_cone_face(cone_faces[0], part):", " result, applied = chamfer_owned_internal_cones(part, cone_faces)", " if applied:", " return result", " if len(cone_faces) == 1 and is_external_cone_face(cone_faces[0], part):", " result, applied = chamfer_owned_external_cones(part, cone_faces)", " if applied:", " return result", " return chamfer_selected(part, distance, selectors, owned_faces)", "", "def safe_subtract(part, cutter):", " if part is None or cutter is None:", " return part", " try:", " vol_before = float(part.volume)", " except Exception:", " vol_before = -1", " try:", " cut = part - cutter", " if cut is None:", " print(f' SUBTRACT: cutter resulted in None, keeping original (vol={vol_before:.0f})')", " return part", " # Accept the cut even when solids() reports 0 – can happen", " # for valid boolean results with non-standard structures.", " try:", " nb_solids = len(list(cut.solids()))", " if nb_solids == 0:", " print(f' SUBTRACT: cut produced 0 solids (still accepting) vol={vol_before:.0f}')", " except Exception:", " pass", " return cut", " except Exception as e:", " print(f' SUBTRACT: exception {type(e).__name__}: {e}, keeping original (vol={vol_before:.0f})')", " return part", "", "def _project_bbox_along_direction(bbox, origin, direction):", " mins = tuple(float(bbox[i]) for i in range(3))", " maxs = tuple(float(bbox[i + 3]) for i in range(3))", " projections = []", " for x in (mins[0], maxs[0]):", " for y in (mins[1], maxs[1]):", " for z in (mins[2], maxs[2]):", " projections.append(sum(((x, y, z)[i] - origin[i]) * direction[i] for i in range(3)))", " return min(projections), max(projections)", "", "def make_owned_cylinder_cutter(face, target_part=None):", " surface = face.get('surface') or {}", " params = surface.get('cylinder_params')", " bbox_m = face.get('box_m')", " if not params or len(params) < 7 or not bbox_m or len(bbox_m) < 6:", " return None", " origin = tuple(float(v) * 1000 for v in params[:3])", " direction = tuple(float(v) for v in params[3:6])", " norm = math.sqrt(sum(v * v for v in direction))", " radius = abs(float(params[6]) * 1000)", " if norm <= 1e-9 or radius <= 1e-9:", " return None", " direction = tuple(v / norm for v in direction)", " mins = tuple(float(bbox_m[i]) * 1000 for i in range(3))", " maxs = tuple(float(bbox_m[i + 3]) * 1000 for i in range(3))", " start, end = _project_bbox_along_direction((*mins, *maxs), origin, direction)", " if target_part is not None:", " try:", " part_bbox = target_part.bounding_box()", " part_box = (*part_bbox.min.to_tuple(), *part_bbox.max.to_tuple())", " part_start, part_end = _project_bbox_along_direction(part_box, origin, direction)", " through_tolerance = max(1.0, radius * 0.12)", " if abs(start - part_start) <= through_tolerance:", " start = part_start", " if abs(end - part_end) <= through_tolerance:", " end = part_end", " except Exception:", " pass", " height = max(0.001, end - start)", " center_offset = (start + end) / 2", " center = tuple(origin[i] + direction[i] * center_offset for i in range(3))", " with BuildPart(Plane(origin=center, z_dir=direction)) as cutter_part:", " Cylinder(radius, height, align=(Align.CENTER, Align.CENTER, Align.CENTER))", " return cutter_part.part", "", "def make_owned_cone_cutter(face):", " surface = face.get('surface') or {}", " params = surface.get('cone_params')", " bbox_m = face.get('box_m')", " if not params or len(params) < 8 or not bbox_m or len(bbox_m) < 6:", " return None", " origin = tuple(float(v) * 1000 for v in params[:3])", " direction = tuple(float(v) for v in params[3:6])", " norm = math.sqrt(sum(v * v for v in direction))", " base_radius = abs(float(params[6]) * 1000)", " half_angle = abs(float(params[7]))", " if norm <= 1e-9 or base_radius <= 1e-9 or half_angle <= 1e-9:", " return None", " direction = tuple(v / norm for v in direction)", " mins = tuple(float(bbox_m[i]) * 1000 for i in range(3))", " maxs = tuple(float(bbox_m[i + 3]) * 1000 for i in range(3))", " projections = []", " for x in (mins[0], maxs[0]):", " for y in (mins[1], maxs[1]):", " for z in (mins[2], maxs[2]):", " projections.append(sum(((x, y, z)[i] - origin[i]) * direction[i] for i in range(3)))", " start = min(projections)", " end = max(projections)", " # Keep a tiny overlap for the boolean while preserving blind-hole depth.", " height = max(0.001, end - start) + 0.001", " # SolidWorks ConeParams stores the radius at the cone origin; along the axis", " # direction the radius tapers rather than expands for hole drill tips.", " r1 = max(0.0, base_radius - math.tan(half_angle) * start)", " r2 = max(0.0, base_radius - math.tan(half_angle) * end)", " if max(r1, r2) <= 1e-9:", " return None", " if r1 <= 1e-9:", " r1 = 1e-6", " if r2 <= 1e-9:", " r2 = 1e-6", " center_offset = (start + end) / 2", " center = tuple(origin[i] + direction[i] * center_offset for i in range(3))", " with BuildPart(Plane(origin=center, z_dir=direction)) as cutter_part:", " Cone(r1, r2, height, align=(Align.CENTER, Align.CENTER, Align.CENTER))", " return cutter_part.part", "", "def make_owned_face_cutter(face, target_part=None):", " surface = face.get('surface') or {}", " if surface.get('is_cylinder'):", " return make_owned_cylinder_cutter(face, target_part)", " if surface.get('is_cone'):", " return make_owned_cone_cutter(face)", " return None", "", "def cut_owned_cylindrical_faces(part, faces):", " result = part", " for face in faces or []:", " cutter = make_owned_face_cutter(face, result)", " result = safe_subtract(result, cutter)", " return result", "", "def make_owned_flip_side_ring_cutter(face, target_part):", " surface = face.get('surface') or {}", " params = surface.get('cylinder_params')", " bbox_m = face.get('box_m')", " if target_part is None or not params or len(params) < 7 or not bbox_m or len(bbox_m) < 6:", " return None", " origin = tuple(float(v) * 1000 for v in params[:3])", " direction = tuple(float(v) for v in params[3:6])", " norm = math.sqrt(sum(v * v for v in direction))", " inner_radius = abs(float(params[6]) * 1000)", " if norm <= 1e-9 or inner_radius <= 1e-9:", " return None", " direction = tuple(v / norm for v in direction)", " mins = tuple(float(bbox_m[i]) * 1000 for i in range(3))", " maxs = tuple(float(bbox_m[i + 3]) * 1000 for i in range(3))", " start, end = _project_bbox_along_direction((*mins, *maxs), origin, direction)", " height = max(0.001, end - start)", " center_offset = (start + end) / 2", " center = tuple(origin[i] + direction[i] * center_offset for i in range(3))", " try:", " part_bbox = target_part.bounding_box()", " part_min = part_bbox.min.to_tuple()", " part_max = part_bbox.max.to_tuple()", " radial = []", " for x in (part_min[0], part_max[0]):", " for y in (part_min[1], part_max[1]):", " for z in (part_min[2], part_max[2]):", " delta = (x - origin[0], y - origin[1], z - origin[2])", " axial = sum(delta[i] * direction[i] for i in range(3))", " perp = tuple(delta[i] - axial * direction[i] for i in range(3))", " radial.append(math.sqrt(sum(v * v for v in perp)))", " outer_radius = max(radial) + max(1.0, inner_radius * 0.05)", " except Exception:", " outer_radius = inner_radius + 100.0", " if outer_radius <= inner_radius + 1e-6:", " return None", " with BuildPart(Plane(origin=center, z_dir=direction)) as cutter_part:", " Cylinder(outer_radius, height, align=(Align.CENTER, Align.CENTER, Align.CENTER))", " Cylinder(inner_radius, height + 0.002, align=(Align.CENTER, Align.CENTER, Align.CENTER), mode=Mode.SUBTRACT)", " return cutter_part.part", "", "def cut_owned_flip_side_cylindrical_faces(part, faces):", " result = part", " for face in faces or []:", " cutter = make_owned_flip_side_ring_cutter(face, result)", " result = safe_subtract(result, cutter)", " return result", "", "def cut_owned_bbox(part, bbox_mm):", " if part is None or not bbox_mm or len(bbox_mm) < 6:", " return part", " mins = tuple(float(bbox_mm[i]) for i in range(3))", " maxs = tuple(float(bbox_mm[i + 3]) for i in range(3))", " size = tuple(max(0.001, maxs[i] - mins[i]) for i in range(3))", " center = tuple((mins[i] + maxs[i]) / 2 for i in range(3))", " cutter = Pos(center) * Box(size[0], size[1], size[2])", " return safe_subtract(part, cutter)", "", "def shape_face_count(shape):", " if shape is None:", " return 0", " try:", " return len(list(shape.faces()))", " except Exception:", " return 0", "", "def safe_union(part, solid, preserve_visible=False):", " if part is None:", " return solid", " if solid is None:", " return part", " try:", " fused = part + solid", " # OCCT fuse succeeded; always return the fused result.", " # is_valid() can return False for edge cases where the geometry", " # is actually correct (e.g. touching-at-faces). Accept it.", " return fused", " except Exception as e:", " print(f' UNION: fuse threw {type(e).__name__}: {e}')", " pass", " try:", " compound = Compound.make_composite([part, solid])", " fused = compound.fuse()", " try:", " if len(list(fused.solids())) > 0:", " print(f' UNION: compound.fuse() worked, {len(list(fused.solids()))} solids')", " return fused", " except Exception:", " pass", " except Exception as e:", " print(f' UNION: compound.fuse() threw {type(e).__name__}: {e}')", " pass", " shapes = []", " try:", " shapes.extend(list(part.solids()))", " except Exception:", " shapes.append(part)", " try:", " shapes.extend(list(solid.solids()))", " except Exception:", " shapes.append(solid)", " return Compound.make_composite(shapes)", "", "def sw_inverted_profile_cut(part, profile_solid, normal):", " if part is None or profile_solid is None:", " return part", " try:", " part_bbox = part.bounding_box()", " profile_bbox = profile_solid.bounding_box()", " n = tuple(float(v) for v in normal)", " axis = max(range(3), key=lambda i: abs(n[i]))", " part_min = part_bbox.min.to_tuple()", " part_max = part_bbox.max.to_tuple()", " prof_min = profile_bbox.min.to_tuple()", " prof_max = profile_bbox.max.to_tuple()", " margin = 5.0", " mins = [part_min[i] - margin for i in range(3)]", " maxs = [part_max[i] + margin for i in range(3)]", " mins[axis] = prof_min[axis] - margin * 0.05", " maxs[axis] = prof_max[axis] + margin * 0.05", " center = tuple((mins[i] + maxs[i]) / 2 for i in range(3))", " size = tuple(max(0.001, maxs[i] - mins[i]) for i in range(3))", " envelope = Pos(center) * Box(size[0], size[1], size[2])", " outside_profile = safe_subtract(envelope, profile_solid)", " return safe_subtract(part, outside_profile)", " except Exception:", " return part", "", "def sw_flip_side_step_cut(part, profile_solid, normal, outer_radius_mm, inner_radius_mm):", " part = sw_inverted_profile_cut(part, profile_solid, normal)", " if part is None or profile_solid is None:", " return part", " try:", " outer_radius = abs(float(outer_radius_mm))", " inner_radius = abs(float(inner_radius_mm))", " except Exception:", " return part", " if outer_radius <= inner_radius + 1e-6:", " return part", " try:", " profile_bbox = profile_solid.bounding_box()", " prof_min = profile_bbox.min.to_tuple()", " prof_max = profile_bbox.max.to_tuple()", " center = tuple((prof_min[i] + prof_max[i]) / 2 for i in range(3))", " n = tuple(float(v) for v in normal)", " axis = max(range(3), key=lambda i: abs(n[i]))", " span_xy = max(prof_max[0] - prof_min[0], prof_max[1] - prof_min[1])", " margin_xy = max(2.0, span_xy * 0.05)", " margin_z = 0.1", " size = tuple(", " max(0.001, prof_max[i] - prof_min[i] + (margin_xy if i < 2 else margin_z))", " for i in range(3)", " )", " plane = Plane(", " origin=center,", " x_dir=(1.0, 0.0, 0.0) if axis != 0 else (0.0, 1.0, 0.0),", " z_dir=n,", " )", " cut_extent = prof_max[axis] - prof_min[axis]", " cut_amount = -abs(cut_extent) if n[axis] < 0 else abs(cut_extent)", " with BuildSketch(plane) as ring_sketch:", " Circle(outer_radius)", " Circle(inner_radius, mode=Mode.SUBTRACT)", " ring = extrude(ring_sketch.sketch, amount=cut_amount)", " return safe_union(part, ring)", " except Exception:", " return part", "", "def sw_cut_holes(part, positions, host_face, diameter, depth, drill_angle=0, include_drill_tip=False, countersink_diameter=0, countersink_angle=0, counterbore_diameter=0, counterbore_depth=0):", " if part is None:", " return part", " if not positions or diameter <= 0 or depth <= 0:", " return part", " plane = host_face.get('surface', {}).get('plane_params') or [0, 0, 1, 0, 0, 0]", " frame = host_face.get('frame') or {}", " normal = tuple(float(v) for v in plane[:3])", " plane_point = tuple(float(v) * 1000 for v in plane[3:6])", " origin = tuple(float(v) for v in frame.get('origin_mm', plane_point))", " x_dir = tuple(float(v) for v in frame.get('x_dir', (0, 0, 0)))", " y_dir = tuple(float(v) for v in frame.get('y_dir', (0, 0, 0)))", " has_frame = sum(abs(v) for v in x_dir) > 0 and sum(abs(v) for v in y_dir) > 0", " bbox = part.bounding_box()", " part_center = tuple((bbox.min.to_tuple()[i] + bbox.max.to_tuple()[i]) / 2 for i in range(3))", " toward_center = tuple(part_center[i] - plane_point[i] for i in range(3))", " dot = sum(toward_center[i] * normal[i] for i in range(3))", " inward = normal if dot >= 0 else tuple(-v for v in normal)", " axis = max(range(3), key=lambda i: abs(inward[i]))", " rotation = (0, 0, 0)", " if axis == 0:", " rotation = (0, 90, 0) if inward[0] >= 0 else (0, -90, 0)", " elif axis == 1:", " rotation = (-90, 0, 0) if inward[1] >= 0 else (90, 0, 0)", " elif inward[2] < 0:", " rotation = (180, 0, 0)", " tip_depth = 0", " if include_drill_tip and drill_angle > 0:", " tip_depth = (diameter / 2) / math.tan(drill_angle / 2)", " countersink_depth = 0", " if countersink_diameter > diameter and countersink_angle > 0:", " countersink_depth = ((countersink_diameter - diameter) / 2) / math.tan(countersink_angle / 2)", " result = part", " for pos in positions:", " x, y = float(pos[0]), float(pos[1])", " if has_frame:", " start = tuple(origin[i] + x_dir[i] * x + y_dir[i] * y for i in range(3))", " elif axis == 0:", " start = (plane_point[0], x, y)", " elif axis == 1:", " start = (x, plane_point[1], -y)", " else:", " start = (x, y, plane_point[2])", " cut_depth = depth", " if depth >= 199:", " part_min = bbox.min.to_tuple()", " part_max = bbox.max.to_tuple()", " corners = []", " for ci in range(2):", " for cj in range(2):", " for ck in range(2):", " corners.append((", " part_min[0] if ci else part_max[0],", " part_min[1] if cj else part_max[1],", " part_min[2] if ck else part_max[2],", " ))", " cut_depth = max(", " sum((corner[i] - start[i]) * inward[i] for i in range(3))", " for corner in corners", " ) + 2.0", " cutters = []", " cb_depth = counterbore_depth if counterbore_diameter > diameter and counterbore_depth > 0 else 0", " cs_depth = countersink_depth if countersink_depth > 0 else 0", " hole_start = cs_depth", " hole_depth = max(0.001, cut_depth - hole_start - cb_depth)", " if hole_depth > 0:", " hole_center = tuple(start[i] + inward[i] * (hole_start + cb_depth + hole_depth / 2) for i in range(3))", " cutters.append(Pos(hole_center) * Cylinder(diameter / 2, hole_depth, rotation=rotation))", " if cb_depth > 0:", " cb_center = tuple(start[i] + inward[i] * (hole_start + cb_depth / 2) for i in range(3))", " cutters.append(Pos(cb_center) * Cylinder(counterbore_diameter / 2, cb_depth, rotation=rotation))", " if cs_depth > 0:", " cs_center = tuple(start[i] + inward[i] * cs_depth / 2 for i in range(3))", " cs = Pos(cs_center) * Cone(countersink_diameter / 2, diameter / 2, cs_depth, rotation=rotation)", " cutters.append(cs)", " if tip_depth > 0:", " base = tuple(start[i] + inward[i] * cut_depth for i in range(3))", " tip_center = tuple(base[i] + inward[i] * tip_depth / 2 for i in range(3))", " tip = Pos(tip_center) * Cone(diameter / 2, 0, tip_depth, rotation=rotation)", " cutters.append(tip)", " if len(cutters) == 1:", " cutter = cutters[0]", " else:", " cutter = Compound.make_composite(cutters)", " result = safe_subtract(result, cutter)", " return result", "", ] part_name_clean = get_part_name(data) lines.append(f"def build_{part_name_clean}():") lines.append(' """Auto-generated build123d code from SolidWorks IR."""') lines.append("") sketches = {s["id"]: s for s in data.get("sketches", [])} operations = data.get("operations", []) references = {r["id"]: r for r in data.get("references", [])} generated_sketches = set() lines.append(" result = None") lines.append("") for op in sort_operations_for_history(operations): op_type = op.get("type", "") op_name = op.get("name", "") if op_type in ["unsupported", "unknown"]: lines.append(f" # Skipping unsupported metadata feature: {op_name}") lines.append("") continue if op_type == "imported_body": lines.extend(_generate_imported_body_pending(op)) elif op_type == "assembly_compose": lines.extend(_generate_assembly_compose(op)) elif op_type == "move_face": lines.extend(_generate_move_face(op)) elif op_type == "fillet": lines.extend(_generate_fillet(op)) elif op_type == "chamfer": lines.extend(_generate_chamfer(op)) elif op_type == "hole": lines.extend(_generate_hole(op)) elif op_type in ("extrude_cut", "extrude_add"): build_op = _resolve_extrude_owned_termination(op, sketches.get(op.get("sketch") or "")) sketch_id = op.get("sketch") if sketch_id and sketch_id in sketches and not _sketch_has_buildable_profile(sketches[sketch_id]): lines.append(f" # Skip: sketch has no buildable closed/profile geometry for {op_name}") continue if sketch_id and sketch_id in sketches and sketch_id not in generated_sketches: lines.extend(_generate_sketch(sketches[sketch_id], references, build_op)) generated_sketches.add(sketch_id) lines.extend(_generate_extrude(build_op, sketches.get(sketch_id, {}), operations, sketches)) elif op_type in ("revolve_cut", "revolve_add"): sketch_id = op.get("sketch") if sketch_id and sketch_id in sketches and not _sketch_has_buildable_profile(sketches[sketch_id]): lines.append(f" # Skip: sketch has no buildable closed/profile geometry for {op_name}") continue if sketch_id and sketch_id in sketches and sketch_id not in generated_sketches: lines.extend(_generate_sketch(sketches[sketch_id], references, op)) generated_sketches.add(sketch_id) lines.extend(_generate_revolve(op, sketches.get(sketch_id, {}))) elif op_type in ("linear_pattern", "pattern_linear"): lines.extend(_generate_linear_pattern(op, operations, sketches, references)) elif op_type == "pattern_mirror": lines.extend(_generate_mirror_pattern(op, operations, sketches, references)) else: lines.append(f" # TODO: {op_type} - {op_name}") lines.append("") lines.append(" if result is None:") lines.append(' raise Exception("No solid was created")') lines.append("") lines.append(" # Clean up small inaccuracies from Boolean operations") lines.append(" try:") lines.append(" result = result.clean()") lines.append(" except Exception:") lines.append(" pass") lines.append(f' export_step(result, "{part_name_clean}.step")') lines.append(" return result") lines.append("") lines.append("# Run the function") lines.append('if __name__ == "__main__":') lines.append(f" build_{part_name_clean}()") return "\n".join(lines) def _generate_imported_body_pending(op: Dict[str, Any]) -> list[str]: return [ f" # Imported body requires generic JSON B-Rep reconstruction: {op.get('name', '')}", " raise NotImplementedError(", " 'Pure-JSON imported-body reconstruction is not implemented yet; '", " 'the plugin captured solid_bodies topology and the part is marked not ready.'", " )", ] def _generate_assembly_compose(op: Dict[str, Any]) -> list[str]: params = op.get("parameters") or {} components = params.get("components") or [] component_ids = [component.get("component_id") for component in components] message = f"Assembly requires rebuilt component JSON registry: {component_ids!r}" return [ f" # Pure-JSON assembly composition: {op.get('name', '')}", " raise NotImplementedError(", f" {message!r}", " )", ] def _sw_math_transform_matrix(array_data: Any, component_name: str) -> list[list[float]]: if not isinstance(array_data, list) or len(array_data) < 13: raise ValueError(f"Assembly component {component_name} has no complete 16-value transform") values = [float(value or 0) for value in array_data] scale = values[12] if abs(scale) <= 1e-12: raise ValueError(f"Assembly component {component_name} has an invalid zero scale") # SOLIDWORKS stores row-vector axes and translation in elements 9..11. # build123d/OpenCascade uses a column-vector 3x4 matrix, hence transpose. return [ [values[0] * scale, values[3] * scale, values[6] * scale, values[9] * 1000.0], [values[1] * scale, values[4] * scale, values[7] * scale, values[10] * 1000.0], [values[2] * scale, values[5] * scale, values[8] * scale, values[11] * 1000.0], [0.0, 0.0, 0.0, 1.0], ] def sort_operations_for_history(operations: list[Dict[str, Any]]) -> list[Dict[str, Any]]: """Return operations in SW rebuild order.""" if _looks_like_reverse_history(operations): return list(reversed(operations)) if all(op.get("source_feature", {}).get("index") is not None for op in operations): return sorted(operations, key=lambda op: op.get("source_feature", {}).get("index", 0)) return sorted(operations, key=_operation_priority) def _looks_like_reverse_history(operations: list[Dict[str, Any]]) -> bool: build_ops = [ op for op in operations if op.get("type") not in ("unsupported", "unknown") ] if len(build_ops) < 2: return False additive = {"extrude_add", "revolve_add", "sweep", "loft"} downstream = {"extrude_cut", "revolve_cut", "fillet", "chamfer", "hole", "linear_pattern", "pattern_linear"} return build_ops[0].get("type") in downstream and build_ops[-1].get("type") in additive def _operation_priority(op: Dict[str, Any]) -> int: op_type = op.get("type", "") if op_type == "extrude_add": return 0 if op_type in ("extrude_cut", "revolve_cut"): return 1 if op_type == "revolve_add": return 2 if op_type in ("fillet", "chamfer"): return 3 if op_type in ("sweep", "loft"): return 4 return 99 def _sketch_has_buildable_profile(sketch: Dict[str, Any]) -> bool: for entity in sketch.get("entities", []) or []: if entity.get("construction"): continue if entity.get("type") == "circle" and float(entity.get("radius_mm") or 0) > 0: return True if entity.get("type") == "arc" and float(entity.get("radius_mm") or 0) > 0: return True valid_lines = 0 for entity in sketch.get("entities", []) or []: if entity.get("construction") or entity.get("type") != "line": continue start = entity.get("start") or [0, 0] end = entity.get("end") or [0, 0] if math.hypot(float(start[0]) - float(end[0]), float(start[1]) - float(end[1])) > 1e-6: valid_lines += 1 return valid_lines >= 2 def _point_key(point: Any, places: int = 5) -> tuple[float, float] | None: if not isinstance(point, list) or len(point) < 2: return None return (round(float(point[0]), places), round(float(point[1]), places)) def _reverse_curve_entity(ent: Dict[str, Any]) -> Dict[str, Any]: """Reverse a sketch segment while preserving its geometric traversal.""" reversed_ent = dict(ent) reversed_ent["start"], reversed_ent["end"] = ent.get("end"), ent.get("start") reversed_ent["reversed"] = not bool(ent.get("reversed", False)) if ent.get("type") == "arc": raw = ent.get("raw") if isinstance(ent.get("raw"), dict) else {} axis = ent.get("curve_axis") or raw.get("curve_axis") if isinstance(axis, list) and len(axis) >= 3: # The arc's endpoints and orientation are a pair. Keep the # source `raw` untouched, but provide a flipped top-level axis for # code generation so a reversed minor arc remains a minor arc. reversed_ent["curve_axis"] = [-float(value) for value in axis[:3]] # 必须删除预置的角度字段，否则代码生成会使用旧的(start,end未翻转时的)角度， # 导致弧段遍历方向与连接顺序相反（如对外弧CW而对内弧也CW而非CCW）。 reversed_ent.pop("start_angle_deg", None) reversed_ent.pop("end_angle_deg", None) reversed_ent.pop("arc_sweep_deg", None) return reversed_ent def _ordered_wire_entities(entities: list[Dict[str, Any]]) -> list[Dict[str, Any]]: """Order sketch line/arc entities into connected loops when SW did not export contours.""" drawable = [ ent for ent in entities if ent.get("type") in ("line", "arc") and _point_key(ent.get("start")) is not None and _point_key(ent.get("end")) is not None ] if len(drawable) < 3: return entities by_node: dict[tuple[float, float], list[tuple[int, str]]] = {} for idx, ent in enumerate(drawable): by_node.setdefault(_point_key(ent.get("start")), []).append((idx, "start")) by_node.setdefault(_point_key(ent.get("end")), []).append((idx, "end")) if not by_node or any(len(touches) != 2 for touches in by_node.values()): return entities remaining = set(range(len(drawable))) ordered: list[Dict[str, Any]] = [] while remaining: first_idx = min(remaining) remaining.remove(first_idx) first = drawable[first_idx] loop = [first] loop_start = _point_key(first.get("start")) cursor = _point_key(first.get("end")) while cursor != loop_start: next_idx = None next_side = None for candidate_idx, side in by_node.get(cursor, []): if candidate_idx in remaining: next_idx = candidate_idx next_side = side break if next_idx is None: return entities remaining.remove(next_idx) next_ent = drawable[next_idx] if next_side == "end": next_ent = _reverse_curve_entity(next_ent) loop.append(next_ent) cursor = _point_key(next_ent.get("end")) ordered.extend(loop) return ordered def _infer_closed_wire_loops(entities: list[Dict[str, Any]]) -> list[Dict[str, Any]]: drawable = [ (idx, ent) for idx, ent in enumerate(entities) if not ent.get("construction", False) and ent.get("type") in ("line", "arc") and _point_key(ent.get("start")) is not None and _point_key(ent.get("end")) is not None ] if len(drawable) < 3: return [] by_node: dict[tuple[float, float], list[tuple[int, str]]] = {} for local_idx, (_, ent) in enumerate(drawable): by_node.setdefault(_point_key(ent.get("start")), []).append((local_idx, "start")) by_node.setdefault(_point_key(ent.get("end")), []).append((local_idx, "end")) remaining = set(range(len(drawable))) loops: list[Dict[str, Any]] = [] while remaining: first_idx = min(remaining) remaining.remove(first_idx) _, first = drawable[first_idx] loop_indices = [first_idx] loop_start = _point_key(first.get("start")) cursor = _point_key(first.get("end")) while cursor != loop_start: matches = [(idx, side) for idx, side in by_node.get(cursor, []) if idx in remaining] if not matches: loop_indices = [] break next_idx, next_side = matches[0] remaining.remove(next_idx) _, next_ent = drawable[next_idx] loop_indices.append(next_idx) cursor = _point_key(next_ent.get("start") if next_side == "end" else next_ent.get("end")) if not loop_indices: continue entity_indices = [drawable[idx][0] for idx in loop_indices] bbox = _loop_bbox([entities[idx] for idx in entity_indices]) loops.append({ "entity_indices": entity_indices, "is_closed": True, "bbox_mm": bbox, "bbox_area_mm2": _bbox_area_2d(bbox), "source": "inferred_connected_loop", }) return loops def _loop_bbox(entities: list[Dict[str, Any]]) -> Optional[list[float]]: points = [] for ent in entities: if not isinstance(ent, dict): continue if ent.get("type") == "circle": center = ent.get("center") radius = ent.get("radius_mm") if isinstance(center, list) and len(center) >= 2 and radius is not None: radius_value = abs(float(radius)) points.append([float(center[0]) - radius_value, float(center[1]) - radius_value]) points.append([float(center[0]) + radius_value, float(center[1]) + radius_value]) continue for key in ("start", "end", "center"): point = ent.get(key) if isinstance(point, list) and len(point) >= 2: points.append(point) if not points: return None return [ min(float(point[0]) for point in points), min(float(point[1]) for point in points), max(float(point[0]) for point in points), max(float(point[1]) for point in points), ] def _bbox_area_2d(bbox: Optional[list[float]]) -> float: if not isinstance(bbox, list) or len(bbox) < 4: return 0.0 return max(0.0, float(bbox[2]) - float(bbox[0])) * max(0.0, float(bbox[3]) - float(bbox[1])) def _bbox_contains_2d(outer: Optional[list[float]], inner: Optional[list[float]], tolerance: float = 1e-6) -> bool: if not isinstance(outer, list) or not isinstance(inner, list) or len(outer) < 4 or len(inner) < 4: return False return ( float(outer[0]) <= float(inner[0]) + tolerance and float(outer[1]) <= float(inner[1]) + tolerance and float(outer[2]) >= float(inner[2]) - tolerance and float(outer[3]) >= float(inner[3]) - tolerance ) def _bbox_overlap_ratio_2d(a: Optional[list[float]], b: Optional[list[float]]) -> float: if not isinstance(a, list) or not isinstance(b, list) or len(a) < 4 or len(b) < 4: return 0.0 ix0 = max(float(a[0]), float(b[0])) iy0 = max(float(a[1]), float(b[1])) ix1 = min(float(a[2]), float(b[2])) iy1 = min(float(a[3]), float(b[3])) intersection = max(0.0, ix1 - ix0) * max(0.0, iy1 - iy0) smaller = min(_bbox_area_2d(a), _bbox_area_2d(b)) if smaller <= 1e-9: return 0.0 return intersection / smaller def _loop_radius_candidates(loop: Dict[str, Any], entities: list[Dict[str, Any]]) -> list[float]: radii: list[float] = [] for idx in loop.get("entity_indices", []) or []: if not isinstance(idx, int) or idx < 0 or idx >= len(entities): continue ent = entities[idx] radius = ent.get("radius_mm") if radius is not None: radii.append(abs(float(radius))) bbox = loop.get("bbox_mm") if isinstance(bbox, list) and len(bbox) >= 4: radii.append(abs(float(bbox[2]) - float(bbox[0])) / 2) radii.append(abs(float(bbox[3]) - float(bbox[1])) / 2) return [radius for radius in radii if radius > 1e-6 and math.isfinite(radius)] def _owned_profile_radii_mm(operation: Optional[Dict[str, Any]], sketch: Dict[str, Any]) -> list[float]: if not isinstance(operation, dict): return [] radii: list[float] = [] loop_radii: list[float] = [] entities = sketch.get("entities") if isinstance(sketch, dict) else [] sketch_loops = (sketch.get("profile_loops") or sketch.get("loops") or []) if isinstance(sketch, dict) else [] for loop in sketch_loops: loop_radii.extend(_loop_radius_candidates(loop, entities if isinstance(entities, list) else [])) def _matches_sketch_radius(value: float) -> bool: return any(abs(value - radius) <= max(0.1, radius * 0.01) for radius in loop_radii) for face in operation.get("source_owned_faces") or []: if not isinstance(face, dict): continue surface = face.get("surface") if isinstance(face.get("surface"), dict) else {} params = surface.get("cylinder_params") if surface.get("is_cylinder") and isinstance(params, list) and len(params) >= 7: radii.append(abs(float(params[6]) * 1000)) continue box = face.get("box_m") area = face.get("area_m2") if surface.get("is_plane") and isinstance(box, list) and len(box) >= 6 and area is not None: sizes = [abs(float(box[i + 3]) - float(box[i])) * 1000 for i in range(3)] non_zero_sizes = [size for size in sizes if size > 1e-4] if len(non_zero_sizes) >= 2: outer_radius = max(non_zero_sizes) / 2 area_mm2 = abs(float(area)) * 1_000_000 inner_sq = outer_radius * outer_radius - area_mm2 / math.pi inner_radius = math.sqrt(inner_sq) if inner_sq > 0 else 0.0 if _matches_sketch_radius(outer_radius): radii.append(outer_radius) if inner_radius > 1e-4 and _matches_sketch_radius(inner_radius): radii.append(inner_radius) unique: list[float] = [] for radius in sorted(radii): if radius <= 1e-6 or not math.isfinite(radius): continue if not any(abs(radius - existing) <= max(0.05, existing * 0.002) for existing in unique): unique.append(radius) return unique def _loops_matching_owned_radii( loops: list[Dict[str, Any]], entities: list[Dict[str, Any]], owned_radii: list[float], ) -> list[Dict[str, Any]]: if not loops or not owned_radii: return [] matched: list[tuple[float, Dict[str, Any]]] = [] for loop in loops: candidates = _loop_radius_candidates(loop, entities) if not candidates: continue best_radius = None best_delta = float("inf") for candidate in candidates: for owned_radius in owned_radii: delta = abs(candidate - owned_radius) if delta < best_delta: best_delta = delta best_radius = candidate if best_radius is None: continue if best_delta <= max(0.1, best_radius * 0.01): matched.append((best_radius, loop)) if not matched: return [] matched.sort(key=lambda item: item[0], reverse=True) deduped: list[tuple[float, Dict[str, Any]]] = [] seen_loop_keys: set[str] = set() for radius, loop in matched: bbox = loop.get("bbox_mm") key = ",".join(f"{float(value):.4f}" for value in bbox[:4]) if isinstance(bbox, list) and len(bbox) >= 4 else str(loop.get("entity_indices")) key = f"{radius:.4f}:{key}" if key in seen_loop_keys: continue seen_loop_keys.add(key) deduped.append((radius, loop)) matched = deduped annotated = [] for index, (_, loop) in enumerate(matched): loop_copy = dict(loop) loop_copy["profile_mode"] = "add" if index == 0 else "subtract" annotated.append(loop_copy) return annotated def _loop_area_from_radii(loops: list[Dict[str, Any]], entities: list[Dict[str, Any]]) -> Optional[float]: if not loops: return None area = 0.0 for index, loop in enumerate(loops): radii = _loop_radius_candidates(loop, entities) if not radii: return None radius = max(radii) mode = loop.get("profile_mode") sign = -1 if mode == "subtract" or (mode is None and index > 0) else 1 area += sign * math.pi * radius * radius return abs(area) if area > 1e-6 else None def _aligned_workplane_for_owned_midplane( sketch: Dict[str, Any], operation: Optional[Dict[str, Any]], loops: list[Dict[str, Any]], ) -> Dict[str, Any]: workplane = dict(sketch.get("workplane") or {}) if not isinstance(operation, dict) or operation.get("type") != "extrude_add": return workplane params = operation.get("parameters") if isinstance(operation.get("parameters"), dict) else {} if not params.get("both_directions"): return workplane entities = sketch.get("entities") if isinstance(sketch.get("entities"), list) else [] profile_area = _loop_area_from_radii(loops, entities) if profile_area is None: return workplane normal = workplane.get("normal") or [0, 0, 1] origin = workplane.get("origin_mm") or [0, 0, 0] if not isinstance(normal, list) or not isinstance(origin, list) or len(normal) < 3 or len(origin) < 3: return workplane normal_vec = [float(v) for v in normal[:3]] norm = math.sqrt(sum(v * v for v in normal_vec)) if norm <= 1e-9: return workplane normal_vec = [v / norm for v in normal_vec] candidates: list[tuple[float, list[float]]] = [] for face in operation.get("source_owned_faces") or []: if not isinstance(face, dict): continue surface = face.get("surface") if isinstance(face.get("surface"), dict) else {} if not surface.get("is_plane"): continue area_m2 = face.get("area_m2") plane_params = surface.get("plane_params") if area_m2 is None or not isinstance(plane_params, list) or len(plane_params) < 6: continue face_area = abs(float(area_m2)) * 1_000_000 if abs(face_area - profile_area) > max(0.5, profile_area * 0.02): continue plane_normal = [float(v) for v in plane_params[:3]] plane_norm = math.sqrt(sum(v * v for v in plane_normal)) if plane_norm <= 1e-9: continue plane_normal = [v / plane_norm for v in plane_normal] alignment = abs(sum(plane_normal[i] * normal_vec[i] for i in range(3))) if alignment < 0.98: continue plane_point = [float(v) * 1000 for v in plane_params[3:6]] old_offset = sum(float(origin[i]) * normal_vec[i] for i in range(3)) new_offset = sum(plane_point[i] * normal_vec[i] for i in range(3)) delta = new_offset - old_offset if abs(delta) <= 1e-6: continue moved_origin = [float(origin[i]) + normal_vec[i] * delta for i in range(3)] candidates.append((abs(delta), moved_origin)) if len(candidates) != 1: return workplane candidates.sort(key=lambda item: item[0]) workplane["origin_mm"] = candidates[0][1] return workplane def _project_owned_faces_to_sketch_bbox( owned_faces: list[Dict[str, Any]], workplane: Dict[str, Any] ) -> Optional[list[float]]: origin = workplane.get("origin_mm") or [0, 0, 0] x_dir = workplane.get("x_dir") or [1, 0, 0] y_dir = workplane.get("y_dir") or [0, 1, 0] if len(origin) < 3 or len(x_dir) < 3 or len(y_dir) < 3: return None projected: list[tuple[float, float]] = [] for face in owned_faces: box = face.get("box_m") if isinstance(face, dict) else None if not isinstance(box, list) or len(box) < 6: continue mins = [float(box[i]) * 1000 for i in range(3)] maxs = [float(box[i + 3]) * 1000 for i in range(3)] for x in (mins[0], maxs[0]): for y in (mins[1], maxs[1]): for z in (mins[2], maxs[2]): point = [x, y, z] rel = [point[i] - float(origin[i]) for i in range(3)] projected.append(( sum(rel[i] * float(x_dir[i]) for i in range(3)), sum(rel[i] * float(y_dir[i]) for i in range(3)), )) if not projected: return None return [ min(point[0] for point in projected), min(point[1] for point in projected), max(point[0] for point in projected), max(point[1] for point in projected), ] def _active_profile_loops(sketch: Dict[str, Any], operation: Optional[Dict[str, Any]]) -> list[Dict[str, Any]]: entities = sketch.get("entities", []) or [] loops = sketch.get("loops", []) or _infer_closed_wire_loops(entities) if not loops: return [] op_type = operation.get("type") if isinstance(operation, dict) else None if op_type == "extrude_cut" and len(loops) > 1: owned_bbox = _project_owned_faces_to_sketch_bbox( operation.get("source_owned_faces") or [], sketch.get("workplane") or {}, ) if owned_bbox: for inner in loops: inner_bbox = inner.get("bbox_mm") if _bbox_overlap_ratio_2d(inner_bbox, owned_bbox) < 0.85: continue containers = [ outer for outer in loops if outer is not inner and _bbox_contains_2d(outer.get("bbox_mm"), inner_bbox, tolerance=1e-4) and _bbox_area_2d(outer.get("bbox_mm")) > _bbox_area_2d(inner_bbox) * 1.05 ] if containers: outer = min(containers, key=lambda loop: _bbox_area_2d(loop.get("bbox_mm"))) outer_loop = dict(outer) inner_loop = dict(inner) outer_loop["profile_mode"] = "add" inner_loop["profile_mode"] = "subtract" return [outer_loop, inner_loop] active = [] for loop in loops: bbox = loop.get("bbox_mm") area = float(loop.get("bbox_area_mm2") or _bbox_area_2d(bbox)) contains_other = any( other is not loop and _bbox_contains_2d(bbox, other.get("bbox_mm")) and area > float(other.get("bbox_area_mm2") or _bbox_area_2d(other.get("bbox_mm"))) * 1.05 for other in loops ) if not contains_other: active.append(loop) if active: return active if op_type == "extrude_add" and len(loops) > 1: owned_matched = _loops_matching_owned_radii(loops, entities, _owned_profile_radii_mm(operation, sketch)) # Owned-face radii are useful for selecting circular profiles, but a # rounded outer contour also contributes arc radii. Those radii can # coincide with an inner circle and make the radius ranking label the # inner loop as ADD and its containing outer loop as SUBTRACT. Such a # profile is topologically impossible as a first additive sketch, so # fall back to the complete contour nesting below. owned_modes_conflict_with_nesting = any( candidate.get("profile_mode") == "add" and any( container is not candidate and container.get("profile_mode") == "subtract" and _bbox_contains_2d( container.get("bbox_mm"), candidate.get("bbox_mm"), tolerance=1e-4, ) and _bbox_area_2d(container.get("bbox_mm")) > _bbox_area_2d(candidate.get("bbox_mm")) * 1.05 for container in owned_matched ) for candidate in owned_matched ) if owned_modes_conflict_with_nesting: owned_matched = [] if owned_matched: # Radius evidence cannot identify closed slot/polygon contours. # Keep non-circular closed loops that lie inside an owned additive # outer loop; they are material-removal islands in the same # additive sketch. Circular unmatched loops remain excluded # because they commonly belong to other features sharing a sketch. matched_entity_keys = { tuple(loop.get("entity_indices") or []) for loop in owned_matched } additive_outers = [ loop for loop in owned_matched if loop.get("profile_mode") == "add" ] for loop in loops: entity_indices = tuple(loop.get("entity_indices") or []) if entity_indices in matched_entity_keys: continue profile_entities = [ entities[index] for index in entity_indices if isinstance(index, int) and 0 <= index < len(entities) ] is_non_circular_profile = bool(profile_entities) and any( entity.get("type") != "circle" and not (entity.get("type") == "arc" and entity.get("is_circle")) for entity in profile_entities ) if not is_non_circular_profile: continue if not any( _bbox_contains_2d( outer.get("bbox_mm"), loop.get("bbox_mm"), tolerance=1e-4 ) for outer in additive_outers ): continue loop_copy = dict(loop) loop_copy["profile_mode"] = "subtract" owned_matched.append(loop_copy) if len(owned_matched) == 1 and isinstance(operation, dict): outer_loop = owned_matched[0] outer_radii = _loop_radius_candidates(outer_loop, entities) outer_radius = max(outer_radii) if outer_radii else 0.0 outer_disk_area = math.pi * outer_radius * outer_radius if outer_radius > 0 else 0.0 has_partial_cap = False for face in operation.get("source_owned_faces") or []: if not isinstance(face, dict): continue surface = face.get("surface") if isinstance(face.get("surface"), dict) else {} area_m2 = face.get("area_m2") if surface.get("is_plane") and area_m2 is not None and outer_disk_area > 0: face_area = abs(float(area_m2)) * 1_000_000 if face_area < outer_disk_area * 0.9: has_partial_cap = True break if has_partial_cap: inner_candidates = [ loop for loop in loops if loop is not outer_loop and _bbox_contains_2d(outer_loop.get("bbox_mm"), loop.get("bbox_mm"), tolerance=1e-4) ] if inner_candidates: inner = max( ( loop for loop in inner_candidates if max(_loop_radius_candidates(loop, entities) or [0.0]) < outer_radius - 0.5 ), key=lambda loop: max(_loop_radius_candidates(loop, entities) or [0.0]), default=None, ) if inner is None: return owned_matched inner_radii = _loop_radius_candidates(inner, entities) inner_radius = max(inner_radii) if inner_radii else 0.0 if inner_radius <= 0: return owned_matched outer_copy = dict(outer_loop) inner_copy = dict(inner) outer_copy["profile_mode"] = "add" inner_copy["profile_mode"] = "subtract" return [outer_copy, inner_copy] return owned_matched annotated = [] for loop in loops: bbox = loop.get("bbox_mm") area = float(loop.get("bbox_area_mm2") or _bbox_area_2d(bbox)) containers = [ outer for outer in loops if outer is not loop and _bbox_contains_2d(outer.get("bbox_mm"), bbox, tolerance=1e-4) and float(outer.get("bbox_area_mm2") or _bbox_area_2d(outer.get("bbox_mm"))) > area * 1.05 ] loop_copy = dict(loop) loop_copy["profile_mode"] = "subtract" if containers else "add" annotated.append(loop_copy) return annotated return loops def _generate_sketch(sketch: Dict[str, Any], references: Dict[str, Any], operation: Optional[Dict[str, Any]] = None) -> list[str]: import math name = sketch.get("name", "Sketch") op_type = operation.get("type") if isinstance(operation, dict) else None workplane = sketch.get("workplane", {}) entities = sketch.get("entities", []) loops = _active_profile_loops(sketch, operation) workplane = _aligned_workplane_for_owned_midplane(sketch, operation, loops) code = [f" # Sketch: {name}"] origin = workplane.get("origin_mm", [0, 0, 0]) x_dir = workplane.get("x_dir", [1, 0, 0]) normal = workplane.get("normal", [0, 0, 1]) if origin != [0, 0, 0] or x_dir != [1, 0, 0] or normal != [0, 0, 1]: code.append( f" with BuildSketch(Plane(origin={_tuple3(origin)}, x_dir={_tuple3(x_dir)}, z_dir={_tuple3(normal)})) as sketch:" ) else: code.append(" with BuildSketch() as sketch:") loop_entities = [] processed_indices = set() for loop in loops: for idx in loop.get("entity_indices", []): if idx < len(entities): loop_entities.append(entities[idx]) processed_indices.add(idx) append_unprocessed = not loops for i, ent in enumerate(entities): if append_unprocessed and i not in processed_indices: loop_entities.append(ent) drawable_entities = [ent for ent in loop_entities if not ent.get("construction", False)] circle_entities = [ ent for ent in drawable_entities if ent.get("type") in ("circle", "arc") and ent.get("is_circle", ent.get("type") == "circle") ] wire_entities = [ ent for ent in drawable_entities if ent not in circle_entities and ent.get("type") in ("line", "arc") ] wire_entities = _ordered_wire_entities(wire_entities) handled_circle_entities = set() if not loops and len(circle_entities) > 1: ranked_circles = sorted( enumerate(circle_entities), key=lambda item: float(item[1].get("radius_mm", 0) or 0), reverse=True, ) outer_index, outer = ranked_circles[0] outer_center = outer.get("center", [0, 0, 0]) outer_radius = float(outer.get("radius_mm", 0) or 0) contains_all = outer_radius > 0 for _, inner in ranked_circles[1:]: inner_center = inner.get("center", [0, 0, 0]) inner_radius = float(inner.get("radius_mm", 0) or 0) center_distance = math.hypot( float(inner_center[0]) - float(outer_center[0]), float(inner_center[1]) - float(outer_center[1]), ) if center_distance + inner_radius >= outer_radius - 1e-6: contains_all = False break if contains_all: code.append(f" with Locations(({outer_center[0]}, {outer_center[1]})):") code.append(f" Circle({outer_radius})") handled_circle_entities.add(outer_index) for inner_index, inner in ranked_circles[1:]: center = inner.get("center", [0, 0, 0]) radius = inner.get("radius_mm", 1) code.append(f" with Locations(({center[0]}, {center[1]})):") code.append(f" Circle({radius}, mode=Mode.SUBTRACT)") handled_circle_entities.add(inner_index) def circle_is_inner_profile(ent: Dict[str, Any]) -> bool: if op_type != "extrude_add" or not loops: return False center = ent.get("center", [0, 0]) radius = float(ent.get("radius_mm", 0) or 0) if radius <= 0 or len(center) < 2: return False bbox = [ float(center[0]) - radius, float(center[1]) - radius, float(center[0]) + radius, float(center[1]) + radius, ] return any(_bbox_contains_2d(loop.get("bbox_mm"), bbox, tolerance=1e-4) for loop in loops) if not loops: for circle_index, ent in enumerate(circle_entities): if circle_index in handled_circle_entities: continue center = ent.get("center", [0, 0, 0]) radius = ent.get("radius_mm", 1) code.append(f" with Locations(({center[0]}, {center[1]})):") if circle_is_inner_profile(ent): code.append(f" Circle({radius}, mode=Mode.SUBTRACT)") else: code.append(f" Circle({radius})") def orient_wire_entities(profile_entities: list[Dict[str, Any]]) -> list[Dict[str, Any]]: """Orient contour segments into a continuous closed wire. SolidWorks contour arrays preserve membership but not necessarily each segment's traversal direction. Reversing an arc must also invert its curve axis; otherwise a short arc becomes its 270-degree complement. """ segments = [deepcopy(entity) for entity in profile_entities] if len(segments) < 2: return segments def endpoints(entity: Dict[str, Any]) -> tuple[Optional[list[float]], Optional[list[float]]]: start = entity.get("start") end = entity.get("end") if not (isinstance(start, list) and isinstance(end, list) and len(start) >= 2 and len(end) >= 2): return None, None return [float(start[0]), float(start[1])], [float(end[0]), float(end[1])] def distance(left: list[float], right: list[float]) -> float: return math.hypot(left[0] - right[0], left[1] - right[1]) def reverse(entity: Dict[str, Any]) -> Dict[str, Any]: reversed_entity = deepcopy(entity) reversed_entity["start"], reversed_entity["end"] = entity.get("end"), entity.get("start") axis = reversed_entity.get("curve_axis") or (reversed_entity.get("raw") or {}).get("curve_axis") if isinstance(axis, list) and len(axis) >= 3: reversed_entity["curve_axis"] = [-float(value) for value in axis[:3]] # 删除预置角度，强制代码生成时从翻转后的start/end重新计算 reversed_entity.pop("start_angle_deg", None) reversed_entity.pop("end_angle_deg", None) reversed_entity.pop("arc_sweep_deg", None) if entity.get("type") == "arc": center = entity.get("center") or [0.0, 0.0] start = reversed_entity.get("start") or [0.0, 0.0] end = reversed_entity.get("end") or [0.0, 0.0] start_angle = math.degrees(math.atan2(float(start[1]) - float(center[1]), float(start[0]) - float(center[0]))) end_angle = math.degrees(math.atan2(float(end[1]) - float(center[1]), float(end[0]) - float(center[0]))) reversed_sweep = end_angle - start_angle if reversed_sweep <= -180: reversed_sweep += 360 elif reversed_sweep > 180: reversed_sweep -= 360 reversed_entity["arc_sweep_deg"] = reversed_sweep return reversed_entity ordered = [segments.pop(0)] while segments: _, previous_end = endpoints(ordered[-1]) if previous_end is None: ordered.extend(segments) break candidates = [] for index, candidate in enumerate(segments): candidate_start, candidate_end = endpoints(candidate) if candidate_start is None or candidate_end is None: continue candidates.append((distance(previous_end, candidate_start), index, candidate)) candidates.append((distance(previous_end, candidate_end), index, reverse(candidate))) if not candidates: ordered.extend(segments) break _, selected_index, selected = min(candidates, key=lambda item: item[0]) ordered.append(selected) segments.pop(selected_index) return ordered def append_wire_profile(profile_entities: list[Dict[str, Any]], make_face_mode: Optional[str] = None) -> None: profile_entities = orient_wire_entities(profile_entities) code.append(" with BuildLine():") code.append(" pass") emitted_wire = False line_points = [] for line_ent in profile_entities: if line_ent.get("type") == "line": line_points.extend([line_ent.get("start", [0, 0]), line_ent.get("end", [0, 0])]) line_bbox = None if line_points: xs = [float(point[0]) for point in line_points] ys = [float(point[1]) for point in line_points] line_bbox = (min(xs), min(ys), max(xs), max(ys)) for ent in profile_entities: ent_type = ent.get("type", "") if ent_type == "line": start = ent.get("start", [0, 0, 0]) end = ent.get("end", [0, 0, 0]) if math.hypot(float(start[0]) - float(end[0]), float(start[1]) - float(end[1])) <= 1e-6: code.append(" # Skip zero-length line") continue code.append(f" Line(({start[0]}, {start[1]}), ({end[0]}, {end[1]}))") emitted_wire = True elif ent_type == "arc": center = ent.get("center", [0, 0, 0]) radius = ent.get("radius_mm", 1) if "start_angle_deg" in ent and "end_angle_deg" in ent: start_angle = ent["start_angle_deg"] end_angle = ent["end_angle_deg"] else: start = ent.get("start", [0, 0]) end = ent.get("end", [0, 0]) start_angle = math.degrees(math.atan2(start[1] - center[1], start[0] - center[0])) end_angle = math.degrees(math.atan2(end[1] - center[1], end[0] - center[0])) if ent.get("arc_sweep_deg") is not None: arc_size = float(ent["arc_sweep_deg"]) else: curve_axis = ent.get("curve_axis") or ent.get("raw", {}).get("curve_axis") if isinstance(curve_axis, list) and len(curve_axis) >= 3 and abs(float(curve_axis[2])) > 1e-9: if float(curve_axis[2]) >= 0: arc_size = (end_angle - start_angle) % 360 else: arc_size = -((start_angle - end_angle) % 360) else: arc_size = end_angle - start_angle if arc_size <= 0: arc_size += 360 if arc_size > 180: arc_size -= 360 code.append(f" CenterArc(({center[0]}, {center[1]}), {radius}, {start_angle}, {arc_size})") emitted_wire = True else: code.append(f" # TODO: entity type {ent_type}") if not emitted_wire: code.append(" # Skip empty wire profile") return if make_face_mode: code.append(f" make_face(mode=Mode.{make_face_mode.upper()})") else: code.append(" make_face()") if loops: ordered_loops = sorted( enumerate(loops), key=lambda item: (1 if item[1].get("profile_mode") == "subtract" else 0, item[0]), ) for loop_order_index, (loop_index, loop) in enumerate(ordered_loops): profile_entities = [ entities[idx] for idx in loop.get("entity_indices", []) if idx < len(entities) and not entities[idx].get("construction", False) and entities[idx].get("type") in ("line", "arc", "circle") ] circle_profile_entities = [ ent for ent in profile_entities if ent.get("type") == "circle" or (ent.get("type") == "arc" and ent.get("is_circle")) ] wire_profile_entities = [ ent for ent in profile_entities if ent.get("type") in ("line", "arc") and ent not in circle_profile_entities ] wire_profile_entities = _ordered_wire_entities(wire_profile_entities) if not profile_entities: continue mode = loop.get("profile_mode") if wire_profile_entities: append_wire_profile(wire_profile_entities, mode if loop_order_index > 0 or mode else None) else: for ent in circle_profile_entities: center = ent.get("center", [0, 0, 0]) radius = ent.get("radius_mm", 1) code.append(f" with Locations(({center[0]}, {center[1]})):") if mode == "subtract": code.append(f" Circle({radius}, mode=Mode.SUBTRACT)") else: code.append(f" Circle({radius})") elif wire_entities: append_wire_profile(wire_entities) return code def _sketch_circle_radii_mm(sketch: Optional[Dict[str, Any]]) -> list[float]: if not isinstance(sketch, dict): return [] radii = [] for entity in sketch.get("entities", []) or []: if entity.get("construction") or entity.get("type") != "circle": continue radius = float(entity.get("radius_mm") or 0) if radius > 0: radii.append(abs(radius)) return radii def _flip_side_step_inner_radius_mm( op: Dict[str, Any], sketch: Optional[Dict[str, Any]], operations: list[Dict[str, Any]], sketches: Dict[str, Dict[str, Any]], ) -> Optional[float]: outer_radii = _sketch_circle_radii_mm(sketch) if not outer_radii: return None outer = max(outer_radii) if len(outer_radii) > 1: return min(outer_radii) inner = None try: op_index = operations.index(op) except ValueError: op_index = len(operations) for prev in operations[:op_index]: if prev.get("type") != "extrude_cut": continue if not (prev.get("parameters") or {}).get("flip_side_to_cut"): continue prev_sketch = sketches.get(prev.get("sketch") or "", {}) for radius in _sketch_circle_radii_mm(prev_sketch): if radius < outer - 1e-6: inner = radius if inner is None else max(inner, radius) return inner def _flip_side_uses_step_ring( op: Dict[str, Any], sketch: Optional[Dict[str, Any]], operations: list[Dict[str, Any]], sketches: Dict[str, Dict[str, Any]], ) -> tuple[Optional[float], Optional[float]]: outer_radii = _sketch_circle_radii_mm(sketch) if not outer_radii: return None, None outer = max(outer_radii) inner = _flip_side_step_inner_radius_mm(op, sketch, operations, sketches) if inner is None or outer <= inner + 0.5: return None, None if outer < 35 and outer / inner < 1.5: return None, None return outer, inner def _effective_extrude_cut_depth_mm( op: Dict[str, Any], sketch: Optional[Dict[str, Any]], distance_mm: float, ) -> float: params = op.get("parameters") if isinstance(op.get("parameters"), dict) else {} if not params.get("flip_side_to_cut"): return distance_mm workplane = (sketch or {}).get("workplane") or {} origin = workplane.get("origin_mm") or [0.0, 0.0, 0.0] normal = workplane.get("normal") or [0.0, 0.0, 1.0] if not isinstance(origin, list) or not isinstance(normal, list) or len(origin) < 3 or len(normal) < 3: return distance_mm axis = max(range(3), key=lambda idx: abs(float(normal[idx]))) cut_amount = distance_mm if params.get("reverse_direction", False) else -abs(distance_mm) cut_sign = -1.0 if cut_amount < 0 else 1.0 owned_values = [] for face in op.get("source_owned_faces") or []: if not isinstance(face, dict): continue surface = face.get("surface") if isinstance(face.get("surface"), dict) else {} if not surface.get("is_plane"): continue box = face.get("box_m") if not isinstance(box, list) or len(box) < 6: continue thicknesses = [abs(float(box[i + 3]) - float(box[i])) * 1000 for i in range(3)] if min(thicknesses) > 0.5: continue owned_values.extend([float(box[axis]) * 1000, float(box[axis + 3]) * 1000]) if not owned_values: return distance_mm transition = (min(owned_values) if cut_sign < 0 else max(owned_values)) + cut_sign * 1.0 effective = abs(float(origin[axis]) - transition) if effective <= 1e-6: return distance_mm if abs(effective - abs(distance_mm)) <= 0.25: return distance_mm # Guard: owned-face depth can be wrong when all owned faces # are near the sketch plane (e.g., edge details), not at the # real cut termination. Fall back to a through-cut distance # so the invert-cutter extends past the entire body. if effective < max(2.0, abs(distance_mm) * 0.15): return max(distance_mm, THROUGH_CUT_AMOUNT_MM) return effective def _owned_extrude_terminal_offsets_mm( op: Dict[str, Any], sketch: Optional[Dict[str, Any]], ) -> tuple[Optional[float], Optional[float]]: """Return the nearest owned planar end faces along the sketch normal. SolidWorks can report a two-sided feature with a stale blind depth when one side terminates on geometry. The feature-owned end face is the reliable result geometry: its signed offset from the sketch plane identifies the actual termination direction and distance. """ workplane = (sketch or {}).get("workplane") or {} origin = workplane.get("origin_mm") or [] normal = workplane.get("normal") or [] if not (isinstance(origin, list) and isinstance(normal, list) and len(origin) >= 3 and len(normal) >= 3): return None, None magnitude = math.sqrt(sum(float(value) ** 2 for value in normal[:3])) if magnitude <= 1e-9: return None, None unit_normal = [float(value) / magnitude for value in normal[:3]] positive: list[float] = [] negative: list[float] = [] for face in op.get("source_owned_faces") or []: if not isinstance(face, dict): continue surface = face.get("surface") if isinstance(face.get("surface"), dict) else {} if not surface.get("is_plane"): continue params = surface.get("plane_params") if not isinstance(params, list) or len(params) < 6: continue point_mm = [float(value) * 1000 for value in params[3:6]] offset = sum((point_mm[index] - float(origin[index])) * unit_normal[index] for index in range(3)) if offset > 1e-4: positive.append(offset) elif offset < -1e-4: negative.append(offset) return (max(positive) if positive else None, min(negative) if negative else None) def _resolve_extrude_owned_termination( op: Dict[str, Any], sketch: Optional[Dict[str, Any]], ) -> Dict[str, Any]: """Resolve an asymmetric two-sided add from its SolidWorks-owned end face.""" params = op.get("parameters") if isinstance(op.get("parameters"), dict) else {} if op.get("type") != "extrude_add" or not params.get("both_directions"): return op positive, negative = _owned_extrude_terminal_offsets_mm(op, sketch) if (positive is None) == (negative is None): return op resolved = dict(op) resolved_params = dict(params) resolved_params["distance_mm"] = positive if positive is not None else abs(float(negative)) resolved_params["reverse_distance_mm"] = 0 resolved_params["both_directions"] = False resolved_params["reverse_direction"] = negative is not None resolved_params["owned_termination_resolved"] = True resolved["parameters"] = resolved_params return resolved def _generate_extrude( op: Dict[str, Any], sketch: Optional[Dict[str, Any]] = None, operations: Optional[list[Dict[str, Any]]] = None, sketches: Optional[Dict[str, Dict[str, Any]]] = None, ) -> list[str]: params = op.get("parameters", {}) distance = _effective_extrude_cut_depth_mm(op, sketch, float(params.get("distance_mm", 10) or 10)) reverse_distance = params.get("reverse_distance_mm", 0) op_type = op.get("type", "") name = op.get("name", "") both_directions = params.get("both_directions", False) flip_side_to_cut = bool(params.get("flip_side_to_cut", False)) end_condition_code = params.get("end_condition_code") reverse_end_condition_code = params.get("reverse_end_condition_code") end_condition = SW_END_CONDITIONS.get(end_condition_code, f"Unknown({end_condition_code})") operations = operations or [] sketches = sketches or {} outer_radius, inner_radius = ( _flip_side_uses_step_ring(op, sketch, operations, sketches) if flip_side_to_cut else (None, None) ) resolved_owned_termination = bool(params.get("owned_termination_resolved")) code = [f" # {op_type}: {name}"] if resolved_owned_termination: code.append(" # Use the owned planar end face to resolve SW's asymmetric termination") preserve_visible = bool(op.get("source_owned_faces")) and op_type == "extrude_add" if end_condition_code is not None: code.append(f" # SW end condition: {end_condition}") owned_cylinder_faces = _owned_cylindrical_cut_faces(op, sketch or {}) prefer_blind_sketch = _prefer_blind_sketch_extrude( op, sketch or {}, distance, end_condition_code, owned_cylinder_faces ) if op_type == "extrude_cut" and owned_cylinder_faces and flip_side_to_cut: code.append(" # Replay SW flip-side circular cut from owned cylindrical faces") code.append(f" result = cut_owned_flip_side_cylindrical_faces(result, {repr(owned_cylinder_faces)})") return code if op_type == "extrude_cut" and owned_cylinder_faces and not flip_side_to_cut and not prefer_blind_sketch: code.append(" # Replay cut from SW owned cylindrical faces when start/end references are missing") code.append(f" result = cut_owned_cylindrical_faces(result, {repr(owned_cylinder_faces)})") return code owned_bbox = _owned_bbox_cut(op, sketch or {}, distance) if op_type == "extrude_cut" and owned_bbox and not flip_side_to_cut and not prefer_blind_sketch: code.append(" # Replay cut from SW owned face bbox when extrude start/end references are missing") code.append(f" result = cut_owned_bbox(result, {repr(owned_bbox)})") return code if distance == 0 and reverse_distance == 0: if op_type == "extrude_cut" and end_condition_code not in (None, 0): distance = THROUGH_CUT_AMOUNT_MM both_directions = end_condition_code in (1, 2, 9) code.append(f" # TODO: exact sw_extrude_cut_{end_condition}; using long cutter") else: code.append(" # Skip: zero distance") return code elif op_type == "extrude_add" and (end_condition_code in (6, 8) or reverse_end_condition_code in (6, 8)): code.append(" # SW mid-plane/two-sided extrusion represented by this IR") distance = distance / 2 reverse_distance = distance both_directions = True elif op_type == "extrude_cut" and end_condition_code not in (None, 0): distance = max(distance, reverse_distance, THROUGH_CUT_AMOUNT_MM) both_directions = both_directions or end_condition_code in (1, 2, 9) code.append(f" # TODO: exact sw_extrude_cut_{end_condition}; using long cutter") if both_directions: amount = max(distance, reverse_distance) if reverse_distance > 0 else distance if op_type == "extrude_cut": code.append(f" cutter = extrude(sketch.sketch, amount={amount}, both=True)") if flip_side_to_cut: normal = (sketch or {}).get("workplane", {}).get("normal", [0, 0, 1]) if outer_radius is not None and inner_radius is not None: code.append( " result = sw_flip_side_step_cut(" f"result, cutter, normal={_tuple3(normal)}, " f"outer_radius_mm={outer_radius}, inner_radius_mm={inner_radius})" ) else: code.append(f" result = sw_inverted_profile_cut(result, cutter, normal={_tuple3(normal)})") else: code.append(" result = safe_subtract(result, cutter)") else: code.append(f" solid = extrude(sketch.sketch, amount={amount}, both=True)") code.append(f" result = safe_union(result, solid, preserve_visible={preserve_visible})") elif op_type == "extrude_cut": if distance > 0: cut_amount = distance if params.get("reverse_direction", False) else -distance code.append(f" cutter = extrude(sketch.sketch, amount={cut_amount})") # 当盲拉伸从不同于草图的起始面开始时，平移cutter到正确位置 if prefer_blind_sketch: face_offset = _blind_extrude_face_offset(op, sketch or {}) if face_offset is not None: code.append(f" cutter = cutter.locate(Location({_tuple3(face_offset)}))") if flip_side_to_cut: normal = (sketch or {}).get("workplane", {}).get("normal", [0, 0, 1]) if outer_radius is not None and inner_radius is not None: code.append( " result = sw_flip_side_step_cut(" f"result, cutter, normal={_tuple3(normal)}, " f"outer_radius_mm={outer_radius}, inner_radius_mm={inner_radius})" ) else: code.append(f" result = sw_inverted_profile_cut(result, cutter, normal={_tuple3(normal)})") else: code.append(" result = safe_subtract(result, cutter)") else: code.append(" # Skip: zero distance cut") else: add_amount = -distance if params.get("reverse_direction", False) else distance code.append(f" solid = extrude(sketch.sketch, amount={add_amount})") code.append(f" result = safe_union(result, solid, preserve_visible={preserve_visible})") return code def _owned_cylindrical_cut_faces(op: Dict[str, Any], sketch: Dict[str, Any]) -> list[Dict[str, Any]]: if op.get("type") != "extrude_cut": return [] sketch_radii = [ abs(float(entity.get("radius_mm") or 0)) for entity in sketch.get("entities", []) or [] if not entity.get("construction") and entity.get("type") == "circle" ] if not sketch_radii: return [] matched = [] for face in op.get("source_owned_faces") or []: if not isinstance(face, dict): continue surface = face.get("surface") if isinstance(face.get("surface"), dict) else {} params = surface.get("cylinder_params") bbox = face.get("box_m") if not (surface.get("is_cylinder") and isinstance(params, list) and len(params) >= 7): continue if not (isinstance(bbox, list) and len(bbox) >= 6): continue radius_mm = abs(float(params[6]) * 1000) if not any(abs(radius_mm - sketch_radius) <= max(0.05, sketch_radius * 0.01) for sketch_radius in sketch_radii): continue matched.append(face) return matched def _blind_extrude_face_offset( op: Dict[str, Any], sketch: Dict[str, Any], ) -> Optional[list[float]]: """当盲拉伸从不同于草图的起始面开始时，计算cutter的3D平移向量。 返回None表示不需要平移。""" faces = (op.get("source_owned_faces") or []) if not faces: return None valid_bboxes = [] for face in faces: bm = face.get("box_m") if isinstance(bm, list) and len(bm) >= 6: valid_bboxes.append([float(v) * 1000 for v in bm[:6]]) if not valid_bboxes: return None normal = (sketch.get("workplane") or {}).get("normal") if not isinstance(normal, list) or len(normal) < 3: return None origin = (sketch.get("workplane") or {}).get("origin_mm") or [0, 0, 0] # 确定主导轴 (extrude方向) axis = max(range(3), key=lambda idx: abs(float(normal[idx]))) normal_sign = 1.0 if float(normal[axis]) >= 0 else -1.0 sketch_coord = float(origin[axis]) if isinstance(origin, list) and len(origin) > axis else 0.0 # 取离草图平面最近的面坐标，使cutter从面的最近点开始切入 # 对于多个面，面可能在草图平面两侧。 all_coords = [] for b in valid_bboxes: all_coords.append(b[axis]) all_coords.append(b[axis + 3]) if not all_coords: return None # 找离sketch_coord最近的面坐标 face_coord = min(all_coords, key=lambda c: abs(c - sketch_coord)) offset = face_coord - sketch_coord if abs(offset) < 1e-3: return None # 返回3D平移向量(仅沿extrude方向) result = [0.0, 0.0, 0.0] result[axis] = offset return result def _prefer_blind_sketch_extrude( op: Dict[str, Any], sketch: Dict[str, Any], distance_mm: float, end_condition_code: Optional[int], owned_cylinder_faces: list[Dict[str, Any]], ) -> bool: """优先使用盲拉伸而非 bbox 回退。对于矩形/圆等简单截面， 盲拉伸比包围盒近似精确得多。含弧的复杂截面可能因方向问题 产生意外偏差，此时仍走 bbox 路径。""" if owned_cylinder_faces: return False if end_condition_code not in (None, 0) or distance_mm <= 0: return False if not _sketch_has_buildable_profile(sketch): return False # 有 owned_faces 的矩形或纯圆截面: 盲拉伸比 bbox 更精确 entities = sketch.get("entities", []) or [] non_const = [e for e in entities if not e.get("construction", False)] types = {e.get("type") for e in non_const if e.get("type") not in ("point", "text")} # 排除point/text后仍是简单截面才用盲拉伸。 # 但如果面位于不同平面，让_blind_extrude_face_offset处理 is_simple = types <= {"line"} or types <= {"circle"} if not is_simple: return False # 检查草图平面与面是否有关键偏移 - 只有当盲拉伸需要偏移修正时才使用 faces = op.get("source_owned_faces") or [] if faces and _blind_extrude_face_offset(op, sketch) is not None: return True # 有面偏移，需要盲拉伸+offset修正 # 无面偏移时，只有当start/end引用完整时才用盲拉伸 if op.get("start_reference") or op.get("end_reference"): return True return False def _owned_bbox_cut(op: Dict[str, Any], sketch: Dict[str, Any], distance_mm: float) -> Optional[list[float]]: if op.get("type") != "extrude_cut": return None faces = [ face for face in (op.get("source_owned_faces") or []) if isinstance(face, dict) and isinstance(face.get("box_m"), list) and len(face.get("box_m")) >= 6 ] if not faces: return None bboxes = [[float(value) * 1000 for value in face["box_m"][:6]] for face in faces] bbox = [ min(box[axis] for box in bboxes) if axis < 3 else max(box[axis] for box in bboxes) for axis in range(6) ] normal = (sketch.get("workplane") or {}).get("normal") or [0, 0, 1] if not isinstance(normal, list) or len(normal) < 3: return None axis = max(range(3), key=lambda idx: abs(float(normal[idx]))) extent = abs(bbox[axis + 3] - bbox[axis]) origin = (sketch.get("workplane") or {}).get("origin_mm") or [0, 0, 0] origin_coord = float(origin[axis]) if isinstance(origin, list) and len(origin) > axis else None distance = abs(float(distance_mm or 0)) origin_outside = ( origin_coord is not None and (origin_coord < min(bbox[axis], bbox[axis + 3]) - 1e-6 or origin_coord > max(bbox[axis], bbox[axis + 3]) + 1e-6) ) if extent <= distance * 1.25 and not origin_outside: return None return bbox def _generate_revolve(op: Dict[str, Any], sketch: Optional[Dict[str, Any]] = None) -> list[str]: params = op.get("parameters", {}) angle = params.get("angle_deg") if angle is None and params.get("angle_rad") is not None: angle = float(params.get("angle_rad")) * 180 / math.pi if angle is None: angle = 360 if abs(angle - 360) < 1e-6: angle = 360 op_type = op.get("type", "") name = op.get("name", "") code = [f" # {op_type}: {name}"] axis_expr = _revolve_axis_expr(params, sketch or {}) code.append(f" revolve_axis = {axis_expr}") if op_type == "revolve_cut": code.append(f" cutter = revolve(sketch.sketch, axis=revolve_axis, revolution_arc={angle})") code.append(" # Force OCCT to fully evaluate both solids before Boolean ops") code.append(" _ = list(cutter.solids()); _ = cutter.is_valid; _ = cutter.volume") code.append(" _ = list(result.solids()); _ = result.is_valid; _ = result.volume") code.append(" # Use a single subtract and capture the result directly (avoids OCCT heisenbug)") code.append(" result = safe_subtract(result, cutter)") else: code.append(f" solid = revolve(sketch.sketch, axis=revolve_axis, revolution_arc={angle})") preserve_visible = bool(op.get("source_owned_faces")) code.append(f" result = safe_union(result, solid, preserve_visible={preserve_visible})") return code def _revolve_axis_expr(params: Dict[str, Any], sketch: Dict[str, Any]) -> str: # 优先使用草图中的构造线作为旋转轴， # 因为它保证位于草图平面上（SW 的 revolve 操作依赖于此） construction_axis = _sketch_construction_axis(sketch) if construction_axis: origin, direction = construction_axis return f"Axis({_tuple3(origin)}, {_tuple3(direction)})" axis_reference = params.get("axis_reference") or {} if axis_reference.get("origin_mm") and axis_reference.get("direction"): return f"Axis({_tuple3(axis_reference['origin_mm'])}, {_tuple3(axis_reference['direction'])})" for candidate in params.get("axis_candidates") or []: if candidate.get("model_start_mm") and candidate.get("model_direction"): return f"Axis({_tuple3(candidate['model_start_mm'])}, {_tuple3(candidate['model_direction'])})" workplane = sketch.get("workplane", {}) origin = workplane.get("origin_mm", [0, 0, 0]) direction = workplane.get("x_dir", [1, 0, 0]) return f"Axis({_tuple3(origin)}, {_tuple3(direction)})" def _sketch_construction_axis( sketch: Dict[str, Any], ) -> Optional[tuple[list[float], list[float]]]: workplane = sketch.get("workplane", {}) origin = [float(v) for v in workplane.get("origin_mm", [0, 0, 0])] x_dir = [float(v) for v in workplane.get("x_dir", [1, 0, 0])] y_dir = [float(v) for v in workplane.get("y_dir", [0, 1, 0])] for entity in sketch.get("entities", []): if entity.get("type") != "line" or not entity.get("construction"): continue start = entity.get("start") end = entity.get("end") if not start or not end: continue start_3d = _sketch_point_to_model_from_basis(origin, x_dir, y_dir, start) end_3d = _sketch_point_to_model_from_basis(origin, x_dir, y_dir, end) direction = [end_3d[i] - start_3d[i] for i in range(3)] length = math.sqrt(sum(component * component for component in direction)) if length <= 0: continue return start_3d, [component / length for component in direction] return None def _sketch_point_to_model_from_basis( origin: list[float], x_dir: list[float], y_dir: list[float], point: list[float] ) -> list[float]: return [ origin[i] + x_dir[i] * float(point[0]) + y_dir[i] * float(point[1]) for i in range(3) ] def _generate_fillet(op: Dict[str, Any]) -> list[str]: params = op.get("parameters", {}) radius = params.get("radius_mm") selectors = op.get("selectors", []) owned_faces = op.get("source_owned_faces") or [] if not radius or float(radius) <= 0: return [f" # Fillet skipped: source radius missing for {op.get('name', '')}"] return [ f" # Fillet: {op.get('name', '')}", " result = fillet_selected(" f"result, radius={radius}, selectors={repr(selectors)}, owned_faces={repr(owned_faces)})", ] def _generate_chamfer(op: Dict[str, Any]) -> list[str]: params = op.get("parameters", {}) distance = params.get("distance_mm") selectors = op.get("selectors", []) owned_faces = op.get("source_owned_faces") or [] if not distance or float(distance) <= 0: return [f" # Chamfer skipped: source distance missing for {op.get('name', '')}"] return [ f" # Chamfer: {op.get('name', '')}", " result = chamfer_selected_with_owned_faces(" f"result, distance={distance}, selectors={repr(selectors)}, owned_faces={repr(owned_faces)})", ] def _generate_move_face(op: Dict[str, Any]) -> list[str]: data = (op.get("parameters") or {}).get("move_face_data") or {} selected_faces = data.get("selected_faces") or [] return [ f" # MoveFace pure-JSON operation: {op.get('name', '')}", " raise NotImplementedError(", f" 'MoveFace native build123d replay is pending; captured selected_faces={len(selected_faces)}'", " )", ] def _hole_should_use_sw_cut_holes(params: Dict[str, Any], owned_cut_faces: list[Dict[str, Any]]) -> bool: positions = params.get("positions") or [] diameter = _hole_diameter_mm(params) if not positions or diameter <= 0: return False if len(owned_cut_faces) <= 1: return False has_cone_owned = any((face.get("surface") or {}).get("is_cone") for face in owned_cut_faces) drill_angle = _hole_drill_angle_rad(params) if has_cone_owned and not (_hole_has_drill_tip(params) and drill_angle > 0): return False counterbore_diameter = _hole_counterbore_diameter_mm(params) counterbore_depth = _hole_counterbore_depth_mm(params) if counterbore_diameter > diameter and counterbore_depth > 0: return True return _hole_has_through_dimension(params) def _effective_hole_cut_depth_mm(params: Dict[str, Any]) -> float: if _hole_has_through_dimension(params): return THROUGH_CUT_AMOUNT_MM return _hole_depth_mm(params) def _generate_hole(op: Dict[str, Any]) -> list[str]: params = op.get("parameters", {}) diameter = _hole_diameter_mm(params) depth = _effective_hole_cut_depth_mm(params) drill_angle = _hole_drill_angle_rad(params) include_drill_tip = _hole_has_drill_tip(params) countersink_diameter = _hole_countersink_diameter_mm(params) countersink_angle = _hole_countersink_angle_rad(params) counterbore_diameter = _hole_counterbore_diameter_mm(params) counterbore_depth = _hole_counterbore_depth_mm(params) positions = [pos.get("mm") for pos in params.get("positions", []) if pos.get("mm")] host_face = params.get("host_face") or {} owned_cut_faces = _hole_owned_cut_faces(op) # Feature position sketches are occasionally incomplete in the plugin export # (notably for wizard holes with multiple instances). The faces owned by the # feature are the authoritative result from SolidWorks, including every hole # location, counterbore, countersink, and drill tip. Prefer replaying those # surfaces whenever they are available; fall back to the parametric cutter # only when the exporter has no usable owned-face geometry. if owned_cut_faces: return [ f" # Hole: {op.get('name', '')}", " # Replay hole from SW owned cut faces to preserve side and axis", f" result = cut_owned_cylindrical_faces(result, {repr(owned_cut_faces)})", ] return [ f" # Hole: {op.get('name', '')}", f" result = sw_cut_holes(result, positions={json.dumps(positions)}, host_face={json.dumps(host_face)}, diameter={diameter}, depth={depth}, drill_angle={drill_angle}, include_drill_tip={include_drill_tip}, countersink_diameter={countersink_diameter}, countersink_angle={countersink_angle}, counterbore_diameter={counterbore_diameter}, counterbore_depth={counterbore_depth})", ] def _hole_owned_cut_faces(op: Dict[str, Any]) -> list[Dict[str, Any]]: matched = [] for face in op.get("source_owned_faces") or []: if not isinstance(face, dict): continue surface = face.get("surface") if isinstance(face.get("surface"), dict) else {} bbox = face.get("box_m") has_cylinder = ( surface.get("is_cylinder") and isinstance(surface.get("cylinder_params"), list) and len(surface.get("cylinder_params") or []) >= 7 ) has_cone = ( surface.get("is_cone") and isinstance(surface.get("cone_params"), list) and len(surface.get("cone_params") or []) >= 8 ) if not (has_cylinder or has_cone): continue if not (isinstance(bbox, list) and len(bbox) >= 6): continue matched.append(face) return matched def _generate_linear_pattern( op: Dict[str, Any], operations: list[Dict[str, Any]], sketches: Dict[str, Dict[str, Any]], references: Dict[str, Any], ) -> list[str]: params = op.get("parameters", {}) source_features = params.get("source_features") or [] offsets = _linear_pattern_offsets(op) code = [f" # Linear pattern: {op.get('name', '')}"] if not source_features or not offsets: code.append(" # Skip: no source features or pattern offsets") return code for source_feature in source_features: source_op = _find_operation_for_source_feature(operations, source_feature) if not source_op: code.append(f" # Skip: source feature not found {source_feature.get('name')}") continue for offset_index, offset in enumerate(offsets, start=1): copied_op = _translated_operation(source_op, offset) copied_op["name"] = f"{source_op.get('name', '')} pattern copy {offset_index}" op_type = copied_op.get("type") if op_type == "hole": code.extend(_generate_hole(copied_op)) elif op_type in ("extrude_cut", "extrude_add", "revolve_cut", "revolve_add"): source_sketch_id = copied_op.get("sketch") source_sketch = sketches.get(source_sketch_id or "") if not source_sketch: code.append(f" # Skip: source sketch not found for {copied_op.get('name')}") continue if not _sketch_has_buildable_profile(source_sketch): code.append(f" # Skip: source sketch has no buildable profile for {copied_op.get('name')}") continue copied_sketch = _translated_sketch(source_sketch, offset, f"{source_sketch_id}_pattern_{offset_index}") code.extend(_generate_sketch(copied_sketch, references, copied_op)) if op_type in ("extrude_cut", "extrude_add"): code.extend(_generate_extrude(copied_op, copied_sketch, operations, sketches)) else: code.extend(_generate_revolve(copied_op, copied_sketch)) else: code.append(f" # TODO: pattern source type {op_type}") return code def _generate_mirror_pattern( op: Dict[str, Any], operations: list[Dict[str, Any]], sketches: Dict[str, Dict[str, Any]], references: Dict[str, Any], ) -> list[str]: """生成镜像代码。SW MirrorPattern 镜像的是特征而非整体，因此必须先切掉镜像面负侧的实体，只保留正侧一半再镜像。""" params = op.get("parameters", {}) source_features = params.get("source_features") or [] raw = op.get("raw_parameters", {}) mirror_plane_info = raw.get("mirror_plane") or {} code = [f" # Mirror pattern: {op.get('name', '')}"] plane_origin = _extract_mirror_plane_origin(raw, mirror_plane_info) plane_normal = _extract_mirror_plane_normal(raw, mirror_plane_info) mx = plane_origin[0] if plane_origin else 0.0 my = plane_origin[1] if plane_origin else 0.0 mz = plane_origin[2] if plane_origin else 0.0 nx = plane_normal[0] if plane_normal else 0.0 ny = plane_normal[1] if plane_normal else 0.0 nz = plane_normal[2] if plane_normal else 1.0 code.append(f" mirror_plane = Plane(origin=({mx}, {my}, {mz}), z_dir=({nx}, {ny}, {nz}))") code.append(f" mx, my, mz = {mx}, {my}, {mz}") code.append(f" nx, ny, nz = {nx}, {ny}, {nz}") code.append(f" try:") code.append(f" bbox = result.bounding_box()") code.append(f" margin = 10.0") # Determine dominant axis and cut away the -normal side adx, ady, adz = abs(nx), abs(ny), abs(nz) if adx >= ady and adx >= adz: if nx > 0: code.append(f" cut_w = (mx - bbox.min.X) + margin") code.append(f" cut_box = Solid.make_box(cut_w, bbox.max.Y - bbox.min.Y + 2*margin, bbox.max.Z - bbox.min.Z + 2*margin)") code.append(f" cut_box = cut_box.translate((bbox.min.X - margin, bbox.min.Y - margin, bbox.min.Z - margin))") else: code.append(f" cut_w = (bbox.max.X - mx) + margin") code.append(f" cut_box = Solid.make_box(cut_w, bbox.max.Y - bbox.min.Y + 2*margin, bbox.max.Z - bbox.min.Z + 2*margin)") code.append(f" cut_box = cut_box.translate((mx, bbox.min.Y - margin, bbox.min.Z - margin))") elif ady >= adx and ady >= adz: if ny > 0: code.append(f" cut_h = (my - bbox.min.Y) + margin") code.append(f" cut_box = Solid.make_box(bbox.max.X - bbox.min.X + 2*margin, cut_h, bbox.max.Z - bbox.min.Z + 2*margin)") code.append(f" cut_box = cut_box.translate((bbox.min.X - margin, bbox.min.Y - margin, bbox.min.Z - margin))") else: code.append(f" cut_h = (bbox.max.Y - my) + margin") code.append(f" cut_box = Solid.make_box(bbox.max.X - bbox.min.X + 2*margin, cut_h, bbox.max.Z - bbox.min.Z + 2*margin)") code.append(f" cut_box = cut_box.translate((bbox.min.X - margin, my, bbox.min.Z - margin))") else: if nz > 0: code.append(f" cut_d = (mz - bbox.min.Z) + margin") code.append(f" cut_box = Solid.make_box(bbox.max.X - bbox.min.X + 2*margin, bbox.max.Y - bbox.min.Y + 2*margin, cut_d)") code.append(f" cut_box = cut_box.translate((bbox.min.X - margin, bbox.min.Y - margin, bbox.min.Z - margin))") else: code.append(f" cut_d = (bbox.max.Z - mz) + margin") code.append(f" cut_box = Solid.make_box(bbox.max.X - bbox.min.X + 2*margin, bbox.max.Y - bbox.min.Y + 2*margin, cut_d)") code.append(f" cut_box = cut_box.translate((bbox.min.X - margin, bbox.min.Y - margin, mz))") code.append(f" half = result.cut(cut_box)") code.append(f" mirrored = half.mirror(mirror_plane)") code.append(f" result = half.fuse(mirrored).clean()") code.append(f" except Exception as e:") code.append(f" print(f'mirror failed: {{e}}')") return code def _extract_mirror_plane_origin(raw: dict, mirror_plane_info: dict): mir_origin = raw.get("mirror_plane_origin") if mir_origin and isinstance(mir_origin, (list, tuple)) and len(mir_origin) >= 3: return (float(mir_origin[0]), float(mir_origin[1]), float(mir_origin[2])) origin_list = mirror_plane_info.get("origin_mm") or mirror_plane_info.get("origin") or [] if origin_list and len(origin_list) >= 3: return (float(origin_list[0]), float(origin_list[1]), float(origin_list[2])) frame = mirror_plane_info.get("frame") if isinstance(frame, dict): origin_list = frame.get("origin") or [] if origin_list and len(origin_list) >= 3: return (float(origin_list[0]), float(origin_list[1]), float(origin_list[2])) return None def _extract_mirror_plane_normal(raw: dict, mirror_plane_info: dict): mir_normal = raw.get("mirror_plane_normal") if mir_normal and isinstance(mir_normal, (list, tuple)) and len(mir_normal) >= 3: return (float(mir_normal[0]), float(mir_normal[1]), float(mir_normal[2])) normal_list = mirror_plane_info.get("normal") or [] if normal_list and len(normal_list) >= 3: return (float(normal_list[0]), float(normal_list[1]), float(normal_list[2])) frame = mirror_plane_info.get("frame") if isinstance(frame, dict): normal_list = frame.get("normal") or [] if normal_list and len(normal_list) >= 3: return (float(normal_list[0]), float(normal_list[1]), float(normal_list[2])) return None def _find_operation_for_source_feature( operations: list[Dict[str, Any]], source_feature: Dict[str, Any] ) -> Optional[Dict[str, Any]]: source_index = source_feature.get("index") source_name = source_feature.get("name") source_identity = source_feature.get("identity") if isinstance(source_feature.get("identity"), dict) else {} source_stable_id = source_feature.get("stable_id") or source_identity.get("stable_id") source_persistent_reference = source_feature.get("persistent_reference") or source_identity.get("persistent_reference") for op in operations: op_source = op.get("source_feature", {}) if source_index is not None and op_source.get("index") == source_index: return op for op in operations: op_source = op.get("source_feature", {}) op_identity = op_source.get("identity") if isinstance(op_source.get("identity"), dict) else {} if source_stable_id and ( op_source.get("stable_id") == source_stable_id or op_identity.get("stable_id") == source_stable_id ): return op if source_persistent_reference and ( op_source.get("persistent_reference") == source_persistent_reference or op_identity.get("persistent_reference") == source_persistent_reference ): return op for op in operations: if source_name and op.get("name") == source_name: return op return None def _find_source_operation_for_pattern( operations: list[Dict[str, Any]], source_features: list[Dict[str, Any]] ) -> Optional[Dict[str, Any]]: for source_feature in source_features: source_op = _find_operation_for_source_feature(operations, source_feature) if source_op: return source_op return None def _linear_pattern_offsets(op: Dict[str, Any]) -> list[tuple[float, float, float]]: params = op.get("parameters", {}) raw = op.get("raw_parameters", {}) explicit_offsets = raw.get("explicit_offsets_mm") if isinstance(explicit_offsets, list) and explicit_offsets: return [ (float(offset[0]), float(offset[1]), float(offset[2])) for offset in explicit_offsets if isinstance(offset, list) and len(offset) >= 3 ] d1_count = int(raw.get("d1_total_instances") or params.get("total_instances") or 1) d2_count = int(raw.get("d2_total_instances") or 1) d1_spacing = float(raw.get("d1_spacing_mm") or params.get("spacing_mm") or 0) d2_spacing = float(raw.get("d2_spacing_mm") or 0) d1_vector = _pattern_direction_vector(raw.get("direction1") or params.get("direction1"), d1_spacing) d2_vector = _pattern_direction_vector(raw.get("direction2") or params.get("direction2"), d2_spacing) offsets = [] for i in range(d1_count): for j in range(d2_count): if i == 0 and j == 0: continue offsets.append(tuple(d1_vector[k] * i + d2_vector[k] * j for k in range(3))) return offsets def _pattern_direction_vector(direction: Optional[Dict[str, Any]], spacing: float) -> tuple[float, float, float]: if not direction or not spacing: return (0.0, 0.0, 0.0) direct_vector = direction.get("vector") if isinstance(direct_vector, list) and len(direct_vector) >= 3: vector = tuple(float(direct_vector[i]) for i in range(3)) length = math.sqrt(sum(component * component for component in vector)) if length <= 0: return (0.0, 0.0, 0.0) return tuple(component / length * spacing for component in vector) start = direction.get("start", {}).get("mm") end = direction.get("end", {}).get("mm") if not start or not end: return (0.0, 0.0, 0.0) vector = tuple(float(end[i]) - float(start[i]) for i in range(3)) length = math.sqrt(sum(component * component for component in vector)) if length <= 0: return (0.0, 0.0, 0.0) return tuple(component / length * spacing for component in vector) def _translated_operation(op: Dict[str, Any], offset: tuple[float, float, float]) -> Dict[str, Any]: copied = deepcopy(op) params = copied.get("parameters") or {} axis_reference = params.get("axis_reference") if isinstance(axis_reference, dict) and isinstance(axis_reference.get("origin_mm"), list): origin = list(axis_reference.get("origin_mm") or [0, 0, 0]) origin = (origin + [0, 0, 0])[:3] axis_reference["origin_mm"] = [float(origin[i]) + float(offset[i]) for i in range(3)] if copied.get("type") == "hole": positions = params.get("positions") or [] local_offset = _model_offset_to_host_local(offset, params.get("host_face") or {}) for position in positions: if position.get("mm"): point = list(position.get("mm") or [0, 0, 0]) point = (point + [0, 0, 0])[:3] position["mm"] = [ float(point[0]) + local_offset[0], float(point[1]) + local_offset[1], float(point[2]) + local_offset[2], ] if position.get("m"): position["m"] = [value / 1000 for value in position.get("mm", [])] if any(abs(float(offset[i])) > 1e-9 for i in range(3)): owned_faces = copied.get("source_owned_faces") or [] if owned_faces: copied["source_owned_faces"] = _translate_owned_faces(owned_faces, offset) return copied def _translate_owned_faces( faces: list[Dict[str, Any]], offset: tuple[float, float, float], ) -> list[Dict[str, Any]]: translated = [] shift_mm = (float(offset[0]), float(offset[1]), float(offset[2])) shift_m = (shift_mm[0] / 1000.0, shift_mm[1] / 1000.0, shift_mm[2] / 1000.0) for face in faces: if not isinstance(face, dict): continue copied = deepcopy(face) box = copied.get("box_m") if isinstance(box, list) and len(box) >= 6: copied["box_m"] = [ float(box[0]) + shift_m[0], float(box[1]) + shift_m[1], float(box[2]) + shift_m[2], float(box[3]) + shift_m[0], float(box[4]) + shift_m[1], float(box[5]) + shift_m[2], ] surface = copied.get("surface") if isinstance(surface, dict): for key in ("cylinder_params", "cone_params"): params = surface.get(key) if isinstance(params, list) and len(params) >= 3: updated = list(params) updated[0] = float(updated[0]) + shift_m[0] updated[1] = float(updated[1]) + shift_m[1] updated[2] = float(updated[2]) + shift_m[2] surface[key] = updated translated.append(copied) return translated def _model_offset_to_host_local( offset: tuple[float, float, float], host_face: Dict[str, Any], ) -> tuple[float, float, float]: frame = host_face.get("frame") if isinstance(host_face, dict) else {} if not isinstance(frame, dict): return offset x_dir = frame.get("x_dir") y_dir = frame.get("y_dir") if not ( isinstance(x_dir, list) and len(x_dir) >= 3 and isinstance(y_dir, list) and len(y_dir) >= 3 ): return offset local_x = sum(float(offset[i]) * float(x_dir[i]) for i in range(3)) local_y = sum(float(offset[i]) * float(y_dir[i]) for i in range(3)) return (local_x, local_y, 0.0) def _translated_sketch( sketch: Dict[str, Any], offset: tuple[float, float, float], sketch_id: str ) -> Dict[str, Any]: copied = deepcopy(sketch) copied["id"] = sketch_id copied["name"] = f"{sketch.get('name', sketch_id)} pattern copy" workplane = copied.setdefault("workplane", {}) origin = list(workplane.get("origin_mm") or [0, 0, 0]) origin = (origin + [0, 0, 0])[:3] workplane["origin_mm"] = [float(origin[i]) + float(offset[i]) for i in range(3)] return copied def _translate_sketch_entities(sketch: Dict[str, Any], offset: tuple[float, float, float]) -> None: dx, dy = offset[0], offset[1] for entity in sketch.get("entities", []): for key in ("start", "end", "center"): point = entity.get(key) if isinstance(point, list) and len(point) >= 2: point[0] = float(point[0]) + dx point[1] = float(point[1]) + dy raw = entity.get("raw", {}) for key in ("start", "end", "center"): raw_point = raw.get(key) if isinstance(raw_point, dict): mm = raw_point.get("mm") if isinstance(mm, list) and len(mm) >= 2: mm[0] = float(mm[0]) + dx mm[1] = float(mm[1]) + dy raw_point["m"] = [value / 1000 for value in mm] def _hole_diameter_mm(params: Dict[str, Any]) -> float: if params.get("diameter_mm"): return float(params["diameter_mm"]) diameters = params.get("diameters_m", {}) for key in ( "hole_diameter", "thru_hole_diameter", "tap_drill_diameter", "thru_tap_drill_diameter", "thread_diameter", "diameter", ): value = diameters.get(key) if value: return float(value) * 1000 return 0 def _hole_depth_mm(params: Dict[str, Any]) -> float: if params.get("depth_mm"): return float(params["depth_mm"]) depths = params.get("depths_m", {}) for key in ( "hole_depth", "thru_hole_depth", "tap_drill_depth", "thru_tap_drill_depth", "thread_depth", "depth", ): value = depths.get(key) if value: return float(value) * 1000 return THROUGH_CUT_AMOUNT_MM def _hole_drill_angle_rad(params: Dict[str, Any]) -> float: angle = params.get("angles_rad", {}).get("drill_angle") return float(angle) if angle else 0 def _hole_countersink_angle_rad(params: Dict[str, Any]) -> float: angle = params.get("angles_rad", {}).get("countersink_angle") return float(angle) if angle else 0 def _hole_countersink_diameter_mm(params: Dict[str, Any]) -> float: diameter = params.get("countersink_diameter_mm") return float(diameter) if diameter else 0 def _hole_counterbore_diameter_mm(params: Dict[str, Any]) -> float: diameter = params.get("counterbore_diameter_mm") return float(diameter) if diameter else 0 def _hole_counterbore_depth_mm(params: Dict[str, Any]) -> float: depth = params.get("counterbore_depth_mm") return float(depth) if depth else 0 def _hole_has_drill_tip(params: Dict[str, Any]) -> bool: depths = params.get("depths_m", {}) angle = _hole_drill_angle_rad(params) if angle <= 0: return False through_depth_keys = ( "thru_hole_depth", "thru_tap_drill_depth", ) if any(depths.get(key) for key in through_depth_keys): return False if params.get("depth_mm"): return True return any(depths.get(key) for key in ("hole_depth", "tap_drill_depth", "depth")) def _hole_has_through_dimension(params: Dict[str, Any]) -> bool: names = " ".join(str(name).lower() for name in params.get("dimension_names", []) or []) return any(token in names for token in ("通孔", "through", "thru")) def _hole_dimension_value(data_block: Dict[str, Any], tokens: tuple[str, ...]) -> Optional[float]: for dim in data_block.get("dimensions", []) or []: name = str(dim.get("name") or "").lower() if all(token.lower() in name for token in tokens) and dim.get("value") not in (None, ""): return float(dim.get("value")) return None def _feature_length_dimension_mm(feature: Dict[str, Any]) -> Optional[float]: candidates: list[tuple[int, float]] = [] for dim in feature.get("dimensions") or []: if not isinstance(dim, dict): continue name = str(dim.get("name") or "") system_value = dim.get("system_value_m") if system_value not in (None, ""): length_mm = abs(float(system_value)) * 1000 elif dim.get("value") not in (None, ""): length_mm = abs(float(dim.get("value"))) else: continue if length_mm <= 1e-9 or length_mm > 500: continue priority = 0 if name.startswith("D1@") else 1 candidates.append((priority, length_mm)) if not candidates: return None candidates.sort(key=lambda item: (item[0], item[1])) return candidates[0][1] def _feature_selection_selectors( feature: Dict[str, Any], data_block: Optional[Dict[str, Any]] = None, ) -> list[Dict[str, Any]]: selectors: list[Dict[str, Any]] = [] seen: set[str] = set() sources = [] if isinstance(data_block, dict): sources.extend(data_block.get("selections") or []) sources.extend(feature.get("selections") or []) for selection in sources: if not isinstance(selection, dict) or selection.get("kind") != "selection": continue geometry = selection.get("object") if not isinstance(geometry, dict): continue kind = geometry.get("kind") if kind not in ("edge", "face"): continue identity = geometry.get("identity") if isinstance(geometry.get("identity"), dict) else {} stable_key = ( geometry.get("stable_id") or geometry.get("persistent_reference") or identity.get("stable_id") or identity.get("persistent_reference") or json.dumps(geometry, sort_keys=True, ensure_ascii=False, default=str) ) if stable_key in seen: continue seen.add(str(stable_key)) selectors.append({ "kind": kind, "geometry": geometry, "mark": selection.get("mark"), "source_feature": { "name": selection.get("feature_name"), "type_name": selection.get("feature_type_name"), }, }) if selectors: return selectors for face in feature.get("owned_faces") or []: if not isinstance(face, dict): continue surface = face.get("surface") if isinstance(face.get("surface"), dict) else {} cylinder_params = surface.get("cylinder_params") if not (surface.get("is_cylinder") and isinstance(cylinder_params, list) and len(cylinder_params) >= 7): continue radius_mm = abs(float(cylinder_params[6]) * 1000) line_params = [ float(cylinder_params[0]), float(cylinder_params[1]), float(cylinder_params[2]), float(cylinder_params[3]), float(cylinder_params[4]), float(cylinder_params[5]), ] stable_key = f"owned_cylinder:{','.join(f'{value:.9g}' for value in line_params)}:{radius_mm:.6g}" if stable_key in seen: continue seen.add(stable_key) selectors.append({ "kind": "edge", "geometry": { "kind": "edge", "curve": { "kind": "curve", "is_line": True, "line_params": line_params, }, "bbox_mm": [float(value) * 1000 for value in face.get("box_m", [])[:6]] if isinstance(face.get("box_m"), list) and len(face.get("box_m")) >= 6 else None, }, "tolerance_mm": max(0.5, radius_mm * 2.5), "source": "owned_cylindrical_face_axis", }) for face in feature.get("owned_faces") or []: if not isinstance(face, dict): continue box_m = face.get("box_m") if not (isinstance(box_m, list) and len(box_m) >= 6): continue bbox_mm = [float(value) * 1000 for value in box_m[:6]] if any(not math.isfinite(value) for value in bbox_mm): continue sizes = [abs(bbox_mm[i + 3] - bbox_mm[i]) for i in range(3)] stable_key = f"owned_face_bbox:{','.join(f'{value:.9g}' for value in bbox_mm)}" if stable_key in seen: continue seen.add(stable_key) selectors.append({ "kind": "edge", "geometry": { "kind": "edge", "bbox_mm": bbox_mm, }, "tolerance_mm": max(0.5, min(max(sizes), 10.0) * 0.35), "source": "owned_face_bbox", }) return selectors def _feature_selection_source( feature: Dict[str, Any], data_block: Optional[Dict[str, Any]] = None, ) -> str: sources = [] if isinstance(data_block, dict): sources.extend(data_block.get("selections") or []) sources.extend(feature.get("selections") or []) if any(isinstance(item, dict) and item.get("kind") == "selection" for item in sources): return "solidworks_original_selection" if feature.get("owned_faces"): return "post_feature_owned_face_inference" return "missing" def _hole_dimension_value_excluding( data_block: Dict[str, Any], tokens: tuple[str, ...], excluded: tuple[str, ...] = (), ) -> Optional[float]: for dim in data_block.get("dimensions", []) or []: name = str(dim.get("name") or "").lower() if excluded and any(token.lower() in name for token in excluded): continue if all(token.lower() in name for token in tokens) and dim.get("value") not in (None, ""): return float(dim.get("value")) return None def _hole_primary_dimension_fallback(data_block: Dict[str, Any], prefer_small: bool) -> Optional[float]: values = [] for dim in data_block.get("dimensions", []) or []: name = str(dim.get("name") or "").lower() if not any(token in name for token in ("孔", "hole", "螺", "thread")): continue if any(token in name for token in ("沉头", "锥", "counter", "csk", "导头", "angle", "角度")): continue value = dim.get("value") if value in (None, ""): continue number = abs(float(value)) if 0 < number < 200: values.append(number) if not values: return None return min(values) if prefer_small else max(values) def _hole_primary_diameter_mm(data_block: Dict[str, Any]) -> float: diameter = ( _hole_dimension_value_excluding(data_block, ("tap", "drill", "dia"), ("depth", "angle")) or _hole_dimension_value_excluding(data_block, ("tap", "drill", "diameter"), ("depth", "angle")) or _hole_dimension_value_excluding(data_block, ("螺纹孔钻头", "直径"), ("深度", "角度")) or _hole_dimension_value_excluding(data_block, ("钻头", "直径"), ("深度", "角度")) or _hole_dimension_value_excluding(data_block, ("通孔", "孔直径"), ("沉头", "锥", "counter", "csk", "角度", "深度")) or _hole_dimension_value_excluding(data_block, ("孔直径",), ("沉头", "锥", "counter", "csk", "角度", "深度")) or _hole_dimension_value_excluding(data_block, ("hole", "diameter"), ("counter", "csk", "angle", "depth")) or _hole_dimension_value_excluding(data_block, ("thread", "diameter"), ("counter", "csk", "angle", "depth")) or _hole_dimension_value_excluding(data_block, ("螺纹",), ("深度", "depth", "角度", "angle")) or _hole_primary_dimension_fallback(data_block, prefer_small=True) ) return abs(float(diameter)) if diameter else 0 def _hole_primary_depth_mm(data_block: Dict[str, Any]) -> float: depth = ( _hole_dimension_value_excluding(data_block, ("通孔", "孔深度"), ("沉头", "锥", "counter", "csk", "角度", "直径")) or _hole_dimension_value_excluding(data_block, ("孔深度",), ("沉头", "锥", "counter", "csk", "角度", "直径")) or _hole_dimension_value_excluding(data_block, ("螺纹孔钻头", "深度"), ("直径", "角度")) or _hole_dimension_value_excluding(data_block, ("通孔", "螺纹孔钻头", "深度"), ("直径", "角度")) or _hole_dimension_value_excluding(data_block, ("tap", "drill", "depth"), ("diameter", "angle")) or _hole_dimension_value_excluding(data_block, ("hole", "depth"), ("counter", "csk", "angle", "diameter")) or _hole_dimension_value_excluding(data_block, ("thread", "depth"), ("counter", "csk", "angle", "diameter")) ) if depth: return abs(float(depth)) return THROUGH_CUT_AMOUNT_MM def _hole_counterbore_dimension_mm(data_block: Dict[str, Any]) -> Optional[float]: return ( _hole_dimension_value(data_block, ("柱形沉头", "直径")) or _hole_dimension_value(data_block, ("柱形沉头孔", "直径")) or _hole_dimension_value(data_block, ("沉头孔", "直径")) or _hole_dimension_value(data_block, ("counterbore", "diameter")) or _hole_dimension_value(data_block, ("counter", "bore", "diameter")) ) def _hole_counterbore_depth_dimension_mm(data_block: Dict[str, Any]) -> Optional[float]: return ( _hole_dimension_value(data_block, ("柱形沉头", "深度")) or _hole_dimension_value(data_block, ("柱形沉头孔", "深度")) or _hole_dimension_value(data_block, ("沉头孔", "深度")) or _hole_dimension_value(data_block, ("counterbore", "depth")) or _hole_dimension_value(data_block, ("counter", "bore", "depth")) ) def _hole_angle_dimension_rad(data_block: Dict[str, Any], tokens: tuple[str, ...]) -> Optional[float]: for dim in data_block.get("dimensions", []) or []: name = str(dim.get("name") or "").lower() if all(token.lower() in name for token in tokens): if dim.get("system_value_m") not in (None, ""): return float(dim.get("system_value_m")) if dim.get("value") not in (None, ""): value = float(dim.get("value")) return value / 1000 if value > math.tau else value return None def _extract_edge_selector_points(op: Dict[str, Any]) -> list[list[tuple[float, float, float]]]: selector_points = [] for selector in op.get("selectors", []): geometry = selector.get("geometry") or {} start = geometry.get("start_vertex") or {} start_point = start.get("point_m") if isinstance(start, dict) else None end = geometry.get("end_vertex") or {} end_point = end.get("point_m") if isinstance(end, dict) else None if start_point and end_point: selector_points.append([_point_m_to_mm(start_point), _point_m_to_mm(end_point)]) return selector_points _SW_METADATA_FEATURE_TYPES = { "commentsfolder", "favoritefolder", "historyfolder", "selectionsetfolder", "sensorfolder", "docsfolder", "detailcabinet", "surfacebodyfolder", "solidbodyfolder", "envfolder", "inkmarkupfolder", "eqnfolder", "materialfolder", "configtablefolder", "ftrfolder", } def _source_feature(feature: Dict[str, Any], index: int) -> Dict[str, Any]: source = feature.get("source_feature") if isinstance(feature.get("source_feature"), dict) else {} identity = source.get("identity") if isinstance(source.get("identity"), dict) else {} return { "index": source.get("index", index), "id": feature.get("id"), "name": feature.get("name"), "type": feature.get("type"), "type_name": feature.get("type_name"), "stable_id": source.get("stable_id") or identity.get("stable_id"), "persistent_reference": source.get("persistent_reference") or identity.get("persistent_reference"), "identity": identity or None, } def _source_owned_faces(feature: Dict[str, Any]) -> list[Dict[str, Any]]: faces = feature.get("owned_faces") if not isinstance(faces, list): return [] summarized = [] for face in faces: if not isinstance(face, dict): continue surface = face.get("surface") if isinstance(face.get("surface"), dict) else {} summarized.append( { "box_m": face.get("box_m"), "area_m2": face.get("area_m2"), "surface": { "is_plane": bool(surface.get("is_plane")), "is_cylinder": bool(surface.get("is_cylinder")), "is_cone": bool(surface.get("is_cone")), "is_sphere": bool(surface.get("is_sphere")), "is_torus": bool(surface.get("is_torus")), "cylinder_params": surface.get("cylinder_params"), "cone_params": surface.get("cone_params"), "plane_params": surface.get("plane_params"), }, } ) return summarized def _convert_sw_reference(feature: Dict[str, Any], index: int) -> Dict[str, Any]: snapshot = feature.get("definition_snapshot", {}) return { "id": feature.get("id") or f"reference_{index:03d}", "name": feature.get("name"), "type": feature.get("type"), "sw_type": feature.get("type_name"), "definition": snapshot.get("values", {}), "source_feature": _source_feature(feature, index), } def _convert_sw_sketch(feature: Dict[str, Any], sketch_id: str, index: int) -> Dict[str, Any]: sketch_data = feature.get("sketch_data", {}) raw_entities = sketch_data.get("entities", []) raw_converted_entities = [_convert_sw_sketch_entity(entity) for entity in raw_entities] converted_entities = [] raw_to_converted_index: dict[int, int] = {} stable_id_to_raw_index: dict[str, int] = {} for raw_index, (raw_entity, converted_entity) in enumerate(zip(raw_entities, raw_converted_entities)): for stable_id in _selectable_stable_ids(raw_entity): stable_id_to_raw_index.setdefault(stable_id, raw_index) if converted_entity is None: continue raw_to_converted_index[raw_index] = len(converted_entities) converted_entities.append(converted_entity) loops = [] for contour in sketch_data.get("sketch_contours", []) or sketch_data.get("contours", []) or []: if not isinstance(contour, dict): continue entity_indices = contour.get("entity_indices") or contour.get("segment_indices") or [] if not entity_indices: entity_indices = _contour_entity_indices_from_segments(contour, stable_id_to_raw_index) if not entity_indices: continue normalized_indices = [ raw_to_converted_index[int(idx)] for idx in entity_indices if isinstance(idx, (int, float)) and int(idx) in raw_to_converted_index ] if not normalized_indices: continue bbox = _loop_bbox([ converted_entities[idx] for idx in normalized_indices if 0 <= idx < len(converted_entities) ]) loops.append({ "id": contour.get("contour_id"), "entity_indices": normalized_indices, "is_closed": contour.get("is_closed"), "bbox_mm": bbox or contour.get("bbox_mm"), "bbox_area_mm2": _bbox_area_2d(bbox) if bbox else contour.get("bbox_area_mm2"), "source": "solidworks_sketch_contour", }) workplane = sketch_data.get("workplane") or {} if not workplane: workplane = {"name": sketch_data.get("plane"), "origin_mm": [0, 0, 0], "normal": [0, 0, 1], "x_dir": [1, 0, 0], "y_dir": [0, 1, 0]} return { "id": sketch_id, "name": feature.get("name", sketch_id), "workplane": workplane, "host_reference": sketch_data.get("host_reference"), "entities": converted_entities, "loops": loops, "sketch_regions": sketch_data.get("sketch_regions", []), "constraints": sketch_data.get("constraints", []), "inferred_constraints": sketch_data.get("inferred_constraints", []), "dimensions": sketch_data.get("dimensions", []), "feature_dimensions": sketch_data.get("feature_dimensions", []), "source_feature": _source_feature(feature, index), } def _selectable_stable_ids(value: Any) -> list[str]: if not isinstance(value, dict): return [] candidates = [value.get("stable_id")] identity = value.get("identity") if isinstance(identity, dict): candidates.append(identity.get("stable_id")) return [str(candidate) for candidate in candidates if candidate] def _contour_entity_indices_from_segments(contour: Dict[str, Any], stable_id_to_raw_index: dict[str, int]) -> list[int]: indices: list[int] = [] seen: set[int] = set() for segment in contour.get("sketch_segments") or []: for stable_id in _selectable_stable_ids(segment): raw_index = stable_id_to_raw_index.get(stable_id) if raw_index is None or raw_index in seen: continue seen.add(raw_index) indices.append(raw_index) break return indices def _convert_sw_sketch_entity(entity: Dict[str, Any]) -> Optional[Dict[str, Any]]: entity_type = str(entity.get("canonical_entity_type") or entity.get("entity_type", "")).lower() curve = entity.get("curve") if isinstance(entity.get("curve"), dict) else {} if ( entity_type == "circle_or_arc" or curve.get("is_circle") is True or entity.get("curve_entity_type") == "circle_or_arc" ): center = entity.get("curve_center_mm") or entity.get("center_mm") radius_mm_value = entity.get("curve_radius_mm") or entity.get("radius_mm") radius_raw_value = entity.get("radius") start = entity.get("start_mm") end = entity.get("end_mm") start_2d = [float(start[0]), float(start[1])] if isinstance(start, list) and len(start) >= 2 else None end_2d = [float(end[0]), float(end[1])] if isinstance(end, list) and len(end) >= 2 else None center_2d = [float(center[0]), float(center[1])] if isinstance(center, list) and len(center) >= 2 else [0.0, 0.0] radius_mm = float(radius_mm_value) if radius_mm_value is not None else _scale_length(radius_raw_value or 0) if start_2d and end_2d and math.hypot(start_2d[0] - end_2d[0], start_2d[1] - end_2d[1]) > 1e-6: # 计算 sweep 方向 import math as _math sa = _math.degrees(_math.atan2(start_2d[1] - center_2d[1], start_2d[0] - center_2d[0])) ea = _math.degrees(_math.atan2(end_2d[1] - center_2d[1], end_2d[0] - center_2d[0])) sweep = round(ea - sa, 10) while sweep <= -180: sweep += 360 while sweep > 180: sweep -= 360 result = { "type": "arc", "center": center_2d, "start": start_2d, "end": end_2d, "radius_mm": radius_mm, "start_angle_deg": round(sa, 10), "end_angle_deg": round(ea, 10), "arc_sweep_deg": round(sweep, 10), "construction": bool(entity.get("construction")), "raw": entity, } curve_axis = entity.get("curve_axis") if isinstance(curve_axis, list) and len(curve_axis) >= 3: result["curve_axis"] = [float(v) for v in curve_axis[:3]] return result return { "type": "circle", "center": center_2d, "radius_mm": radius_mm, "construction": bool(entity.get("construction")), "raw": entity, } if "line" in entity_type: return { "type": "line", "start": _sketch_point_mm(entity, "start"), "end": _sketch_point_mm(entity, "end"), "construction": bool(entity.get("construction")), "raw": entity, } if "circle" in entity_type: return { "type": "circle", "center": _sketch_point_mm(entity, "center"), "radius_mm": _sketch_radius_mm(entity), "construction": bool(entity.get("construction")), "raw": entity, } if "arc" in entity_type: return { "type": "arc", "center": _sketch_point_mm(entity, "center"), "start": _sketch_point_mm(entity, "start"), "end": _sketch_point_mm(entity, "end"), "radius_mm": _sketch_radius_mm(entity), "start_angle_deg": _to_degrees(entity.get("start_angle", 0)), "end_angle_deg": _to_degrees(entity.get("end_angle", 360)), "construction": bool(entity.get("construction")), "raw": entity, } if entity_type == "point": point = entity.get("point_mm") or [float(entity.get("x", 0)) * 1000, float(entity.get("y", 0)) * 1000, 0] return {"type": "point", "point": point[:2], "point_mm": point, "construction": bool(entity.get("construction")), "raw": entity} return None def _sketch_point_mm(entity: Dict[str, Any], key: str) -> list[float]: point = entity.get(f"{key}_mm") if isinstance(point, list) and len(point) >= 2: return [float(point[0]), float(point[1])] return _scale_point(entity.get(key, [0, 0])) def _sketch_radius_mm(entity: Dict[str, Any]) -> float: for key in ("radius_mm", "major_radius_mm", "major_radius"): if entity.get(key) is not None: return _scale_length(entity.get(key)) if entity.get("radius") is not None: return _scale_length(entity.get("radius")) start = _sketch_point_mm(entity, "start") center = _sketch_point_mm(entity, "center") if start and center: return math.hypot(float(start[0]) - float(center[0]), float(start[1]) - float(center[1])) return 1.0 def _convert_sw_extrude(feature: Dict[str, Any], type_name: str, sketch_id: Optional[str], index: int) -> Dict[str, Any]: data_block = feature.get("extrude_data", {}) op_type = "extrude_cut" if _is_cut_feature(feature, type_name) else "extrude_add" distance = _best_extrude_depth_mm(feature, data_block) reverse_end_condition_code = data_block.get("reverse_end_condition_code") reverse_distance = abs(data_block.get("reverse_depth") or 0) both_directions = bool(data_block.get("both_directions", False)) reverse_direction = data_block.get("is_reverse") if reverse_direction is None: reverse_direction = data_block.get("definition_snapshot", {}).get("ReverseDirection") if reverse_direction is None: reverse_direction = feature.get("definition_snapshot", {}).get("values", {}).get("ReverseDirection", False) if reverse_end_condition_code in (None, 0) and data_block.get("effective_depth_source") == "feature_dimension": spans_both_sides = _extrude_owned_faces_span_sketch_plane(feature, data_block) if spans_both_sides and bool(reverse_direction): both_directions = True reverse_distance = reverse_distance or distance else: both_directions = False reverse_distance = 0 raw_depth = abs(data_block.get("depth") or data_block.get("blind_depth") or 0) uses_reverse_depth_only = ( op_type == "extrude_cut" and feature.get("type") == "ice" and raw_depth <= 1e-9 and reverse_distance > 0 ) if uses_reverse_depth_only: reverse_direction = not bool(reverse_direction) if False else bool(reverse_direction) return { "id": feature.get("id"), "name": feature.get("name"), "type": op_type, "sketch": sketch_id, "parameters": { "distance_mm": distance, "reverse": bool(reverse_direction), "reverse_direction": bool(reverse_direction), "reverse_distance_mm": reverse_distance, "both_directions": False if uses_reverse_depth_only else both_directions, "end_condition": data_block.get("end_condition"), "end_condition_code": data_block.get("end_condition_code"), "reverse_end_condition_code": reverse_end_condition_code, "flip_side_to_cut": bool(data_block.get("flip_side_to_cut", False)), "start_condition_reference": _clean_null_reference(data_block.get("start_condition_reference")), "end_condition_reference": _clean_null_reference(data_block.get("end_condition_reference")), "reverse_end_condition_reference": _clean_null_reference(data_block.get("reverse_end_condition_reference")), "draft_angle_rad": data_block.get("draft_angle_rad"), "reverse_draft_angle_rad": data_block.get("reverse_draft_angle_rad"), }, "source_feature": _source_feature(feature, index), "source_owned_faces": _source_owned_faces(feature), } def _extrude_owned_faces_span_sketch_plane(feature: Dict[str, Any], data_block: Dict[str, Any]) -> bool: sketches = data_block.get("source_sketches") or [] workplane = sketches[0].get("workplane") if sketches and isinstance(sketches[0], dict) else None if not isinstance(workplane, dict): return bool(data_block.get("both_directions")) and (data_block.get("reverse_depth") not in (None, 0)) origin = workplane.get("origin_mm") or [0, 0, 0] normal = workplane.get("normal") or [0, 0, 1] if not isinstance(origin, list) or not isinstance(normal, list) or len(origin) < 3 or len(normal) < 3: return False nx, ny, nz = (float(normal[0]), float(normal[1]), float(normal[2])) length = math.sqrt(nx * nx + ny * ny + nz * nz) or 1.0 nx, ny, nz = nx / length, ny / length, nz / length ox, oy, oz = float(origin[0]), float(origin[1]), float(origin[2]) min_distance = math.inf max_distance = -math.inf for face in feature.get("owned_faces") or []: box = face.get("box_m") if isinstance(face, dict) else None if not isinstance(box, list) or len(box) < 6: continue xs = [float(box[0]) * 1000, float(box[3]) * 1000] ys = [float(box[1]) * 1000, float(box[4]) * 1000] zs = [float(box[2]) * 1000, float(box[5]) * 1000] for x in xs: for y in ys: for z in zs: distance_to_plane = (x - ox) * nx + (y - oy) * ny + (z - oz) * nz min_distance = min(min_distance, distance_to_plane) max_distance = max(max_distance, distance_to_plane) if math.isinf(min_distance) or math.isinf(max_distance): return False tolerance = 1e-4 return min_distance < -tolerance and max_distance > tolerance def _convert_sw_revolve(feature: Dict[str, Any], type_name: str, sketch_id: Optional[str], index: int) -> Dict[str, Any]: data_block = feature.get("revolve_data", {}) op_type = "revolve_cut" if _is_cut_feature(feature, type_name) else "revolve_add" selected_axis = _axis_reference_from_feature_selections(data_block.get("selections")) owned_face_axis = _axis_reference_from_owned_faces(feature) extracted_axis = _extract_axis_reference(data_block.get("axis_reference")) axis_reference = selected_axis or owned_face_axis if not axis_reference and not _is_weak_inferred_axis(extracted_axis): axis_reference = extracted_axis return { "id": feature.get("id"), "name": feature.get("name"), "type": op_type, "sketch": sketch_id, "parameters": { "angle_deg": abs(data_block.get("angle") or 360), "angle_rad": data_block.get("angle_rad"), "reverse": data_block.get("is_reverse", False), "end_condition": data_block.get("end_condition"), "end_condition_code": data_block.get("end_condition_code"), "axis_reference": axis_reference, "axis_candidates": data_block.get("axis_candidates", []), }, "source_feature": _source_feature(feature, index), "source_owned_faces": _source_owned_faces(feature), } def _axis_reference_from_owned_faces(feature: Dict[str, Any]) -> Optional[Dict[str, Any]]: candidates: list[tuple[float, Dict[str, Any]]] = [] for face in feature.get("owned_faces") or []: if not isinstance(face, dict): continue surface = face.get("surface") if isinstance(face.get("surface"), dict) else {} params = None if surface.get("is_cylinder") and isinstance(surface.get("cylinder_params"), list): params = surface.get("cylinder_params") elif surface.get("is_cone") and isinstance(surface.get("cone_params"), list): params = surface.get("cone_params") if not isinstance(params, list) or len(params) < 6: continue direction = [float(value) for value in params[3:6]] norm = math.sqrt(sum(value * value for value in direction)) if norm <= 1e-9: continue candidates.append(( float(face.get("area_m2") or 0.0), { "origin_mm": [float(value) * 1000 for value in params[:3]], "direction": [value / norm for value in direction], "source": "owned_face_axis", }, )) if not candidates: return None candidates.sort(key=lambda item: item[0], reverse=True) return candidates[0][1] def _is_weak_inferred_axis(axis_reference: Optional[Dict[str, Any]]) -> bool: if not isinstance(axis_reference, dict): return False return str(axis_reference.get("source") or "") in {"construction_line_candidate", "construction_line"} def _convert_sw_hole(feature: Dict[str, Any], index: int) -> Dict[str, Any]: data_block = feature.get("hole_data", {}) positions = [] host_face = _host_face_from_feature_selections(data_block.get("selections")) or {} position_sketches = _hole_position_sketches(data_block.get("position_sketches", []) or []) for sketch in position_sketches: workplane = sketch.get("workplane") or {} if not host_face and workplane: host_face = _host_face_from_workplane(workplane) for point in _hole_position_points(sketch): positions.append({"mm": [float(point[0]), float(point[1]), float(point[2] if len(point) > 2 else 0)]}) diameter_mm = abs(data_block.get("diameter") or 0) or _hole_primary_diameter_mm(data_block) depth_mm = abs(data_block.get("depth") or 0) or _hole_primary_depth_mm(data_block) return { "id": feature.get("id"), "name": feature.get("name"), "type": "hole", "parameters": { "diameter_mm": diameter_mm, "depth_mm": depth_mm, "counterbore_diameter_mm": _hole_counterbore_dimension_mm(data_block), "counterbore_depth_mm": _hole_counterbore_depth_dimension_mm(data_block), "countersink_diameter_mm": _hole_dimension_value(data_block, ("锥形沉头", "直径")) or _hole_dimension_value(data_block, ("近端锥形沉头", "直径")) or _hole_dimension_value(data_block, ("锥坑", "直径")) or _hole_dimension_value(data_block, ("countersink", "diameter")) or _hole_dimension_value(data_block, ("csk", "diameter")), "angles_rad": { "countersink_angle": _hole_angle_dimension_rad(data_block, ("锥形沉头", "角度")) or _hole_angle_dimension_rad(data_block, ("近端锥形沉头", "角度")) or _hole_angle_dimension_rad(data_block, ("锥坑", "角度")) or _hole_angle_dimension_rad(data_block, ("countersink", "angle")) or _hole_angle_dimension_rad(data_block, ("csk", "angle")), "drill_angle": _hole_angle_dimension_rad(data_block, ("导头", "角度")) or _hole_angle_dimension_rad(data_block, ("drill", "angle")) or _hole_angle_dimension_rad(data_block, ("tip", "angle")), }, "positions": positions, "host_face": host_face, "hole_type": data_block.get("hole_type"), "standard": data_block.get("standard"), "size": data_block.get("size"), "dimension_names": [ str(dim.get("name") or "") for dim in data_block.get("dimensions", []) or [] if isinstance(dim, dict) ], }, "source_feature": _source_feature(feature, index), "source_owned_faces": _source_owned_faces(feature), } def _hole_position_sketches(sketches: list[Dict[str, Any]]) -> list[Dict[str, Any]]: point_only = [] for sketch in sketches: entities = sketch.get("entities") or [] if not entities: continue if _is_hole_profile_sketch(sketch): continue point_count = sum(1 for entity in entities if _is_sketch_point_entity(entity)) drawable_segment_count = sum( 1 for entity in entities if not _is_sketch_point_entity(entity) and not entity.get("construction") ) if point_count > 0 and drawable_segment_count == 0: point_only.append(sketch) return point_only or sketches[:1] def _is_hole_profile_sketch(sketch: Dict[str, Any]) -> bool: tokens = ( "孔直径", "孔深度", "沉头", "导头", "螺纹孔钻头", "tap drill", "drill", "counterbore", "countersink", "hole diameter", "hole depth", ) dimension_sources = [] dimension_sources.extend(sketch.get("dimensions") or []) dimension_sources.extend(sketch.get("feature_dimensions") or []) for dim in dimension_sources: if not isinstance(dim, dict): continue name = str(dim.get("name") or "").lower() if any(token in name for token in tokens): return True return False def _is_sketch_point_entity(entity: Dict[str, Any]) -> bool: entity_type = str(entity.get("entity_type") or entity.get("type") or "").lower() return entity_type == "point" def _hole_position_entity_flags(entity: Dict[str, Any]) -> tuple[Optional[bool], bool]: raw = entity.get("raw") if isinstance(entity.get("raw"), dict) else entity candidate = raw.get("hole_position_candidate") if candidate is None: candidate = entity.get("hole_position_candidate") if isinstance(candidate, bool): candidate_flag: Optional[bool] = candidate else: candidate_flag = None construction_reference = bool( raw.get("construction_endpoint_reference") or entity.get("construction_endpoint_reference") ) return candidate_flag, construction_reference def _construction_endpoint_degrees(sketch: Dict[str, Any]) -> dict[tuple[float, float, float], int]: degrees: dict[tuple[float, float, float], int] = {} for entity in sketch.get("entities") or []: if not entity.get("construction"): continue entity_type = str(entity.get("entity_type") or entity.get("type") or "").lower() if "line" not in entity_type: continue for key in ("start_mm", "end_mm"): endpoint = entity.get(key) if isinstance(endpoint, list) and len(endpoint) >= 2: point_key = _rounded_point_key(endpoint) degrees[point_key] = degrees.get(point_key, 0) + 1 return degrees def _hole_position_points(sketch: Dict[str, Any]) -> list[list[float]]: """Return only real Hole Wizard placement points from a position sketch. SolidWorks Hole Wizard position sketches often include construction segments whose endpoints are reference geometry, not hole centers. Older parser JSON exposes those endpoints as ordinary sketch points, so we filter them generically here instead of letting every point become a hole. """ entities = sketch.get("entities") or [] point_entities: list[tuple[list[float], Optional[bool], bool]] = [] construction_endpoints: set[tuple[float, float, float]] = set() for entity in entities: point = entity.get("point_mm") if _is_sketch_point_entity(entity) and isinstance(point, list) and len(point) >= 2: candidate_flag, construction_reference = _hole_position_entity_flags(entity) point_entities.append( ( [float(point[0]), float(point[1]), float(point[2] if len(point) > 2 else 0)], candidate_flag, construction_reference, ) ) continue if not entity.get("construction"): continue entity_type = str(entity.get("entity_type") or entity.get("type") or "").lower() if "line" not in entity_type: continue for key in ("start_mm", "end_mm"): endpoint = entity.get(key) if isinstance(endpoint, list) and len(endpoint) >= 2: construction_endpoints.add(_rounded_point_key(endpoint)) if not point_entities: return [] explicit_candidates = [ point for point, candidate_flag, _ in point_entities if candidate_flag is True ] if explicit_candidates: return _dedupe_points(explicit_candidates) endpoint_degrees = _construction_endpoint_degrees(sketch) if endpoint_degrees: filtered = [] for point, candidate_flag, construction_reference in point_entities: point_key = _rounded_point_key(point) degree = endpoint_degrees.get(point_key, 0) if candidate_flag is False and construction_reference and degree <= 1: continue if degree >= 2 or not construction_reference: filtered.append(point) filtered = _dedupe_points(filtered) non_origin_filtered = [point for point in filtered if not _is_near_origin(point)] if non_origin_filtered: return _dedupe_points(non_origin_filtered) if filtered: return filtered raw_points = _dedupe_points([point for point, _, _ in point_entities]) if not raw_points or not construction_endpoints: return raw_points legacy_filtered = [point for point in raw_points if _rounded_point_key(point) not in construction_endpoints] non_origin_raw = [point for point in raw_points if not _is_near_origin(point)] non_origin_filtered = [point for point in legacy_filtered if not _is_near_origin(point)] if non_origin_filtered: return _dedupe_points(non_origin_filtered) if non_origin_raw: return _dedupe_points(non_origin_raw) return _dedupe_points(legacy_filtered or raw_points) def _dedupe_points(points: list[list[float]]) -> list[list[float]]: result = [] seen = set() for point in points: key = _rounded_point_key(point) if key in seen: continue seen.add(key) result.append(point) return result def _is_near_origin(point: list[float], tolerance: float = 1e-6) -> bool: return math.sqrt(sum(float(component) * float(component) for component in point[:3])) <= tolerance def _rounded_point_key(point: list[Any], digits: int = 5) -> tuple[float, float, float]: z = point[2] if len(point) > 2 else 0 return (round(float(point[0]), digits), round(float(point[1]), digits), round(float(z), digits)) def _convert_sw_linear_pattern( feature: Dict[str, Any], index: int, previous_build_op: Optional[Dict[str, Any]], source_frame: Optional[Dict[str, Any]] = None, sketches: Optional[list[Dict[str, Any]]] = None, source_bbox: Optional[list[float]] = None, ) -> Dict[str, Any]: data_block = feature.get("linear_pattern_data", {}) source_features = data_block.get("source_features") or [] if not source_features and previous_build_op: source_features = [previous_build_op.get("source_feature", {})] spacing_1 = data_block.get("spacing_1") spacing_2 = data_block.get("spacing_2") direction_1 = _pattern_direction_from_plugin(data_block.get("direction_1"), axis="x", source_frame=source_frame) direction_2 = _pattern_direction_from_plugin(data_block.get("direction_2"), axis="y", source_frame=source_frame) direction_1 = _pattern_direction_from_reference(direction_1, data_block.get("direction_1_reference"), source_frame) direction_2 = _pattern_direction_from_reference(direction_2, data_block.get("direction_2_reference"), source_frame) if data_block.get("direction_1_reverse") is True: direction_1 = _reverse_pattern_direction(direction_1) if data_block.get("direction_2_reverse") is True: direction_2 = _reverse_pattern_direction(direction_2) source_op_bbox = _operation_profile_bbox(previous_build_op, sketches or []) if data_block.get("direction_1") is None: direction_1 = _choose_pattern_direction_sign( direction_1, spacing_1 or 0, int(data_block.get("pattern_count_1") or 1), source_op_bbox, source_bbox, ) if data_block.get("direction_2") is None: direction_2 = _choose_pattern_direction_sign( direction_2, spacing_2 or 0, int(data_block.get("pattern_count_2") or 1), source_op_bbox, source_bbox, ) explicit_offsets = _owned_face_pattern_offsets(previous_build_op, feature) return { "id": feature.get("id"), "name": feature.get("name"), "type": "linear_pattern", "parameters": { "source_features": source_features, "total_instances": data_block.get("pattern_count_1") or 1, "spacing_mm": spacing_1 or 0, "direction1": direction_1, "direction2": direction_2, }, "raw_parameters": { "d1_total_instances": data_block.get("pattern_count_1") or 1, "d2_total_instances": data_block.get("pattern_count_2") or 1, "d1_spacing_mm": spacing_1 or 0, "d2_spacing_mm": spacing_2 or 0, "direction1": direction_1, "direction2": direction_2, "explicit_offsets_mm": explicit_offsets, }, "source_feature": _source_feature(feature, index), "source_owned_faces": _source_owned_faces(feature), } def _owned_face_pattern_offsets( source_op: Optional[Dict[str, Any]], pattern_feature: Dict[str, Any], ) -> list[list[float]]: if not source_op: return [] source_faces = _owned_face_signatures(source_op.get("source_owned_faces") or []) pattern_faces = _owned_face_signatures(_source_owned_faces(pattern_feature)) if not source_faces or not pattern_faces: return [] votes: Dict[tuple[float, float, float], int] = {} for pattern_face in pattern_faces: for source_face in source_faces: if pattern_face["kind"] != source_face["kind"]: continue if not _similar_bbox_size(pattern_face["size"], source_face["size"]): continue offset = tuple( round(pattern_face["center"][axis] - source_face["center"][axis], 3) for axis in range(3) ) if math.sqrt(sum(component * component for component in offset)) < 1e-6: continue votes[offset] = votes.get(offset, 0) + 1 if not votes: return [] threshold = max(1, min(2, len(source_faces))) offsets = [offset for offset, count in votes.items() if count >= threshold] offsets.sort(key=lambda offset: (offset[0] * offset[0] + offset[1] * offset[1] + offset[2] * offset[2], offset)) return [[float(value) for value in offset] for offset in offsets] def _owned_face_signatures(faces: list[Dict[str, Any]]) -> list[Dict[str, Any]]: signatures = [] for face in faces: if not isinstance(face, dict): continue box = face.get("box_m") if not isinstance(box, list) or len(box) < 6: continue box_mm = [float(value) * 1000 for value in box[:6]] surface = face.get("surface") if isinstance(face.get("surface"), dict) else {} kind = "other" if surface.get("is_cylinder"): kind = "cylinder" elif surface.get("is_cone"): kind = "cone" elif surface.get("is_plane"): kind = "plane" signatures.append( { "kind": kind, "center": [(box_mm[i] + box_mm[i + 3]) / 2 for i in range(3)], "size": [abs(box_mm[i + 3] - box_mm[i]) for i in range(3)], } ) return signatures def _similar_bbox_size(a: list[float], b: list[float], tolerance: float = 0.05) -> bool: return all(abs(float(a[i]) - float(b[i])) <= tolerance for i in range(3)) def _source_pattern_frame( previous_build_op: Optional[Dict[str, Any]], sketches: list[Dict[str, Any]], ) -> Optional[Dict[str, Any]]: if not previous_build_op: return None params = previous_build_op.get("parameters") or {} host_frame = ((params.get("host_face") or {}).get("frame") or {}) if host_frame.get("x_dir") and host_frame.get("y_dir"): return host_frame sketch_id = previous_build_op.get("sketch") for sketch in sketches: if sketch.get("id") == sketch_id: workplane = sketch.get("workplane") or {} if workplane.get("x_dir") and workplane.get("y_dir"): return workplane return None def _source_bbox_from_plugin_json(data: Dict[str, Any]) -> Optional[list[float]]: bbox = (data.get("validation_hints") or {}).get("part_box_m") if isinstance(bbox, list) and len(bbox) >= 6: return [float(v) * 1000 for v in bbox[:6]] return None def _operation_profile_bbox( op: Optional[Dict[str, Any]], sketches: list[Dict[str, Any]], ) -> Optional[list[float]]: if not op: return None if op.get("type") == "hole": host_face = (op.get("parameters") or {}).get("host_face") or {} positions = [ _hole_position_to_model(pos.get("mm"), host_face) for pos in (op.get("parameters") or {}).get("positions", []) if isinstance(pos.get("mm"), list) and len(pos.get("mm")) >= 3 ] if positions: return _points_bbox(positions) sketch_id = op.get("sketch") sketch = next((item for item in sketches if item.get("id") == sketch_id), None) if not sketch: return None points = [] workplane = sketch.get("workplane") or {} origin = workplane.get("origin_mm") or [0, 0, 0] x_dir = workplane.get("x_dir") or [1, 0, 0] y_dir = workplane.get("y_dir") or [0, 1, 0] for entity in sketch.get("entities", []) or []: if entity.get("type") == "circle": center = entity.get("center") or [0, 0] radius = float(entity.get("radius_mm") or 0) for dx, dy in ((-radius, -radius), (-radius, radius), (radius, -radius), (radius, radius)): points.append(_sketch_point_to_model_bbox(origin, x_dir, y_dir, [float(center[0]) + dx, float(center[1]) + dy])) for key in ("start", "end", "center", "point"): point = entity.get(key) if isinstance(point, list) and len(point) >= 2: points.append(_sketch_point_to_model_bbox(origin, x_dir, y_dir, point)) return _points_bbox(points) def _sketch_point_to_model_bbox(origin: list[Any], x_dir: list[Any], y_dir: list[Any], point: list[Any]) -> list[float]: return [ float(origin[i]) + float(x_dir[i]) * float(point[0]) + float(y_dir[i]) * float(point[1]) for i in range(3) ] def _points_bbox(points: list[list[float]]) -> Optional[list[float]]: if not points: return None return [ min(point[0] for point in points), min(point[1] for point in points), min(point[2] for point in points), max(point[0] for point in points), max(point[1] for point in points), max(point[2] for point in points), ] def _hole_position_to_model(point: list[Any], host_face: Dict[str, Any]) -> list[float]: frame = host_face.get("frame") if isinstance(host_face, dict) else {} if not isinstance(frame, dict): return [float(v) for v in (point + [0, 0, 0])[:3]] origin = frame.get("origin_mm") or [0, 0, 0] x_dir = frame.get("x_dir") or [1, 0, 0] y_dir = frame.get("y_dir") or [0, 1, 0] values = [float(v) for v in (point + [0, 0, 0])[:3]] return [ float(origin[i]) + float(x_dir[i]) * values[0] + float(y_dir[i]) * values[1] for i in range(3) ] def _choose_pattern_direction_sign( direction: Dict[str, Any], spacing: float, count: int, source_op_bbox: Optional[list[float]], source_bbox: Optional[list[float]], ) -> Dict[str, Any]: vector = direction.get("vector") if ( not isinstance(vector, list) or len(vector) < 3 or not spacing or count <= 1 or not source_op_bbox or not source_bbox ): return direction unit = _unit3(vector) distance = float(spacing) * (count - 1) positive = [component * distance for component in unit] negative = [-component * distance for component in unit] positive_score = _bbox_overflow_score(_translated_bbox(source_op_bbox, positive), source_bbox) negative_score = _bbox_overflow_score(_translated_bbox(source_op_bbox, negative), source_bbox) if abs(positive_score - negative_score) <= 1e-9: positive_score += _bbox_center_distance_score(_translated_bbox(source_op_bbox, positive), source_bbox) negative_score += _bbox_center_distance_score(_translated_bbox(source_op_bbox, negative), source_bbox) copied = dict(direction) if negative_score + 1e-9 < positive_score: copied["vector"] = [-component for component in unit] copied["source"] = f"{direction.get('source', 'missing_direction')}_sign_from_source_bbox" return copied copied["vector"] = unit if positive_score + 1e-9 < negative_score: copied["source"] = f"{direction.get('source', 'missing_direction')}_sign_from_source_bbox" return copied def _unit3(vector: list[Any]) -> list[float]: raw = [float(vector[i]) for i in range(3)] length = math.sqrt(sum(v * v for v in raw)) if length <= 0: return [0.0, 0.0, 0.0] return [v / length for v in raw] def _translated_bbox(bbox: list[float], offset: list[float]) -> list[float]: return [ bbox[0] + offset[0], bbox[1] + offset[1], bbox[2] + offset[2], bbox[3] + offset[0], bbox[4] + offset[1], bbox[5] + offset[2], ] def _bbox_overflow_score(candidate: list[float], source: list[float]) -> float: score = 0.0 for axis in range(3): score += max(source[axis] - candidate[axis], 0) score += max(candidate[axis + 3] - source[axis + 3], 0) return score def _bbox_center_distance_score(candidate: list[float], source: list[float]) -> float: score = 0.0 for axis in range(3): source_center = (source[axis] + source[axis + 3]) / 2 candidate_center = (candidate[axis] + candidate[axis + 3]) / 2 axis_size = max(source[axis + 3] - source[axis], 1.0) score += abs(candidate_center - source_center) / axis_size return score def _is_cut_feature(feature: Dict[str, Any], type_name: str) -> bool: text = f"{type_name} {feature.get('name', '')}".lower() return "cut" in text or "切除" in text or "revcut" in text def _best_extrude_depth_mm(feature: Dict[str, Any], data_block: Dict[str, Any]) -> float: for key in ("depth", "blind_depth"): value = data_block.get(key) if value: return abs(float(value)) owned_face_depth = _extrude_depth_from_owned_faces(feature, data_block) effective_depth = abs(float(data_block.get("effective_depth") or 0)) if ( owned_face_depth and _is_cut_feature(feature, str(feature.get("type_name") or feature.get("type") or "")) and data_block.get("effective_depth_source") == "feature_dimension" and not data_block.get("depth") and not data_block.get("blind_depth") and not data_block.get("reverse_depth") and effective_depth > owned_face_depth * 2 ): return owned_face_depth owner_name = feature.get("name") for dim in data_block.get("dimensions", []) or []: name = dim.get("name") or "" if owner_name and f"@{owner_name}@" in name and dim.get("value") not in (None, 0): return abs(float(dim.get("value"))) for dim in data_block.get("dimensions", []) or []: if dim.get("owner") == owner_name and dim.get("value") not in (None, 0): return abs(float(dim.get("value"))) if data_block.get("reverse_depth") not in (None, 0): return abs(float(data_block.get("reverse_depth"))) if data_block.get("effective_depth") not in (None, 0): return abs(float(data_block.get("effective_depth"))) return 0.0 def _extrude_depth_from_owned_faces(feature: Dict[str, Any], data_block: Dict[str, Any]) -> Optional[float]: sketches = data_block.get("source_sketches") or [] workplane = sketches[0].get("workplane") if sketches and isinstance(sketches[0], dict) else None if not isinstance(workplane, dict): return None normal = workplane.get("normal") or [0, 0, 1] if not isinstance(normal, list) or len(normal) < 3: return None axis = max(range(3), key=lambda idx: abs(float(normal[idx]))) values: list[float] = [] for face in feature.get("owned_faces") or []: if not isinstance(face, dict): continue box = face.get("box_m") if isinstance(box, list) and len(box) >= 6: values.extend([float(box[axis]) * 1000, float(box[axis + 3]) * 1000]) if not values: return None extent = max(values) - min(values) return abs(extent) if extent > 1e-6 else None def _host_face_from_workplane(workplane: Dict[str, Any]) -> Dict[str, Any]: origin = workplane.get("origin_mm") or [0, 0, 0] normal = workplane.get("normal") or [0, 0, 1] x_dir = workplane.get("x_dir") or [1, 0, 0] y_dir = workplane.get("y_dir") or [0, 1, 0] return { "surface": {"plane_params": [*normal[:3], *(float(v) / 1000 for v in origin[:3])]}, "frame": {"origin_mm": origin[:3], "x_dir": x_dir[:3], "y_dir": y_dir[:3], "normal": normal[:3]}, } def _pattern_direction_from_plugin( direction: Any, axis: str, source_frame: Optional[Dict[str, Any]] = None, ) -> Dict[str, Any]: if isinstance(direction, dict): return direction if source_frame: key = "y_dir" if axis == "y" else "x_dir" vector = source_frame.get(key) if isinstance(vector, list) and len(vector) >= 3: return {"vector": vector[:3], "source": f"source_feature_frame_{key}"} if axis == "y": return {"vector": [0, 1, 0], "source": "default_y_when_plugin_direction_missing"} return {"vector": [1, 0, 0], "source": "default_x_when_plugin_direction_missing"} def _pattern_direction_from_reference( fallback: Dict[str, Any], reference: Any, source_frame: Optional[Dict[str, Any]] = None, ) -> Dict[str, Any]: axis = _extract_axis_reference(reference) if not axis: return fallback vector = axis.get("direction") if not isinstance(vector, list) or len(vector) < 3: return fallback model_vector = _sketch_vector_to_model(vector[:3], source_frame) or vector[:3] model_origin = _sketch_point_to_model(axis.get("origin_mm"), source_frame) or axis.get("origin_mm") return { "vector": _unit3(model_vector), "origin_mm": model_origin, "source": axis.get("source") or "direction_reference", } def _sketch_vector_to_model( vector: list[Any], source_frame: Optional[Dict[str, Any]], ) -> Optional[list[float]]: if not source_frame: return None x_dir = source_frame.get("x_dir") y_dir = source_frame.get("y_dir") normal = source_frame.get("normal") if not ( isinstance(x_dir, list) and len(x_dir) >= 3 and isinstance(y_dir, list) and len(y_dir) >= 3 ): return None if not (isinstance(normal, list) and len(normal) >= 3): normal = [ float(x_dir[1]) * float(y_dir[2]) - float(x_dir[2]) * float(y_dir[1]), float(x_dir[2]) * float(y_dir[0]) - float(x_dir[0]) * float(y_dir[2]), float(x_dir[0]) * float(y_dir[1]) - float(x_dir[1]) * float(y_dir[0]), ] values = [float(v) for v in (vector + [0, 0, 0])[:3]] return [ values[0] * float(x_dir[i]) + values[1] * float(y_dir[i]) + values[2] * float(normal[i]) for i in range(3) ] def _sketch_point_to_model( point: Any, source_frame: Optional[Dict[str, Any]], ) -> Optional[list[float]]: if not isinstance(point, list) or len(point) < 3 or not source_frame: return None origin = source_frame.get("origin_mm") vector = _sketch_vector_to_model(point[:3], source_frame) if not (isinstance(origin, list) and len(origin) >= 3 and vector): return None return [float(origin[i]) + vector[i] for i in range(3)] def _reverse_pattern_direction(direction: Dict[str, Any]) -> Dict[str, Any]: vector = direction.get("vector") if not isinstance(vector, list) or len(vector) < 3: return direction copied = dict(direction) copied["vector"] = [-float(vector[0]), -float(vector[1]), -float(vector[2])] copied["source"] = f"{direction.get('source', 'direction')}_reversed" return copied def _clean_null_reference(reference: Any) -> Optional[Dict[str, Any]]: if not isinstance(reference, dict): return None if reference.get("kind") == "null": return None obj = reference.get("object") if isinstance(obj, dict) and obj.get("kind") == "null": return None return reference def _extract_axis_reference(reference: Any) -> Optional[Dict[str, Any]]: if not isinstance(reference, dict): return None if reference.get("origin_mm") and reference.get("direction"): return { "origin_mm": [float(v) for v in reference.get("origin_mm", [])[:3]], "direction": [float(v) for v in reference.get("direction", [])[:3]], "source": reference.get("source") or "axis_reference", } obj = reference.get("object") if isinstance(reference.get("object"), dict) else reference if obj.get("kind") == "null": return None line_params = obj.get("line_params") if isinstance(line_params, list) and len(line_params) >= 6: return { "origin_mm": [float(v) * 1000 for v in line_params[:3]], "direction": [float(v) for v in line_params[3:6]], "source": reference.get("source") or "selection_line_params", } curve = obj.get("curve") if isinstance(obj.get("curve"), dict) else {} curve_line_params = curve.get("line_params") if isinstance(curve_line_params, list) and len(curve_line_params) >= 6: return { "origin_mm": [float(v) * 1000 for v in curve_line_params[:3]], "direction": [float(v) for v in curve_line_params[3:6]], "source": reference.get("source") or "selection_curve_line_params", } return None def _selection_objects(selections: Any) -> list[Dict[str, Any]]: objects: list[Dict[str, Any]] = [] if not isinstance(selections, list): return objects for selection in selections: if not isinstance(selection, dict): continue obj = selection.get("object") if isinstance(obj, dict) and obj.get("kind") != "null": objects.append(obj) return objects def _axis_reference_from_feature_selections(selections: Any) -> Optional[Dict[str, Any]]: for obj in _selection_objects(selections): axis = _extract_axis_reference(obj) if axis: axis["source"] = "feature_selection_axis" return axis return None def _host_face_from_feature_selections(selections: Any) -> Optional[Dict[str, Any]]: for obj in _selection_objects(selections): if obj.get("kind") != "face": continue surface = obj.get("surface") if isinstance(obj.get("surface"), dict) else {} frame = obj.get("frame") if isinstance(obj.get("frame"), dict) else {} if not frame: continue normal = frame.get("normal") or (surface.get("plane_params") or [0, 0, 1])[:3] origin = frame.get("origin_mm") if not origin: plane_params = surface.get("plane_params") if isinstance(plane_params, list) and len(plane_params) >= 6: origin = [float(v) * 1000 for v in plane_params[3:6]] if not origin: origin = [0, 0, 0] x_dir = frame.get("x_dir") or [1, 0, 0] y_dir = frame.get("y_dir") or [0, 1, 0] origin_values = list(origin) x_values = list(x_dir) y_values = list(y_dir) normal_values = list(normal) return { "surface": surface, "frame": { "origin_mm": [float(v) for v in (origin_values + [0, 0, 0])[:3]], "x_dir": [float(v) for v in (x_values + [0, 0, 0])[:3]], "y_dir": [float(v) for v in (y_values + [0, 0, 0])[:3]], "normal": [float(v) for v in (normal_values + [0, 0, 1])[:3]], }, "source": "feature_selection_face", } return None def _tuple3(values: Any) -> tuple[float, float, float]: values = list(values or [0, 0, 0]) values = (values + [0, 0, 0])[:3] return tuple(values) def _point_m_to_mm(point: Any) -> tuple[float, float, float]: values = list(point or [0, 0, 0]) values = (values + [0, 0, 0])[:3] return tuple(float(value) * 1000 for value in values) def _scale_point(point: Any) -> list[float]: values = [0 if value is None else float(value) for value in (point or [0, 0])] return [_scale_length(value) for value in values[:2]] def _scale_length(value: Any) -> float: value = 0 if value is None else float(value) return value * 1000 if abs(value) <= 10 else value def _to_degrees(value: Any) -> float: value = 0 if value is None else float(value) return value * 180 / 3.141592653589793 if abs(value) <= 6.283185307179586 else value