1472 lines
58 KiB
Python
1472 lines
58 KiB
Python
from __future__ import annotations
|
||
|
||
import math
|
||
import re
|
||
from dataclasses import dataclass
|
||
from pathlib import Path
|
||
from typing import Callable, Iterable
|
||
|
||
from OCC.Core.BRep import BRep_Tool
|
||
from OCC.Core.BRepAdaptor import BRepAdaptor_Curve, BRepAdaptor_Surface
|
||
from OCC.Core.BRepAlgoAPI import BRepAlgoAPI_Cut, BRepAlgoAPI_Fuse
|
||
from OCC.Core.BRepBndLib import brepbndlib
|
||
from OCC.Core.BRepBuilderAPI import BRepBuilderAPI_Transform
|
||
from OCC.Core.BRepCheck import BRepCheck_Analyzer
|
||
from OCC.Core.BRepClass3d import BRepClass3d_SolidClassifier
|
||
from OCC.Core.BRepGProp import brepgprop
|
||
from OCC.Core.BRepMesh import BRepMesh_IncrementalMesh
|
||
from OCC.Core.BRepPrimAPI import BRepPrimAPI_MakeCylinder, BRepPrimAPI_MakePrism
|
||
from OCC.Core.Bnd import Bnd_Box
|
||
from OCC.Core.GeomAbs import (
|
||
GeomAbs_BSplineCurve,
|
||
GeomAbs_BSplineSurface,
|
||
GeomAbs_BezierCurve,
|
||
GeomAbs_BezierSurface,
|
||
GeomAbs_Circle,
|
||
GeomAbs_Cone,
|
||
GeomAbs_Cylinder,
|
||
GeomAbs_Ellipse,
|
||
GeomAbs_Hyperbola,
|
||
GeomAbs_Line,
|
||
GeomAbs_OffsetSurface,
|
||
GeomAbs_OtherCurve,
|
||
GeomAbs_OtherSurface,
|
||
GeomAbs_Parabola,
|
||
GeomAbs_Plane,
|
||
GeomAbs_Sphere,
|
||
GeomAbs_SurfaceOfExtrusion,
|
||
GeomAbs_SurfaceOfRevolution,
|
||
GeomAbs_Torus,
|
||
)
|
||
from OCC.Core.GProp import GProp_GProps
|
||
from OCC.Core.IFSelect import IFSelect_RetDone
|
||
from OCC.Core.Interface import Interface_Static
|
||
from OCC.Core.STEPCAFControl import STEPCAFControl_Reader
|
||
from OCC.Core.STEPControl import STEPControl_AsIs, STEPControl_Reader, STEPControl_Writer
|
||
from OCC.Core.TDF import TDF_Label, TDF_LabelSequence
|
||
from OCC.Core.TDocStd import TDocStd_Document
|
||
from OCC.Core.TopAbs import (
|
||
TopAbs_EDGE,
|
||
TopAbs_EXTERNAL,
|
||
TopAbs_FACE,
|
||
TopAbs_FORWARD,
|
||
TopAbs_IN,
|
||
TopAbs_INTERNAL,
|
||
TopAbs_OUT,
|
||
TopAbs_REVERSED,
|
||
TopAbs_SOLID,
|
||
)
|
||
from OCC.Core.TopExp import TopExp_Explorer
|
||
from OCC.Core.TopLoc import TopLoc_Location
|
||
from OCC.Core.TopoDS import TopoDS_Compound, TopoDS_Shape, topods
|
||
from OCC.Core.XCAFDoc import XCAFDoc_DocumentTool
|
||
from OCC.Core.gp import gp_Ax2, gp_Dir, gp_Pnt, gp_Vec
|
||
from OCC.Extend.TopologyUtils import TopologyExplorer, discretize_edge
|
||
|
||
|
||
SURFACE_TYPES = {
|
||
GeomAbs_Plane: "plane",
|
||
GeomAbs_Cylinder: "cylinder",
|
||
GeomAbs_Cone: "cone",
|
||
GeomAbs_Sphere: "sphere",
|
||
GeomAbs_Torus: "torus",
|
||
GeomAbs_BezierSurface: "bezier surface",
|
||
GeomAbs_BSplineSurface: "b-spline surface",
|
||
GeomAbs_SurfaceOfRevolution: "surface of revolution",
|
||
GeomAbs_SurfaceOfExtrusion: "surface of extrusion",
|
||
GeomAbs_OffsetSurface: "offset surface",
|
||
GeomAbs_OtherSurface: "other surface",
|
||
}
|
||
|
||
CURVE_TYPES = {
|
||
GeomAbs_Line: "line",
|
||
GeomAbs_Circle: "circle",
|
||
GeomAbs_Ellipse: "ellipse",
|
||
GeomAbs_Hyperbola: "hyperbola",
|
||
GeomAbs_Parabola: "parabola",
|
||
GeomAbs_BezierCurve: "bezier curve",
|
||
GeomAbs_BSplineCurve: "b-spline curve",
|
||
GeomAbs_OtherCurve: "other curve",
|
||
}
|
||
|
||
ORIENTATION_TYPES = {
|
||
TopAbs_FORWARD: "forward",
|
||
TopAbs_REVERSED: "reversed",
|
||
TopAbs_INTERNAL: "internal",
|
||
TopAbs_EXTERNAL: "external",
|
||
}
|
||
|
||
|
||
@dataclass
|
||
class PartNode:
|
||
id: int
|
||
name: str
|
||
kind: str
|
||
shape: TopoDS_Shape
|
||
parent_id: int | None = None
|
||
depth: int = 0
|
||
path: str = ""
|
||
|
||
|
||
@dataclass
|
||
class TopologyStats:
|
||
parts: int
|
||
solids: int
|
||
faces: int
|
||
edges: int
|
||
vertices: int
|
||
|
||
|
||
class StepModel:
|
||
def __init__(self, filename: Path, parts: list[PartNode], shape: TopoDS_Shape):
|
||
self.filename = filename
|
||
self.parts = parts
|
||
self.shape = shape
|
||
self.faces: list[TopoDS_Shape] = []
|
||
self.face_part_ids: list[int] = []
|
||
self.face_solid_ids: list[int] = []
|
||
self.edges: list[TopoDS_Shape] = []
|
||
self.edge_part_ids: list[int] = []
|
||
self.solids: list[tuple[int, TopoDS_Shape]] = []
|
||
self.refresh_topology()
|
||
|
||
@classmethod
|
||
def load(cls, filename: str | Path) -> "StepModel":
|
||
path = Path(filename)
|
||
if not path.exists():
|
||
raise FileNotFoundError(path)
|
||
|
||
product_names = _parse_product_names(path)
|
||
parts, whole_shape = _load_with_xcaf(path, product_names)
|
||
if not parts or whole_shape.IsNull():
|
||
whole_shape = _load_plain_step(path)
|
||
fallback_name = product_names[0] if product_names else path.stem
|
||
parts = [PartNode(1, fallback_name, "part", whole_shape, path=fallback_name)]
|
||
return cls(path, parts, whole_shape)
|
||
|
||
def display_parts(self) -> list[PartNode]:
|
||
leaf_parts = [p for p in self.parts if p.kind == "part" and not p.shape.IsNull()]
|
||
if leaf_parts:
|
||
return leaf_parts
|
||
return [p for p in self.parts if not p.shape.IsNull()]
|
||
|
||
def stats(self) -> TopologyStats:
|
||
topo = TopologyExplorer(self.shape, ignore_orientation=True)
|
||
return TopologyStats(
|
||
parts=len(self.display_parts()),
|
||
solids=len(list(topo.solids())),
|
||
faces=len(list(topo.faces())),
|
||
edges=len(list(topo.edges())),
|
||
vertices=len(list(topo.vertices())),
|
||
)
|
||
|
||
def geometry_stats(self) -> dict[str, object]:
|
||
surface_props = GProp_GProps()
|
||
brepgprop.SurfaceProperties(self.shape, surface_props)
|
||
info: dict[str, object] = {
|
||
"surface_area": surface_props.Mass(),
|
||
"surface_center": _point_tuple(surface_props.CentreOfMass()),
|
||
}
|
||
info.update(_shape_bounds_info(self.shape))
|
||
info.update(_shape_volume_info(self.shape))
|
||
return info
|
||
|
||
def refresh_topology(self) -> None:
|
||
self.shape = _compound_from_shapes([p.shape for p in self.display_parts()])
|
||
self.faces.clear()
|
||
self.face_part_ids.clear()
|
||
self.face_solid_ids.clear()
|
||
self.edges.clear()
|
||
self.edge_part_ids.clear()
|
||
self.solids.clear()
|
||
|
||
solid_id = 0
|
||
for part in self.display_parts():
|
||
part_solids = _explore(part.shape, TopAbs_SOLID)
|
||
if part_solids:
|
||
for solid in part_solids:
|
||
self.solids.append((part.id, solid))
|
||
for face in _explore(solid, TopAbs_FACE):
|
||
self.faces.append(face)
|
||
self.face_part_ids.append(part.id)
|
||
self.face_solid_ids.append(solid_id)
|
||
solid_id += 1
|
||
else:
|
||
for face in _explore(part.shape, TopAbs_FACE):
|
||
self.faces.append(face)
|
||
self.face_part_ids.append(part.id)
|
||
self.face_solid_ids.append(-1)
|
||
|
||
for edge in TopologyExplorer(part.shape, ignore_orientation=True).edges():
|
||
self.edges.append(edge)
|
||
self.edge_part_ids.append(part.id)
|
||
|
||
def part_by_id(self, part_id: int) -> PartNode | None:
|
||
return next((p for p in self.parts if p.id == part_id), None)
|
||
|
||
def snapshot(self) -> dict[int, TopoDS_Shape]:
|
||
return {part.id: part.shape for part in self.parts}
|
||
|
||
def restore_snapshot(self, snapshot: dict[int, TopoDS_Shape]) -> None:
|
||
for part in self.parts:
|
||
if part.id in snapshot:
|
||
part.shape = snapshot[part.id]
|
||
self.refresh_topology()
|
||
|
||
def face_info(self, face_id: int) -> dict[str, object]:
|
||
face = self.faces[face_id]
|
||
props = GProp_GProps()
|
||
brepgprop.SurfaceProperties(face, props)
|
||
|
||
surf = BRepAdaptor_Surface(face)
|
||
surface_type = surf.GetType()
|
||
boundary_edges = len(list(TopologyExplorer(face, ignore_orientation=True).edges()))
|
||
info: dict[str, object] = {
|
||
"kind": "face",
|
||
"face_id": face_id,
|
||
"part_id": self.face_part_ids[face_id],
|
||
"solid_id": self.face_solid_ids[face_id],
|
||
"orientation": _orientation_name(face.Orientation()),
|
||
"surface": SURFACE_TYPES.get(surface_type, f"type {surface_type}"),
|
||
"area": props.Mass(),
|
||
"area_center": _point_tuple(props.CentreOfMass()),
|
||
"u_range": (surf.FirstUParameter(), surf.LastUParameter()),
|
||
"v_range": (surf.FirstVParameter(), surf.LastVParameter()),
|
||
"boundary_edges": boundary_edges,
|
||
}
|
||
info.update(_shape_bounds_info(face))
|
||
if surface_type == GeomAbs_Plane:
|
||
plane = surf.Plane()
|
||
direction = plane.Axis().Direction()
|
||
push_pull_direction = self._plane_push_pull_direction(face_id, surf)
|
||
info["plane_origin"] = _point_tuple(plane.Location())
|
||
info["normal"] = _dir_tuple(direction)
|
||
info["oriented_normal"] = _oriented_dir_tuple(direction, face)
|
||
info["push_pull_outward_direction"] = push_pull_direction["outward_direction"]
|
||
info["push_pull_inward_direction"] = push_pull_direction["inward_direction"]
|
||
info["push_pull_plus_side"] = push_pull_direction["plus_side_state"]
|
||
info["push_pull_minus_side"] = push_pull_direction["minus_side_state"]
|
||
info["push_pull_confidence"] = push_pull_direction["confidence"]
|
||
info["push_pull_note"] = push_pull_direction["note"]
|
||
elif surface_type == GeomAbs_Cylinder:
|
||
cyl = surf.Cylinder()
|
||
axis = cyl.Axis()
|
||
radius = cyl.Radius()
|
||
u_span = abs(surf.LastUParameter() - surf.FirstUParameter())
|
||
swept_area = max(radius * max(u_span, 1e-9), 1e-9)
|
||
classification = self._classify_cylindrical_face(face_id, surf, detailed=True)
|
||
info["radius"] = cyl.Radius()
|
||
info["diameter"] = cyl.Radius() * 2.0
|
||
info["axis_point"] = _point_tuple(axis.Location())
|
||
info["axis"] = _dir_tuple(axis.Direction())
|
||
info["angular_span"] = u_span
|
||
info["is_full_cylinder"] = u_span >= math.tau * 0.98
|
||
info["height_estimate"] = props.Mass() / swept_area
|
||
info["feature_guess"] = classification["feature_guess"]
|
||
info["confidence"] = classification["confidence"]
|
||
info["material_toward_axis"] = classification["toward_axis"]
|
||
info["material_away_axis"] = classification["away_axis"]
|
||
info["material_vote_summary"] = classification["vote_summary"]
|
||
info["material_sample_count"] = classification["sample_count"]
|
||
info["note"] = classification["note"]
|
||
info.update(self._cylinder_end_opening_info(face_id, surf))
|
||
info.update(_cylinder_resize_readiness(info))
|
||
elif surface_type == GeomAbs_Cone:
|
||
cone = surf.Cone()
|
||
info["axis_point"] = _point_tuple(cone.Location())
|
||
info["axis"] = _dir_tuple(cone.Axis().Direction())
|
||
info["reference_radius"] = cone.RefRadius()
|
||
info["semi_angle"] = cone.SemiAngle()
|
||
elif surface_type == GeomAbs_Sphere:
|
||
sphere = surf.Sphere()
|
||
info["center"] = _point_tuple(sphere.Location())
|
||
info["radius"] = sphere.Radius()
|
||
info["diameter"] = sphere.Radius() * 2.0
|
||
elif surface_type == GeomAbs_Torus:
|
||
torus = surf.Torus()
|
||
info["center"] = _point_tuple(torus.Location())
|
||
info["axis"] = _dir_tuple(torus.Axis().Direction())
|
||
info["major_radius"] = torus.MajorRadius()
|
||
info["minor_radius"] = torus.MinorRadius()
|
||
return info
|
||
|
||
def edge_info(self, edge_id: int) -> dict[str, object]:
|
||
edge = self.edges[edge_id]
|
||
props = GProp_GProps()
|
||
brepgprop.LinearProperties(edge, props)
|
||
|
||
curve = BRepAdaptor_Curve(edge)
|
||
curve_type = curve.GetType()
|
||
info: dict[str, object] = {
|
||
"kind": "edge",
|
||
"edge_id": edge_id,
|
||
"part_id": self.edge_part_ids[edge_id],
|
||
"orientation": _orientation_name(edge.Orientation()),
|
||
"curve": CURVE_TYPES.get(curve_type, f"type {curve_type}"),
|
||
"length": props.Mass(),
|
||
"length_center": _point_tuple(props.CentreOfMass()),
|
||
"first_parameter": curve.FirstParameter(),
|
||
"last_parameter": curve.LastParameter(),
|
||
"start_point": _point_tuple(curve.Value(curve.FirstParameter())),
|
||
"end_point": _point_tuple(curve.Value(curve.LastParameter())),
|
||
}
|
||
info.update(_shape_bounds_info(edge))
|
||
if curve_type == GeomAbs_Line:
|
||
line = curve.Line()
|
||
info["line_origin"] = _point_tuple(line.Location())
|
||
info["direction"] = _dir_tuple(line.Direction())
|
||
if curve_type == GeomAbs_Circle:
|
||
circle = curve.Circle()
|
||
info["center"] = _point_tuple(circle.Location())
|
||
info["axis"] = _dir_tuple(circle.Axis().Direction())
|
||
info["radius"] = circle.Radius()
|
||
info["diameter"] = circle.Radius() * 2.0
|
||
return info
|
||
|
||
def solid_info(self, solid_id: int) -> dict[str, object]:
|
||
if solid_id < 0 or solid_id >= len(self.solids):
|
||
raise ValueError(f"Unknown solid id {solid_id}")
|
||
part_id, solid = self.solids[solid_id]
|
||
topo = TopologyExplorer(solid, ignore_orientation=True)
|
||
surface_props = GProp_GProps()
|
||
brepgprop.SurfaceProperties(solid, surface_props)
|
||
info: dict[str, object] = {
|
||
"kind": "solid",
|
||
"solid_id": solid_id,
|
||
"part_id": part_id,
|
||
"faces": len(list(topo.faces())),
|
||
"edges": len(list(topo.edges())),
|
||
"vertices": len(list(topo.vertices())),
|
||
"surface_area": surface_props.Mass(),
|
||
"surface_center": _point_tuple(surface_props.CentreOfMass()),
|
||
}
|
||
info.update(_shape_bounds_info(solid))
|
||
info.update(_shape_volume_info(solid))
|
||
return info
|
||
|
||
def part_info(self, part_id: int) -> dict[str, object]:
|
||
part = self.part_by_id(part_id)
|
||
if part is None:
|
||
raise ValueError(f"Unknown part id {part_id}")
|
||
topo = TopologyExplorer(part.shape, ignore_orientation=True)
|
||
info: dict[str, object] = {
|
||
"kind": part.kind,
|
||
"part_id": part.id,
|
||
"name": part.name,
|
||
"path": part.path,
|
||
"parent_id": part.parent_id if part.parent_id is not None else "",
|
||
"depth": part.depth,
|
||
"solids": len(list(topo.solids())),
|
||
"faces": len(list(topo.faces())),
|
||
"edges": len(list(topo.edges())),
|
||
"vertices": len(list(topo.vertices())),
|
||
}
|
||
info.update(_shape_bounds_info(part.shape))
|
||
info.update(_shape_volume_info(part.shape))
|
||
return info
|
||
|
||
def editable_feature_candidates(
|
||
self,
|
||
limit: int = 160,
|
||
detailed: bool = False,
|
||
progress_callback: Callable[[], None] | None = None,
|
||
) -> list[dict[str, object]]:
|
||
per_type_limit = max(1, limit // 2)
|
||
candidates: list[dict[str, object]] = []
|
||
|
||
for item in self.cylindrical_feature_candidates(
|
||
limit=per_type_limit,
|
||
include_end_info=False,
|
||
progress_callback=progress_callback,
|
||
):
|
||
candidates.append(
|
||
{
|
||
"operation_key": "resize_cylinder",
|
||
"operation": "调整圆柱孔径",
|
||
"face_id": item["face_id"],
|
||
"part_id": item["part_id"],
|
||
"solid_id": item["solid_id"],
|
||
"surface": "cylinder",
|
||
"feature_guess": item["feature_guess"],
|
||
"current_value": item["diameter"],
|
||
"current_value_label": "diameter",
|
||
"status": item["resize_status"],
|
||
"risk": item["resize_risk"],
|
||
"confidence": item["confidence"],
|
||
"note": item["resize_note"],
|
||
}
|
||
)
|
||
|
||
plane_count = 0
|
||
for face_id, face in enumerate(self.faces):
|
||
if progress_callback is not None and face_id % 30 == 0:
|
||
progress_callback()
|
||
if plane_count >= per_type_limit:
|
||
break
|
||
surf = BRepAdaptor_Surface(face)
|
||
if surf.GetType() != GeomAbs_Plane:
|
||
continue
|
||
props = GProp_GProps()
|
||
brepgprop.SurfaceProperties(face, props)
|
||
if detailed:
|
||
direction_info = self._plane_push_pull_direction(face_id, surf)
|
||
confidence = str(direction_info["confidence"])
|
||
risk = "low" if confidence == "high" else "medium"
|
||
status = "ready" if confidence == "high" else "caution"
|
||
note = str(direction_info["note"])
|
||
else:
|
||
confidence = "pending"
|
||
risk = "medium"
|
||
status = "caution"
|
||
note = "快速扫描：推拉方向会在选中 face 或执行编辑前再详细判断。"
|
||
candidates.append(
|
||
{
|
||
"operation_key": "push_pull_plane",
|
||
"operation": "推拉平面",
|
||
"face_id": face_id,
|
||
"part_id": self.face_part_ids[face_id],
|
||
"solid_id": self.face_solid_ids[face_id],
|
||
"surface": "plane",
|
||
"feature_guess": "planar push/pull candidate",
|
||
"current_value": props.Mass(),
|
||
"current_value_label": "area",
|
||
"status": status,
|
||
"risk": risk,
|
||
"confidence": confidence,
|
||
"note": note,
|
||
}
|
||
)
|
||
plane_count += 1
|
||
|
||
status_order = {"ready": 0, "caution": 1, "blocked": 2}
|
||
risk_order = {"low": 0, "medium": 1, "high": 2, "blocked": 3}
|
||
operation_order = {"resize_cylinder": 0, "push_pull_plane": 1}
|
||
candidates.sort(
|
||
key=lambda item: (
|
||
status_order.get(str(item["status"]), 9),
|
||
risk_order.get(str(item["risk"]), 9),
|
||
operation_order.get(str(item["operation_key"]), 9),
|
||
int(item["face_id"]),
|
||
)
|
||
)
|
||
return candidates[:limit]
|
||
|
||
def cylindrical_feature_candidates(
|
||
self,
|
||
limit: int = 100,
|
||
include_end_info: bool = False,
|
||
progress_callback: Callable[[], None] | None = None,
|
||
) -> list[dict[str, object]]:
|
||
candidates: list[dict[str, object]] = []
|
||
for face_id, face in enumerate(self.faces):
|
||
if progress_callback is not None and face_id % 30 == 0:
|
||
progress_callback()
|
||
surf = BRepAdaptor_Surface(face)
|
||
if surf.GetType() != GeomAbs_Cylinder:
|
||
continue
|
||
cyl = surf.Cylinder()
|
||
props = GProp_GProps()
|
||
brepgprop.SurfaceProperties(face, props)
|
||
radius = cyl.Radius()
|
||
u_span = abs(surf.LastUParameter() - surf.FirstUParameter())
|
||
v_span = abs(surf.LastVParameter() - surf.FirstVParameter())
|
||
swept_area = max(radius * max(u_span, 1e-9), 1e-9)
|
||
height_estimate = props.Mass() / swept_area
|
||
boundary_edges = len(list(TopologyExplorer(face, ignore_orientation=True).edges()))
|
||
classification = self._classify_cylindrical_face(face_id, surf)
|
||
candidate = {
|
||
"face_id": face_id,
|
||
"part_id": self.face_part_ids[face_id],
|
||
"solid_id": self.face_solid_ids[face_id],
|
||
"radius": radius,
|
||
"diameter": radius * 2.0,
|
||
"axis": _dir_tuple(cyl.Axis().Direction()),
|
||
"area": props.Mass(),
|
||
"angular_span": u_span,
|
||
"height_estimate": height_estimate,
|
||
"param_height": v_span,
|
||
"boundary_edges": boundary_edges,
|
||
"feature_guess": classification["feature_guess"],
|
||
"material_toward_axis": classification["toward_axis"],
|
||
"material_away_axis": classification["away_axis"],
|
||
"material_vote_summary": classification["vote_summary"],
|
||
"material_sample_count": classification["sample_count"],
|
||
"confidence": classification["confidence"],
|
||
"note": classification["note"],
|
||
}
|
||
if include_end_info:
|
||
candidate.update(self._cylinder_end_opening_info(face_id, surf))
|
||
candidate.update(_cylinder_resize_readiness(candidate))
|
||
candidates.append(candidate)
|
||
if len(candidates) >= limit:
|
||
break
|
||
return candidates
|
||
|
||
def cylindrical_resize_plan(self, face_id: int, new_diameter: float) -> dict[str, object]:
|
||
if face_id < 0 or face_id >= len(self.faces):
|
||
raise ValueError(f"Unknown face id {face_id}")
|
||
info = self.face_info(face_id)
|
||
if info.get("surface") != "cylinder" or "diameter" not in info:
|
||
return {
|
||
"status": "blocked",
|
||
"risk": "blocked",
|
||
"message": "当前选中的 face 不是圆柱面，不能执行圆柱切削。",
|
||
}
|
||
current_diameter = float(info["diameter"])
|
||
readiness = _cylinder_resize_readiness(info, new_diameter)
|
||
resize_mode = _resize_mode(current_diameter, new_diameter)
|
||
cutter_plan = self._bounded_cylinder_cutter_plan(face_id, new_diameter)
|
||
fill_plan = self._bounded_cylinder_fill_plan(face_id) if resize_mode == "shrink" else {}
|
||
return {
|
||
"status": readiness["resize_status"],
|
||
"risk": readiness["resize_risk"],
|
||
"message": readiness["resize_note"],
|
||
"warnings": readiness["resize_warnings"],
|
||
"blockers": readiness["resize_blockers"],
|
||
"face_id": face_id,
|
||
"part_id": info["part_id"],
|
||
"solid_id": info["solid_id"],
|
||
"current_diameter": current_diameter,
|
||
"target_diameter": new_diameter,
|
||
"delta_diameter": new_diameter - current_diameter,
|
||
"resize_mode": resize_mode,
|
||
"feature_guess": info.get("feature_guess"),
|
||
"confidence": info.get("confidence"),
|
||
"angular_span": info.get("angular_span"),
|
||
"height_estimate": info.get("height_estimate"),
|
||
"material_vote_summary": info.get("material_vote_summary"),
|
||
"material_sample_count": info.get("material_sample_count"),
|
||
**cutter_plan,
|
||
**fill_plan,
|
||
}
|
||
|
||
def _bounded_cylinder_cutter_plan(self, face_id: int, new_diameter: float) -> dict[str, object]:
|
||
face = self.faces[face_id]
|
||
surf = BRepAdaptor_Surface(face)
|
||
if surf.GetType() != GeomAbs_Cylinder:
|
||
return {
|
||
"cutter_strategy": "unavailable",
|
||
"cutter_note": "selected face is not cylindrical",
|
||
}
|
||
|
||
cyl = surf.Cylinder()
|
||
old_radius = cyl.Radius()
|
||
new_radius = new_diameter / 2.0
|
||
v1 = surf.FirstVParameter()
|
||
v2 = surf.LastVParameter()
|
||
v_min = min(v1, v2)
|
||
v_max = max(v1, v2)
|
||
span = max(v_max - v_min, 0.0)
|
||
end_info = self._cylinder_end_opening_info(face_id, surf)
|
||
base_margin = min(max(new_radius * 0.05, abs(new_radius - old_radius) * 0.5, 0.02), max(span * 0.05, 0.2))
|
||
closed_margin = min(base_margin, max(span * 0.005, 0.02))
|
||
start_margin = base_margin if end_info["start_end_open"] else closed_margin
|
||
end_margin = base_margin if end_info["end_end_open"] else closed_margin
|
||
start_parameter = v_min - start_margin
|
||
end_parameter = v_max + end_margin
|
||
height = max(end_parameter - start_parameter, 1e-6)
|
||
axis = cyl.Axis()
|
||
direction = axis.Direction()
|
||
axis_point = axis.Location()
|
||
start = gp_Pnt(
|
||
axis_point.X() + direction.X() * start_parameter,
|
||
axis_point.Y() + direction.Y() * start_parameter,
|
||
axis_point.Z() + direction.Z() * start_parameter,
|
||
)
|
||
return {
|
||
"cutter_strategy": "bounded-to-selected-cylinder-v-range",
|
||
"cutter_note": "有限长度切削：按选中圆柱面的 V 参数范围生成 cutter，减少贯穿整个零件的误切风险。",
|
||
"cutter_start_parameter": start_parameter,
|
||
"cutter_end_parameter": end_parameter,
|
||
"cutter_height": height,
|
||
"cutter_margin": base_margin,
|
||
"cutter_start_margin": start_margin,
|
||
"cutter_end_margin": end_margin,
|
||
"cutter_radius": new_radius,
|
||
"cutter_axis_point": _point_tuple(axis_point),
|
||
"cutter_axis_direction": _dir_tuple(direction),
|
||
"cutter_start_point": _point_tuple(start),
|
||
**end_info,
|
||
}
|
||
|
||
def _bounded_cylinder_fill_plan(self, face_id: int) -> dict[str, object]:
|
||
face = self.faces[face_id]
|
||
surf = BRepAdaptor_Surface(face)
|
||
if surf.GetType() != GeomAbs_Cylinder:
|
||
return {
|
||
"fill_strategy": "unavailable",
|
||
"fill_note": "selected face is not cylindrical",
|
||
}
|
||
|
||
cyl = surf.Cylinder()
|
||
radius = cyl.Radius()
|
||
v1 = surf.FirstVParameter()
|
||
v2 = surf.LastVParameter()
|
||
v_min = min(v1, v2)
|
||
v_max = max(v1, v2)
|
||
height = max(v_max - v_min, 1e-6)
|
||
overlap = min(max(radius * 0.001, 0.001), 0.05)
|
||
axis = cyl.Axis()
|
||
direction = axis.Direction()
|
||
axis_point = axis.Location()
|
||
start = _point_on_axis(axis_point, direction, v_min)
|
||
return {
|
||
"fill_strategy": "bounded-fill-then-recut",
|
||
"fill_note": "缩小孔径实验策略：先在原圆柱面范围内补料，再按目标直径重切。补料不向开口端外伸。",
|
||
"fill_start_parameter": v_min,
|
||
"fill_end_parameter": v_max,
|
||
"fill_height": height,
|
||
"fill_radius": radius + overlap,
|
||
"fill_radius_overlap": overlap,
|
||
"fill_start_point": _point_tuple(start),
|
||
}
|
||
|
||
def _cylinder_end_opening_info(self, face_id: int, surf: BRepAdaptor_Surface) -> dict[str, object]:
|
||
solid_id = self.face_solid_ids[face_id]
|
||
fallback = {
|
||
"cylinder_end_type": "unknown",
|
||
"hole_depth_estimate": abs(surf.LastVParameter() - surf.FirstVParameter()),
|
||
"start_end_state": "unknown",
|
||
"end_end_state": "unknown",
|
||
"start_end_open": False,
|
||
"end_end_open": False,
|
||
"open_end_count": 0,
|
||
"closed_end_count": 0,
|
||
"end_sample_offset": "",
|
||
"end_sample_note": "no owning solid was found",
|
||
}
|
||
if solid_id < 0 or solid_id >= len(self.solids):
|
||
return fallback
|
||
|
||
solid = self.solids[solid_id][1]
|
||
cyl = surf.Cylinder()
|
||
axis = cyl.Axis()
|
||
axis_point = axis.Location()
|
||
direction = axis.Direction()
|
||
v1 = surf.FirstVParameter()
|
||
v2 = surf.LastVParameter()
|
||
v_min = min(v1, v2)
|
||
v_max = max(v1, v2)
|
||
span = max(v_max - v_min, 0.0)
|
||
radius = cyl.Radius()
|
||
offset = min(max(radius * 0.08, span * 0.02, 0.05), max(span * 0.25, 0.2))
|
||
|
||
start_probe = _point_on_axis(axis_point, direction, v_min - offset)
|
||
end_probe = _point_on_axis(axis_point, direction, v_max + offset)
|
||
start_state = _solid_state(solid, start_probe)
|
||
end_state = _solid_state(solid, end_probe)
|
||
start_open = start_state == "outside"
|
||
end_open = end_state == "outside"
|
||
start_closed = start_state == "inside"
|
||
end_closed = end_state == "inside"
|
||
open_count = int(start_open) + int(end_open)
|
||
closed_count = int(start_closed) + int(end_closed)
|
||
|
||
if open_count == 2:
|
||
end_type = "through/open-ended"
|
||
note = "both axis-end probes are outside material"
|
||
elif open_count == 1 and closed_count == 1:
|
||
end_type = "blind"
|
||
note = "one axis-end probe is outside material and the other is inside material"
|
||
elif closed_count == 2:
|
||
end_type = "closed/internal"
|
||
note = "both axis-end probes are inside material"
|
||
else:
|
||
end_type = "unclear"
|
||
note = "axis-end probes did not produce a clear open/closed pattern"
|
||
|
||
return {
|
||
"cylinder_end_type": end_type,
|
||
"hole_depth_estimate": span,
|
||
"start_end_state": start_state,
|
||
"end_end_state": end_state,
|
||
"start_end_open": start_open,
|
||
"end_end_open": end_open,
|
||
"open_end_count": open_count,
|
||
"closed_end_count": closed_count,
|
||
"end_sample_offset": offset,
|
||
"end_sample_note": note,
|
||
}
|
||
|
||
def _classify_cylindrical_face(
|
||
self,
|
||
face_id: int,
|
||
surf: BRepAdaptor_Surface,
|
||
detailed: bool = False,
|
||
) -> dict[str, object]:
|
||
solid_id = self.face_solid_ids[face_id]
|
||
if solid_id < 0 or solid_id >= len(self.solids):
|
||
return {
|
||
"feature_guess": "cylindrical face",
|
||
"toward_axis": "unknown",
|
||
"away_axis": "unknown",
|
||
"vote_summary": "hole=0, boss=0, unclear=0",
|
||
"sample_count": 0,
|
||
"confidence": "low",
|
||
"note": "no owning solid was found",
|
||
}
|
||
|
||
solid = self.solids[solid_id][1]
|
||
radius = surf.Cylinder().Radius()
|
||
angular_span = abs(surf.LastUParameter() - surf.FirstUParameter())
|
||
boundary_edges = len(list(TopologyExplorer(self.faces[face_id], ignore_orientation=True).edges()))
|
||
solid_diagonal = _shape_diagonal(solid)
|
||
is_partial_cylinder = angular_span < math.tau * 0.92
|
||
is_small_radius = solid_diagonal > 0 and radius <= solid_diagonal * 0.04
|
||
samples = self._sample_cylinder_material_states(surf, solid, detailed=detailed)
|
||
sample_count = len(samples)
|
||
if sample_count == 0:
|
||
return {
|
||
"feature_guess": "cylindrical face",
|
||
"toward_axis": "unknown",
|
||
"away_axis": "unknown",
|
||
"vote_summary": "hole=0, boss=0, unclear=0",
|
||
"sample_count": 0,
|
||
"confidence": "low",
|
||
"note": "could not sample cylinder material sides",
|
||
}
|
||
|
||
toward_states = [sample["toward"] for sample in samples]
|
||
away_states = [sample["away"] for sample in samples]
|
||
hole_votes = sum(1 for sample in samples if sample["toward"] == "outside" and sample["away"] == "inside")
|
||
boss_votes = sum(1 for sample in samples if sample["toward"] == "inside" and sample["away"] == "outside")
|
||
unclear_votes = sample_count - hole_votes - boss_votes
|
||
vote_summary = f"hole={hole_votes}, boss={boss_votes}, unclear={unclear_votes}"
|
||
threshold = max(1, math.ceil(sample_count * 0.6))
|
||
base = {
|
||
"toward_axis": _state_summary(toward_states),
|
||
"away_axis": _state_summary(away_states),
|
||
"vote_summary": vote_summary,
|
||
"sample_count": sample_count,
|
||
}
|
||
|
||
if hole_votes >= threshold:
|
||
confidence = "high" if hole_votes == sample_count and not is_partial_cylinder else "medium"
|
||
return {
|
||
"feature_guess": "hole/groove candidate",
|
||
"confidence": confidence,
|
||
"note": "axis side is mostly empty and outer side is mostly material",
|
||
**base,
|
||
}
|
||
|
||
if is_partial_cylinder and is_small_radius:
|
||
return {
|
||
"feature_guess": "round/fillet candidate",
|
||
"confidence": "medium" if boundary_edges >= 4 else "low",
|
||
"note": "partial small-radius cylinder; may be a fillet or blend",
|
||
**base,
|
||
}
|
||
|
||
if boss_votes >= threshold:
|
||
return {
|
||
"feature_guess": "boss/outer-round candidate",
|
||
"confidence": "high" if boss_votes == sample_count and not is_partial_cylinder else "medium",
|
||
"note": "axis side is mostly material and outer side is mostly empty",
|
||
**base,
|
||
}
|
||
|
||
return {
|
||
"feature_guess": "cylindrical face",
|
||
"confidence": "low",
|
||
"note": "material sampling did not produce a clear inside/outside pattern",
|
||
**base,
|
||
}
|
||
|
||
def _sample_cylinder_material_states(
|
||
self,
|
||
surf: BRepAdaptor_Surface,
|
||
solid: TopoDS_Shape,
|
||
detailed: bool = False,
|
||
) -> list[dict[str, str]]:
|
||
cyl = surf.Cylinder()
|
||
axis = cyl.Axis()
|
||
axis_point = axis.Location()
|
||
axis_dir = axis.Direction()
|
||
radius = cyl.Radius()
|
||
u_first = surf.FirstUParameter()
|
||
u_last = surf.LastUParameter()
|
||
v = (surf.FirstVParameter() + surf.LastVParameter()) / 2.0
|
||
u_span = u_last - u_first
|
||
fractions = [0.5]
|
||
if detailed and abs(u_span) > 0.2:
|
||
fractions = [0.25, 0.5, 0.75]
|
||
|
||
samples: list[dict[str, str]] = []
|
||
for fraction in fractions:
|
||
u = u_first + u_span * fraction
|
||
point = surf.Value(u, v)
|
||
axis_to_point = _vec_from_points(axis_point, point)
|
||
projection = _dot(axis_to_point, axis_dir)
|
||
center = gp_Pnt(
|
||
axis_point.X() + axis_dir.X() * projection,
|
||
axis_point.Y() + axis_dir.Y() * projection,
|
||
axis_point.Z() + axis_dir.Z() * projection,
|
||
)
|
||
radial = _vec_from_points(center, point)
|
||
radial_len = radial.Magnitude()
|
||
if radial_len <= 1e-9:
|
||
continue
|
||
|
||
unit = gp_Vec(radial.X() / radial_len, radial.Y() / radial_len, radial.Z() / radial_len)
|
||
epsilon = min(max(radius * 0.03, 0.05), 1.0)
|
||
toward_point = gp_Pnt(
|
||
point.X() - unit.X() * epsilon,
|
||
point.Y() - unit.Y() * epsilon,
|
||
point.Z() - unit.Z() * epsilon,
|
||
)
|
||
away_point = gp_Pnt(
|
||
point.X() + unit.X() * epsilon,
|
||
point.Y() + unit.Y() * epsilon,
|
||
point.Z() + unit.Z() * epsilon,
|
||
)
|
||
samples.append(
|
||
{
|
||
"toward": _solid_state(solid, toward_point),
|
||
"away": _solid_state(solid, away_point),
|
||
}
|
||
)
|
||
return samples
|
||
|
||
def _plane_push_pull_direction(self, face_id: int, surf: BRepAdaptor_Surface) -> dict[str, object]:
|
||
face = self.faces[face_id]
|
||
direction = surf.Plane().Axis().Direction()
|
||
axis_tuple = _dir_tuple(direction)
|
||
oriented_tuple = _oriented_dir_tuple(direction, face)
|
||
fallback = {
|
||
"outward_direction": oriented_tuple,
|
||
"inward_direction": _neg_tuple(oriented_tuple),
|
||
"plus_side_state": "unknown",
|
||
"minus_side_state": "unknown",
|
||
"confidence": "low",
|
||
"note": "falling back to topology-oriented plane normal",
|
||
}
|
||
|
||
solid_id = self.face_solid_ids[face_id]
|
||
if solid_id < 0 or solid_id >= len(self.solids):
|
||
fallback["note"] = "no owning solid was found; using topology-oriented plane normal"
|
||
return fallback
|
||
|
||
solid = self.solids[solid_id][1]
|
||
props = GProp_GProps()
|
||
brepgprop.SurfaceProperties(face, props)
|
||
sample = props.CentreOfMass()
|
||
diagonal = _shape_diagonal(solid)
|
||
epsilon = min(max(diagonal * 1e-4, 0.05), 1.0)
|
||
plus_point = gp_Pnt(
|
||
sample.X() + direction.X() * epsilon,
|
||
sample.Y() + direction.Y() * epsilon,
|
||
sample.Z() + direction.Z() * epsilon,
|
||
)
|
||
minus_point = gp_Pnt(
|
||
sample.X() - direction.X() * epsilon,
|
||
sample.Y() - direction.Y() * epsilon,
|
||
sample.Z() - direction.Z() * epsilon,
|
||
)
|
||
plus_state = _solid_state(solid, plus_point)
|
||
minus_state = _solid_state(solid, minus_point)
|
||
|
||
if plus_state == "outside" and minus_state == "inside":
|
||
return {
|
||
"outward_direction": axis_tuple,
|
||
"inward_direction": _neg_tuple(axis_tuple),
|
||
"plus_side_state": plus_state,
|
||
"minus_side_state": minus_state,
|
||
"confidence": "high",
|
||
"note": "positive plane normal side is outside material",
|
||
}
|
||
if plus_state == "inside" and minus_state == "outside":
|
||
return {
|
||
"outward_direction": _neg_tuple(axis_tuple),
|
||
"inward_direction": axis_tuple,
|
||
"plus_side_state": plus_state,
|
||
"minus_side_state": minus_state,
|
||
"confidence": "high",
|
||
"note": "negative plane normal side is outside material",
|
||
}
|
||
|
||
fallback["plus_side_state"] = plus_state
|
||
fallback["minus_side_state"] = minus_state
|
||
fallback["note"] = "inside/outside sampling was unclear; using topology-oriented plane normal"
|
||
return fallback
|
||
|
||
def export_all(self, filename: str | Path) -> None:
|
||
_write_step(self.shape, Path(filename))
|
||
|
||
def export_part(self, part_id: int, filename: str | Path) -> None:
|
||
part = self.part_by_id(part_id)
|
||
if part is None:
|
||
raise ValueError(f"Unknown part id {part_id}")
|
||
_write_step(part.shape, Path(filename))
|
||
|
||
def export_solid(self, solid_id: int, filename: str | Path) -> None:
|
||
if solid_id < 0 or solid_id >= len(self.solids):
|
||
raise ValueError(f"Unknown solid id {solid_id}")
|
||
_write_step(self.solids[solid_id][1], Path(filename))
|
||
|
||
def export_face(self, face_id: int, filename: str | Path) -> None:
|
||
if face_id < 0 or face_id >= len(self.faces):
|
||
raise ValueError(f"Unknown face id {face_id}")
|
||
_write_step(self.faces[face_id], Path(filename))
|
||
|
||
def push_pull_preview_polydata(self, face_id: int, distance: float, deflection: float = 0.8):
|
||
face = self.faces[face_id]
|
||
surf = BRepAdaptor_Surface(face)
|
||
if surf.GetType() != GeomAbs_Plane:
|
||
raise ValueError("Push/pull preview currently supports planar faces only.")
|
||
|
||
direction_info = self._plane_push_pull_direction(face_id, surf)
|
||
outward = direction_info["outward_direction"]
|
||
vec = gp_Vec(
|
||
float(outward[0]) * distance,
|
||
float(outward[1]) * distance,
|
||
float(outward[2]) * distance,
|
||
)
|
||
preview_shape = BRepPrimAPI_MakePrism(face, vec).Shape()
|
||
BRepMesh_IncrementalMesh(preview_shape, deflection)
|
||
return _shape_faces_polydata(preview_shape)
|
||
|
||
def push_pull_face(self, face_id: int, distance: float) -> str:
|
||
face = self.faces[face_id]
|
||
surf = BRepAdaptor_Surface(face)
|
||
if surf.GetType() != GeomAbs_Plane:
|
||
raise ValueError("Push/pull currently supports planar faces only.")
|
||
|
||
direction_info = self._plane_push_pull_direction(face_id, surf)
|
||
outward = direction_info["outward_direction"]
|
||
vec = gp_Vec(
|
||
float(outward[0]) * distance,
|
||
float(outward[1]) * distance,
|
||
float(outward[2]) * distance,
|
||
)
|
||
tool_shape = BRepPrimAPI_MakePrism(face, vec).Shape()
|
||
part_id = self.face_part_ids[face_id]
|
||
part = self.part_by_id(part_id)
|
||
if part is None:
|
||
raise ValueError(f"Unknown part id {part_id}")
|
||
|
||
op = BRepAlgoAPI_Fuse(part.shape, tool_shape) if distance >= 0 else BRepAlgoAPI_Cut(part.shape, tool_shape)
|
||
op.Build()
|
||
if not op.IsDone():
|
||
raise RuntimeError("Boolean operation failed.")
|
||
result = op.Shape()
|
||
_ensure_valid_shape(result)
|
||
part.shape = result
|
||
self.refresh_topology()
|
||
action = "fused outward prism" if distance >= 0 else "cut inward prism"
|
||
return (
|
||
"Planar face push/pull completed: "
|
||
f"{action}, semantic_distance={distance:g}, "
|
||
f"outward_direction={_format_tuple(outward)}, "
|
||
f"direction_confidence={direction_info['confidence']}."
|
||
)
|
||
|
||
def enlarge_cylindrical_hole(self, face_id: int, new_diameter: float) -> str:
|
||
return self.resize_cylindrical_hole(face_id, new_diameter)
|
||
|
||
def resize_cylindrical_hole(self, face_id: int, new_diameter: float) -> str:
|
||
plan = self.cylindrical_resize_plan(face_id, new_diameter)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
|
||
face = self.faces[face_id]
|
||
surf = BRepAdaptor_Surface(face)
|
||
if surf.GetType() != GeomAbs_Cylinder:
|
||
raise ValueError("Hole resize currently supports cylindrical faces only.")
|
||
|
||
cyl = surf.Cylinder()
|
||
old_radius = cyl.Radius()
|
||
new_radius = new_diameter / 2.0
|
||
if new_radius <= 0:
|
||
raise ValueError("Target diameter must be greater than 0.")
|
||
|
||
part_id = self.face_part_ids[face_id]
|
||
part = self.part_by_id(part_id)
|
||
if part is None:
|
||
raise ValueError(f"Unknown part id {part_id}")
|
||
|
||
direction = cyl.Axis().Direction()
|
||
source_shape = part.shape
|
||
if plan["resize_mode"] == "shrink":
|
||
fill_start = gp_Pnt(*plan["fill_start_point"])
|
||
fill_axis = gp_Ax2(fill_start, gp_Dir(direction.X(), direction.Y(), direction.Z()))
|
||
filler = BRepPrimAPI_MakeCylinder(
|
||
fill_axis,
|
||
float(plan["fill_radius"]),
|
||
float(plan["fill_height"]),
|
||
).Shape()
|
||
fuse = BRepAlgoAPI_Fuse(part.shape, filler)
|
||
fuse.Build()
|
||
if not fuse.IsDone():
|
||
raise RuntimeError("Cylinder fill/fuse failed.")
|
||
source_shape = fuse.Shape()
|
||
_ensure_valid_shape(source_shape)
|
||
|
||
cutter_start = gp_Pnt(*plan["cutter_start_point"])
|
||
cutter_axis = gp_Ax2(cutter_start, gp_Dir(direction.X(), direction.Y(), direction.Z()))
|
||
cutter = BRepPrimAPI_MakeCylinder(cutter_axis, new_radius, float(plan["cutter_height"])).Shape()
|
||
|
||
op = BRepAlgoAPI_Cut(source_shape, cutter)
|
||
op.Build()
|
||
if not op.IsDone():
|
||
raise RuntimeError("Cylinder cut failed.")
|
||
result = op.Shape()
|
||
_ensure_valid_shape(result)
|
||
part.shape = result
|
||
self.refresh_topology()
|
||
action = "enlarged by bounded cut" if plan["resize_mode"] == "enlarge" else "shrunk by fill and recut"
|
||
return (
|
||
f"Cylindrical resize completed: diameter {old_radius * 2.0:g} -> {new_diameter:g}, "
|
||
f"mode={plan['resize_mode']}, action={action}, "
|
||
f"risk={plan['risk']}, feature={plan['feature_guess']}, "
|
||
f"cutter={plan['cutter_strategy']}, height={float(plan['cutter_height']):g}."
|
||
)
|
||
|
||
def build_face_polydata(
|
||
self,
|
||
face_ids: Iterable[int] | None = None,
|
||
part_ids: Iterable[int] | None = None,
|
||
deflection: float = 0.8,
|
||
):
|
||
import vtk
|
||
|
||
selected_faces = set(face_ids) if face_ids is not None else None
|
||
selected_parts = set(part_ids) if part_ids is not None else None
|
||
BRepMesh_IncrementalMesh(self.shape, deflection)
|
||
|
||
points = vtk.vtkPoints()
|
||
polys = vtk.vtkCellArray()
|
||
face_arr = vtk.vtkIntArray()
|
||
face_arr.SetName("face_id")
|
||
part_arr = vtk.vtkIntArray()
|
||
part_arr.SetName("part_id")
|
||
solid_arr = vtk.vtkIntArray()
|
||
solid_arr.SetName("solid_id")
|
||
|
||
for face_id, face in enumerate(self.faces):
|
||
part_id = self.face_part_ids[face_id]
|
||
if selected_faces is not None and face_id not in selected_faces:
|
||
continue
|
||
if selected_parts is not None and part_id not in selected_parts:
|
||
continue
|
||
|
||
loc = TopLoc_Location()
|
||
tri = BRep_Tool.Triangulation(topods.Face(face), loc)
|
||
if tri is None:
|
||
continue
|
||
transform = loc.Transformation()
|
||
node_offset = points.GetNumberOfPoints()
|
||
for node_index in range(1, tri.NbNodes() + 1):
|
||
pnt = tri.Node(node_index).Transformed(transform)
|
||
points.InsertNextPoint(pnt.X(), pnt.Y(), pnt.Z())
|
||
|
||
reversed_face = face.Orientation() == TopAbs_REVERSED
|
||
for tri_index in range(1, tri.NbTriangles() + 1):
|
||
n1, n2, n3 = tri.Triangle(tri_index).Get()
|
||
if reversed_face:
|
||
n2, n3 = n3, n2
|
||
vtk_tri = vtk.vtkTriangle()
|
||
vtk_tri.GetPointIds().SetId(0, node_offset + n1 - 1)
|
||
vtk_tri.GetPointIds().SetId(1, node_offset + n2 - 1)
|
||
vtk_tri.GetPointIds().SetId(2, node_offset + n3 - 1)
|
||
polys.InsertNextCell(vtk_tri)
|
||
face_arr.InsertNextValue(face_id)
|
||
part_arr.InsertNextValue(part_id)
|
||
solid_arr.InsertNextValue(self.face_solid_ids[face_id])
|
||
|
||
poly = vtk.vtkPolyData()
|
||
poly.SetPoints(points)
|
||
poly.SetPolys(polys)
|
||
poly.GetCellData().AddArray(face_arr)
|
||
poly.GetCellData().AddArray(part_arr)
|
||
poly.GetCellData().AddArray(solid_arr)
|
||
return poly
|
||
|
||
def build_snapshot_polydata(self, snapshot: dict[int, TopoDS_Shape], deflection: float = 0.8):
|
||
shape = _compound_from_shapes(snapshot.values())
|
||
BRepMesh_IncrementalMesh(shape, deflection)
|
||
return _shape_faces_polydata(shape)
|
||
|
||
def build_edge_polydata(self, deflection: float = 0.8):
|
||
import vtk
|
||
|
||
points = vtk.vtkPoints()
|
||
lines = vtk.vtkCellArray()
|
||
edge_arr = vtk.vtkIntArray()
|
||
edge_arr.SetName("edge_id")
|
||
part_arr = vtk.vtkIntArray()
|
||
part_arr.SetName("part_id")
|
||
|
||
for edge_id, edge in enumerate(self.edges):
|
||
samples = discretize_edge(edge, deflection)
|
||
if len(samples) < 2:
|
||
continue
|
||
polyline = vtk.vtkPolyLine()
|
||
polyline.GetPointIds().SetNumberOfIds(len(samples))
|
||
for i, coords in enumerate(samples):
|
||
point_id = points.InsertNextPoint(float(coords[0]), float(coords[1]), float(coords[2]))
|
||
polyline.GetPointIds().SetId(i, point_id)
|
||
lines.InsertNextCell(polyline)
|
||
edge_arr.InsertNextValue(edge_id)
|
||
part_arr.InsertNextValue(self.edge_part_ids[edge_id])
|
||
|
||
poly = vtk.vtkPolyData()
|
||
poly.SetPoints(points)
|
||
poly.SetLines(lines)
|
||
poly.GetCellData().AddArray(edge_arr)
|
||
poly.GetCellData().AddArray(part_arr)
|
||
return poly
|
||
|
||
|
||
def _load_with_xcaf(path: Path, product_names: list[str]) -> tuple[list[PartNode], TopoDS_Shape]:
|
||
doc = TDocStd_Document("pythonocc-step-document")
|
||
shape_tool = XCAFDoc_DocumentTool.ShapeTool(doc.Main())
|
||
|
||
reader = STEPCAFControl_Reader()
|
||
reader.SetColorMode(True)
|
||
reader.SetLayerMode(True)
|
||
reader.SetNameMode(True)
|
||
reader.SetMatMode(True)
|
||
reader.SetGDTMode(True)
|
||
status = reader.ReadFile(str(path))
|
||
if status != IFSelect_RetDone:
|
||
raise ValueError(f"Could not read STEP file: {path}")
|
||
if not reader.Transfer(doc):
|
||
raise ValueError(f"Could not transfer STEP document: {path}")
|
||
|
||
parts: list[PartNode] = []
|
||
free_shapes = TDF_LabelSequence()
|
||
shape_tool.GetFreeShapes(free_shapes)
|
||
|
||
def next_name(label: TDF_Label, index: int) -> str:
|
||
label_name = str(label.GetLabelName()).strip()
|
||
if label_name:
|
||
return label_name
|
||
if index - 1 < len(product_names):
|
||
return product_names[index - 1]
|
||
return f"Part {index}"
|
||
|
||
def add_node(
|
||
name: str,
|
||
kind: str,
|
||
shape: TopoDS_Shape,
|
||
parent_id: int | None,
|
||
depth: int,
|
||
path_text: str,
|
||
) -> PartNode:
|
||
node = PartNode(len(parts) + 1, name, kind, shape, parent_id, depth, path_text)
|
||
parts.append(node)
|
||
return node
|
||
|
||
def transformed_shape(label: TDF_Label, locations: list[TopLoc_Location]) -> TopoDS_Shape:
|
||
shape = shape_tool.GetShape(label)
|
||
if shape.IsNull() or not locations:
|
||
return shape
|
||
location = TopLoc_Location()
|
||
for loc in locations:
|
||
location = location.Multiplied(loc)
|
||
return BRepBuilderAPI_Transform(shape, location.Transformation()).Shape()
|
||
|
||
def walk(label: TDF_Label, parent_id: int | None, depth: int, locations: list[TopLoc_Location], path_names: list[str]):
|
||
name = next_name(label, len(parts) + 1)
|
||
label_path = " / ".join(path_names + [name])
|
||
|
||
if shape_tool.IsAssembly(label):
|
||
node = add_node(name, "assembly", transformed_shape(label, locations), parent_id, depth, label_path)
|
||
components = TDF_LabelSequence()
|
||
shape_tool.GetComponents(label, components)
|
||
for i in range(1, components.Length() + 1):
|
||
component = components.Value(i)
|
||
if shape_tool.IsReference(component):
|
||
referred = TDF_Label()
|
||
shape_tool.GetReferredShape(component, referred)
|
||
loc = shape_tool.GetLocation(component)
|
||
walk(referred, node.id, depth + 1, locations + [loc], path_names + [name])
|
||
else:
|
||
walk(component, node.id, depth + 1, locations, path_names + [name])
|
||
return
|
||
|
||
if shape_tool.IsSimpleShape(label) or shape_tool.IsShape(label):
|
||
add_node(name, "part", transformed_shape(label, locations), parent_id, depth, label_path)
|
||
|
||
for i in range(1, free_shapes.Length() + 1):
|
||
walk(free_shapes.Value(i), None, 0, [], [])
|
||
|
||
display_shapes = [p.shape for p in parts if p.kind == "part" and not p.shape.IsNull()]
|
||
if not display_shapes:
|
||
display_shapes = [p.shape for p in parts if not p.shape.IsNull()]
|
||
return parts, _compound_from_shapes(display_shapes)
|
||
|
||
|
||
def _load_plain_step(path: Path) -> TopoDS_Shape:
|
||
reader = STEPControl_Reader()
|
||
status = reader.ReadFile(str(path))
|
||
if status != IFSelect_RetDone:
|
||
raise ValueError(f"Could not read STEP file: {path}")
|
||
if not reader.TransferRoots():
|
||
raise ValueError(f"Could not transfer STEP roots: {path}")
|
||
return reader.Shape()
|
||
|
||
|
||
def _parse_product_names(path: Path) -> list[str]:
|
||
text = path.read_text(errors="ignore")
|
||
names = re.findall(r"PRODUCT\('((?:''|[^'])*)'", text)
|
||
return [name.replace("''", "'") for name in names if name.strip()]
|
||
|
||
|
||
def _write_step(shape: TopoDS_Shape, filename: Path) -> None:
|
||
if shape.IsNull():
|
||
raise ValueError("Cannot export a null shape.")
|
||
filename.parent.mkdir(parents=True, exist_ok=True)
|
||
Interface_Static.SetCVal("write.step.schema", "AP214IS")
|
||
writer = STEPControl_Writer()
|
||
writer.Transfer(shape, STEPControl_AsIs)
|
||
status = writer.Write(str(filename))
|
||
if status != IFSelect_RetDone:
|
||
raise IOError(f"Could not write STEP file: {filename}")
|
||
|
||
|
||
def _compound_from_shapes(shapes: Iterable[TopoDS_Shape]) -> TopoDS_Shape:
|
||
from OCC.Core.BRep import BRep_Builder
|
||
|
||
valid_shapes = [shape for shape in shapes if not shape.IsNull()]
|
||
if len(valid_shapes) == 1:
|
||
return valid_shapes[0]
|
||
|
||
compound = TopoDS_Compound()
|
||
builder = BRep_Builder()
|
||
builder.MakeCompound(compound)
|
||
for shape in valid_shapes:
|
||
builder.Add(compound, shape)
|
||
return compound
|
||
|
||
|
||
def _explore(shape: TopoDS_Shape, shape_type: int) -> list[TopoDS_Shape]:
|
||
items: list[TopoDS_Shape] = []
|
||
explorer = TopExp_Explorer(shape, shape_type)
|
||
while explorer.More():
|
||
current = explorer.Current()
|
||
if shape_type == TopAbs_FACE:
|
||
items.append(topods.Face(current))
|
||
elif shape_type == TopAbs_EDGE:
|
||
items.append(topods.Edge(current))
|
||
elif shape_type == TopAbs_SOLID:
|
||
items.append(topods.Solid(current))
|
||
else:
|
||
items.append(current)
|
||
explorer.Next()
|
||
return items
|
||
|
||
|
||
def _shape_faces_polydata(shape: TopoDS_Shape):
|
||
import vtk
|
||
|
||
points = vtk.vtkPoints()
|
||
polys = vtk.vtkCellArray()
|
||
for face in _explore(shape, TopAbs_FACE):
|
||
loc = TopLoc_Location()
|
||
tri = BRep_Tool.Triangulation(topods.Face(face), loc)
|
||
if tri is None:
|
||
continue
|
||
transform = loc.Transformation()
|
||
node_offset = points.GetNumberOfPoints()
|
||
for node_index in range(1, tri.NbNodes() + 1):
|
||
pnt = tri.Node(node_index).Transformed(transform)
|
||
points.InsertNextPoint(pnt.X(), pnt.Y(), pnt.Z())
|
||
|
||
reversed_face = face.Orientation() == TopAbs_REVERSED
|
||
for tri_index in range(1, tri.NbTriangles() + 1):
|
||
n1, n2, n3 = tri.Triangle(tri_index).Get()
|
||
if reversed_face:
|
||
n2, n3 = n3, n2
|
||
vtk_tri = vtk.vtkTriangle()
|
||
vtk_tri.GetPointIds().SetId(0, node_offset + n1 - 1)
|
||
vtk_tri.GetPointIds().SetId(1, node_offset + n2 - 1)
|
||
vtk_tri.GetPointIds().SetId(2, node_offset + n3 - 1)
|
||
polys.InsertNextCell(vtk_tri)
|
||
|
||
poly = vtk.vtkPolyData()
|
||
poly.SetPoints(points)
|
||
poly.SetPolys(polys)
|
||
return poly
|
||
|
||
|
||
def _shape_bounds(shape: TopoDS_Shape) -> tuple[float, float, float, float, float, float]:
|
||
box = Bnd_Box()
|
||
brepbndlib.Add(shape, box)
|
||
return box.Get()
|
||
|
||
|
||
def _shape_bounds_info(shape: TopoDS_Shape) -> dict[str, object]:
|
||
xmin, ymin, zmin, xmax, ymax, zmax = _shape_bounds(shape)
|
||
dx = xmax - xmin
|
||
dy = ymax - ymin
|
||
dz = zmax - zmin
|
||
return {
|
||
"bbox_min": (xmin, ymin, zmin),
|
||
"bbox_max": (xmax, ymax, zmax),
|
||
"bbox_size": (dx, dy, dz),
|
||
"bbox_diagonal": math.sqrt(dx * dx + dy * dy + dz * dz),
|
||
}
|
||
|
||
|
||
def _shape_volume_info(shape: TopoDS_Shape) -> dict[str, object]:
|
||
props = GProp_GProps()
|
||
try:
|
||
brepgprop.VolumeProperties(shape, props)
|
||
except Exception:
|
||
return {"volume": "unavailable"}
|
||
volume = props.Mass()
|
||
info: dict[str, object] = {"volume": volume}
|
||
if abs(volume) > 1e-9:
|
||
info["center_of_mass"] = _point_tuple(props.CentreOfMass())
|
||
return info
|
||
|
||
|
||
def _shape_diagonal(shape: TopoDS_Shape) -> float:
|
||
xmin, ymin, zmin, xmax, ymax, zmax = _shape_bounds(shape)
|
||
return math.sqrt((xmax - xmin) ** 2 + (ymax - ymin) ** 2 + (zmax - zmin) ** 2)
|
||
|
||
|
||
def _ensure_valid_shape(shape: TopoDS_Shape) -> None:
|
||
if shape.IsNull():
|
||
raise RuntimeError("Operation returned a null shape.")
|
||
analyzer = BRepCheck_Analyzer(shape)
|
||
if not analyzer.IsValid():
|
||
raise RuntimeError("Operation returned an invalid B-Rep shape.")
|
||
|
||
|
||
def _solid_state(solid: TopoDS_Shape, point: gp_Pnt) -> str:
|
||
classifier = BRepClass3d_SolidClassifier(solid, point, 1e-6)
|
||
state = classifier.State()
|
||
if state == TopAbs_IN:
|
||
return "inside"
|
||
if state == TopAbs_OUT:
|
||
return "outside"
|
||
return "on/unknown"
|
||
|
||
|
||
def _state_summary(states: list[str]) -> str:
|
||
if not states:
|
||
return "unknown"
|
||
counts: dict[str, int] = {}
|
||
for state in states:
|
||
counts[state] = counts.get(state, 0) + 1
|
||
if len(counts) == 1:
|
||
return states[0]
|
||
return ", ".join(f"{state}:{count}" for state, count in sorted(counts.items()))
|
||
|
||
|
||
def _cylinder_resize_readiness(
|
||
info: dict[str, object],
|
||
new_diameter: float | None = None,
|
||
) -> dict[str, object]:
|
||
risk = "low"
|
||
status = "ready"
|
||
warnings: list[str] = []
|
||
blockers: list[str] = []
|
||
guess = str(info.get("feature_guess", "cylindrical face"))
|
||
confidence = str(info.get("confidence", "low"))
|
||
angular_span = float(info.get("angular_span", 0.0))
|
||
|
||
if guess == "round/fillet candidate":
|
||
risk = "high"
|
||
warnings.append("当前圆柱面更像圆角/倒圆，调整圆柱孔径很可能误切圆角。")
|
||
elif guess == "boss/outer-round candidate":
|
||
risk = "high"
|
||
warnings.append("当前圆柱面更像凸柱或外圆，调整圆柱孔径可能切掉外部结构。")
|
||
elif guess != "hole/groove candidate":
|
||
risk = "high"
|
||
warnings.append("当前圆柱面还没有被识别为孔/槽候选。")
|
||
|
||
if guess == "hole/groove candidate" and confidence == "low":
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append("孔/槽判断置信度较低。")
|
||
if guess == "hole/groove candidate" and angular_span < math.tau * 0.92:
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append("这是局部圆柱面，更像槽或半孔，不是完整圆孔。")
|
||
|
||
if new_diameter is not None:
|
||
current_diameter = float(info.get("diameter", 0.0))
|
||
if new_diameter <= 0:
|
||
status = "blocked"
|
||
risk = "blocked"
|
||
blockers.append("目标直径必须大于 0。")
|
||
elif abs(new_diameter - current_diameter) <= max(current_diameter * 1e-5, 1e-6):
|
||
status = "blocked"
|
||
risk = "blocked"
|
||
blockers.append("目标直径与当前直径几乎相同，不需要修改。")
|
||
elif new_diameter < current_diameter:
|
||
if guess != "hole/groove candidate":
|
||
status = "blocked"
|
||
risk = "blocked"
|
||
blockers.append("缩小孔径第一版只支持孔/槽候选，不支持圆角、凸柱或未明确圆柱面。")
|
||
else:
|
||
risk = _max_risk(risk, "high")
|
||
warnings.append("缩小孔径会先补料再重切，属于高风险实验功能。")
|
||
|
||
if risk in {"medium", "high"} and status != "blocked":
|
||
status = "caution"
|
||
if not warnings and not blockers:
|
||
note = "可以尝试调整圆柱孔径。"
|
||
else:
|
||
note = " ".join(blockers + warnings)
|
||
return {
|
||
"resize_status": status,
|
||
"resize_risk": risk,
|
||
"resize_warnings": "；".join(warnings),
|
||
"resize_blockers": "；".join(blockers),
|
||
"resize_note": note,
|
||
}
|
||
|
||
|
||
def _max_risk(current: str, candidate: str) -> str:
|
||
levels = {"low": 0, "medium": 1, "high": 2, "blocked": 3}
|
||
return candidate if levels[candidate] > levels[current] else current
|
||
|
||
|
||
def _resize_mode(current_diameter: float, target_diameter: float) -> str:
|
||
return "enlarge" if target_diameter > current_diameter else "shrink"
|
||
|
||
|
||
def _dir_tuple(direction) -> tuple[float, float, float]:
|
||
return (direction.X(), direction.Y(), direction.Z())
|
||
|
||
|
||
def _oriented_dir_tuple(direction, shape: TopoDS_Shape) -> tuple[float, float, float]:
|
||
values = _dir_tuple(direction)
|
||
if shape.Orientation() == TopAbs_REVERSED:
|
||
return (-values[0], -values[1], -values[2])
|
||
return values
|
||
|
||
|
||
def _neg_tuple(values: tuple[float, float, float]) -> tuple[float, float, float]:
|
||
return (-values[0], -values[1], -values[2])
|
||
|
||
|
||
def _point_tuple(point) -> tuple[float, float, float]:
|
||
return (point.X(), point.Y(), point.Z())
|
||
|
||
|
||
def _point_on_axis(axis_point: gp_Pnt, direction, parameter: float) -> gp_Pnt:
|
||
return gp_Pnt(
|
||
axis_point.X() + direction.X() * parameter,
|
||
axis_point.Y() + direction.Y() * parameter,
|
||
axis_point.Z() + direction.Z() * parameter,
|
||
)
|
||
|
||
|
||
def _orientation_name(orientation) -> str:
|
||
return ORIENTATION_TYPES.get(orientation, f"type {orientation}")
|
||
|
||
|
||
def _format_tuple(values: tuple[float, float, float]) -> str:
|
||
return "(" + ", ".join(f"{float(value):.6g}" for value in values) + ")"
|
||
|
||
|
||
def _vec_from_points(a: gp_Pnt, b: gp_Pnt) -> gp_Vec:
|
||
return gp_Vec(b.X() - a.X(), b.Y() - a.Y(), b.Z() - a.Z())
|
||
|
||
|
||
def _dot(vec: gp_Vec, direction) -> float:
|
||
return vec.X() * direction.X() + vec.Y() * direction.Y() + vec.Z() * direction.Z()
|