4617 lines
196 KiB
Python
4617 lines
196 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_Defeaturing, 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.BRepFilletAPI import BRepFilletAPI_MakeChamfer, BRepFilletAPI_MakeFillet
|
||
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.ShapeFix import ShapeFix_Shape
|
||
from OCC.Core.ShapeUpgrade import ShapeUpgrade_UnifySameDomain
|
||
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, topexp
|
||
from OCC.Core.TopLoc import TopLoc_Location
|
||
from OCC.Core.TopoDS import TopoDS_Compound, TopoDS_Shape, topods
|
||
from OCC.Core.TopTools import TopTools_IndexedDataMapOfShapeListOfShape, TopTools_IndexedMapOfShape
|
||
from OCC.Core.XCAFDoc import XCAFDoc_DocumentTool
|
||
from OCC.Core.gp import gp_Ax1, gp_Ax2, gp_Dir, gp_Pnt, gp_Trsf, 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.edge_solid_ids: list[int] = []
|
||
self.solids: list[tuple[int, TopoDS_Shape]] = []
|
||
self._face_info_cache: dict[int, dict[str, object]] = {}
|
||
self._edge_info_cache: dict[int, dict[str, object]] = {}
|
||
self._face_edge_ids_cache: dict[int, list[int]] = {}
|
||
self._edge_face_ids_cache: dict[int, list[int]] = {}
|
||
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 part_topology_stats(self, part_id: int) -> TopologyStats:
|
||
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)
|
||
return TopologyStats(
|
||
parts=1,
|
||
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.edge_solid_ids.clear()
|
||
self.solids.clear()
|
||
self._face_info_cache.clear()
|
||
self._edge_info_cache.clear()
|
||
self._face_edge_ids_cache.clear()
|
||
self._edge_face_ids_cache.clear()
|
||
|
||
solid_id = 0
|
||
for part in self.display_parts():
|
||
part_solids = _explore(part.shape, TopAbs_SOLID)
|
||
part_solid_edge_maps: list[tuple[int, TopTools_IndexedDataMapOfShapeListOfShape]] = []
|
||
part_solid_entries: list[tuple[int, TopoDS_Shape]] = []
|
||
if part_solids:
|
||
for solid in part_solids:
|
||
current_solid_id = solid_id
|
||
self.solids.append((part.id, solid))
|
||
part_solid_entries.append((current_solid_id, solid))
|
||
edge_map = TopTools_IndexedDataMapOfShapeListOfShape()
|
||
topexp.MapShapesAndAncestors(solid, TopAbs_EDGE, TopAbs_SOLID, edge_map)
|
||
part_solid_edge_maps.append((current_solid_id, edge_map))
|
||
solid_id += 1
|
||
|
||
part_edge_map = TopTools_IndexedMapOfShape()
|
||
topexp.MapShapes(part.shape, TopAbs_EDGE, part_edge_map)
|
||
part_edge_ids_by_index: dict[int, int] = {}
|
||
for local_edge_index in range(1, part_edge_map.Size() + 1):
|
||
edge = part_edge_map.FindKey(local_edge_index)
|
||
edge_id = len(self.edges)
|
||
part_edge_ids_by_index[local_edge_index] = edge_id
|
||
self.edges.append(edge)
|
||
self.edge_part_ids.append(part.id)
|
||
self.edge_solid_ids.append(_mapped_edge_solid_id(edge, part_solid_edge_maps))
|
||
self._edge_face_ids_cache[edge_id] = []
|
||
|
||
if part_solids:
|
||
for current_solid_id, solid in part_solid_entries:
|
||
for face in _explore(solid, TopAbs_FACE):
|
||
face_id = len(self.faces)
|
||
self.faces.append(face)
|
||
self.face_part_ids.append(part.id)
|
||
self.face_solid_ids.append(current_solid_id)
|
||
self._cache_face_edge_links(face_id, face, part_edge_map, part_edge_ids_by_index)
|
||
else:
|
||
for face in _explore(part.shape, TopAbs_FACE):
|
||
face_id = len(self.faces)
|
||
self.faces.append(face)
|
||
self.face_part_ids.append(part.id)
|
||
self.face_solid_ids.append(-1)
|
||
self._cache_face_edge_links(face_id, face, part_edge_map, part_edge_ids_by_index)
|
||
|
||
def _cache_face_edge_links(
|
||
self,
|
||
face_id: int,
|
||
face: TopoDS_Shape,
|
||
part_edge_map: TopTools_IndexedMapOfShape,
|
||
part_edge_ids_by_index: dict[int, int],
|
||
) -> None:
|
||
face_edge_ids: list[int] = []
|
||
face_edge_map = TopTools_IndexedMapOfShape()
|
||
topexp.MapShapes(face, TopAbs_EDGE, face_edge_map)
|
||
for local_face_edge_index in range(1, face_edge_map.Size() + 1):
|
||
local_part_edge_index = part_edge_map.FindIndex(face_edge_map.FindKey(local_face_edge_index))
|
||
edge_id = part_edge_ids_by_index.get(local_part_edge_index)
|
||
if edge_id is None:
|
||
continue
|
||
face_edge_ids.append(edge_id)
|
||
self._edge_face_ids_cache.setdefault(edge_id, []).append(face_id)
|
||
self._face_edge_ids_cache[face_id] = face_edge_ids
|
||
|
||
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]:
|
||
if face_id in self._face_info_cache:
|
||
return dict(self._face_info_cache[face_id])
|
||
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))
|
||
info.update(_cylinder_boss_resize_readiness(info))
|
||
info.update(_cylinder_depth_readiness(info))
|
||
info.update(_cylinder_suppress_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()
|
||
self._face_info_cache[face_id] = dict(info)
|
||
return dict(info)
|
||
|
||
def feature_info(self, face_id: int) -> 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)
|
||
surface = str(info.get("surface", ""))
|
||
if surface == "cylinder":
|
||
return self._cylindrical_feature_info(face_id, info)
|
||
if surface == "plane":
|
||
return self._planar_feature_info(face_id, info)
|
||
boundary_edge_ids = self._face_boundary_edge_ids(face_id)
|
||
result = dict(info)
|
||
result.update(
|
||
{
|
||
"kind": "feature",
|
||
"feature_type": "暂不支持的局部曲面候选",
|
||
"feature_source_face_id": face_id,
|
||
"feature_face_ids": (face_id,),
|
||
"feature_highlight_face_ids": (face_id,),
|
||
"feature_boundary_edge_ids": tuple(boundary_edge_ids),
|
||
"feature_edit_actions": "当前第一版只能查看该局部曲面，暂不支持直接编辑。",
|
||
"feature_mode": "Feature 模式会把选中的 face 解释为局部几何特征候选。",
|
||
}
|
||
)
|
||
return result
|
||
|
||
def _planar_feature_info(self, face_id: int, info: dict[str, object]) -> dict[str, object]:
|
||
coplanar_face_ids = self._connected_coplanar_planar_face_ids(face_id)
|
||
boundary_edge_ids = self._region_boundary_edge_ids(coplanar_face_ids)
|
||
if len(coplanar_face_ids) > 1:
|
||
scope_note = f"已检测到 {len(coplanar_face_ids)} 个共享边且共面的 face，推拉时会作为同一片平面区域处理。"
|
||
else:
|
||
scope_note = "当前 face 没有检测到可一起推拉的共享边共面邻居。"
|
||
result = dict(info)
|
||
result.update(
|
||
{
|
||
"kind": "feature",
|
||
"feature_type": "可推拉平面候选",
|
||
"feature_source_face_id": face_id,
|
||
"feature_face_ids": tuple(coplanar_face_ids),
|
||
"feature_highlight_face_ids": tuple(coplanar_face_ids),
|
||
"feature_boundary_edge_ids": tuple(boundary_edge_ids),
|
||
"feature_adjacent_face_ids": tuple(
|
||
sorted(set(self._adjacent_face_ids_for_edges(boundary_edge_ids, face_id)) - set(coplanar_face_ids))
|
||
),
|
||
"push_pull_scope_face_ids": tuple(coplanar_face_ids),
|
||
"push_pull_scope_face_count": len(coplanar_face_ids),
|
||
"push_pull_scope_note": scope_note,
|
||
"feature_edit_actions": "推拉平面",
|
||
"feature_mode": "这是从 B-Rep 几何推断出的平面编辑候选，不是 CAD 历史特征。",
|
||
}
|
||
)
|
||
return result
|
||
|
||
def _cylindrical_feature_info(self, face_id: int, info: dict[str, object]) -> dict[str, object]:
|
||
boundary_edge_ids = self._face_boundary_edge_ids(face_id)
|
||
adjacent_face_ids = self._adjacent_face_ids_for_edges(boundary_edge_ids, face_id)
|
||
end_faces = self._cylindrical_end_face_groups(face_id, adjacent_face_ids, info)
|
||
end_face_ids = end_faces["end_face_ids"]
|
||
bottom_face_ids = end_faces["bottom_face_ids"]
|
||
opening_face_ids = end_faces["opening_face_ids"]
|
||
slot_info = self._cylindrical_slot_info(face_id, adjacent_face_ids, end_face_ids, info)
|
||
fillet_info = self._cylindrical_existing_fillet_info(face_id, adjacent_face_ids, end_face_ids, info)
|
||
|
||
guess = str(info.get("feature_guess", "cylindrical face"))
|
||
angular_span = float(info.get("angular_span", 0.0))
|
||
if guess == "hole/groove candidate":
|
||
if angular_span < math.tau * 0.92:
|
||
feature_type = "槽/半孔候选"
|
||
else:
|
||
feature_type = "圆柱孔候选"
|
||
if info.get("cylinder_end_type") == "blind" and bottom_face_ids:
|
||
edit_actions = "调整圆柱孔径；调整盲孔深度"
|
||
else:
|
||
edit_actions = "调整圆柱孔径；孔深调整需要明确盲孔底面"
|
||
if angular_span >= math.tau * 0.92:
|
||
edit_actions += "；封堵圆柱孔"
|
||
elif guess == "round/fillet candidate":
|
||
feature_type = "圆角/倒圆候选"
|
||
edit_actions = "当前可识别已有圆角半径和相邻支撑面；已有圆角半径修改尚未实现。"
|
||
elif guess == "boss/outer-round candidate":
|
||
feature_type = "凸台/外圆候选"
|
||
edit_actions = "调整圆柱凸台直径。"
|
||
else:
|
||
feature_type = "未明确圆柱特征"
|
||
edit_actions = "可尝试调整圆柱孔径，但风险较高。"
|
||
|
||
highlight_face_ids = tuple(
|
||
sorted(
|
||
{
|
||
face_id,
|
||
*end_face_ids,
|
||
*slot_info.get("feature_slot_boundary_face_ids", ()),
|
||
*fillet_info.get("feature_existing_fillet_support_face_ids", ()),
|
||
}
|
||
)
|
||
)
|
||
result = dict(info)
|
||
result.update(
|
||
{
|
||
"kind": "feature",
|
||
"feature_type": feature_type,
|
||
"feature_source_face_id": face_id,
|
||
"feature_face_ids": (face_id,),
|
||
"feature_side_face_ids": (face_id,),
|
||
"feature_end_face_ids": tuple(end_face_ids),
|
||
"feature_bottom_face_ids": tuple(bottom_face_ids),
|
||
"feature_opening_face_ids": tuple(opening_face_ids),
|
||
"feature_highlight_face_ids": highlight_face_ids,
|
||
"feature_boundary_edge_ids": tuple(boundary_edge_ids),
|
||
"feature_adjacent_face_ids": tuple(adjacent_face_ids),
|
||
"feature_start_end_face_ids": tuple(end_faces["start_end_face_ids"]),
|
||
"feature_end_end_face_ids": tuple(end_faces["end_end_face_ids"]),
|
||
"feature_bottom_confidence": end_faces["bottom_confidence"],
|
||
"feature_bottom_detection": end_faces["bottom_detection"],
|
||
"feature_bottom_note": end_faces["bottom_note"],
|
||
"feature_edit_actions": edit_actions,
|
||
"feature_mode": "这是从 B-Rep 圆柱面、相邻面和材料采样推断出的局部特征候选。",
|
||
**slot_info,
|
||
**fillet_info,
|
||
}
|
||
)
|
||
return result
|
||
|
||
def _cylindrical_slot_info(
|
||
self,
|
||
face_id: int,
|
||
adjacent_face_ids: list[int],
|
||
end_face_ids: Iterable[int],
|
||
info: dict[str, object],
|
||
) -> dict[str, object]:
|
||
guess = str(info.get("feature_guess", "cylindrical face"))
|
||
angular_span = float(info.get("angular_span", 0.0))
|
||
if guess != "hole/groove candidate" or angular_span >= math.tau * 0.92:
|
||
return {}
|
||
|
||
radius = max(float(info.get("radius", 0.0)), 0.0)
|
||
span = min(max(angular_span, 0.0), math.tau)
|
||
boundary_face_ids = sorted(set(adjacent_face_ids) - set(end_face_ids))
|
||
chord_width = 2.0 * radius * math.sin(span / 2.0) if radius > 0 else 0.0
|
||
sagitta_depth = radius * (1.0 - math.cos(min(span, math.pi) / 2.0)) if radius > 0 else 0.0
|
||
return {
|
||
"slot_kind": "partial-cylindrical-groove",
|
||
"slot_status": "candidate",
|
||
"slot_angular_span": angular_span,
|
||
"slot_open_angle": max(math.tau - span, 0.0),
|
||
"slot_chord_width_estimate": chord_width,
|
||
"slot_arc_length_estimate": radius * span,
|
||
"slot_sagitta_depth_estimate": sagitta_depth,
|
||
"feature_slot_face_ids": (face_id,),
|
||
"feature_slot_boundary_face_ids": tuple(boundary_face_ids),
|
||
"slot_note": (
|
||
"这是由局部圆柱面推断出的槽/半孔候选；宽度和深度是几何估算，"
|
||
"不是 CAD 历史里的参数。"
|
||
),
|
||
}
|
||
|
||
def _cylindrical_existing_fillet_info(
|
||
self,
|
||
face_id: int,
|
||
adjacent_face_ids: list[int],
|
||
end_face_ids: Iterable[int],
|
||
info: dict[str, object],
|
||
) -> dict[str, object]:
|
||
if str(info.get("feature_guess", "cylindrical face")) != "round/fillet candidate":
|
||
return {}
|
||
|
||
radius = max(float(info.get("radius", 0.0)), 0.0)
|
||
angular_span = min(max(float(info.get("angular_span", 0.0)), 0.0), math.tau)
|
||
support_face_ids = sorted(set(adjacent_face_ids) - set(end_face_ids))
|
||
return {
|
||
"existing_fillet_kind": "cylindrical-round-face",
|
||
"existing_fillet_status": "candidate",
|
||
"existing_fillet_radius_estimate": radius,
|
||
"existing_fillet_angular_span": angular_span,
|
||
"existing_fillet_arc_length_estimate": radius * angular_span,
|
||
"feature_existing_fillet_face_ids": (face_id,),
|
||
"feature_existing_fillet_support_face_ids": tuple(support_face_ids),
|
||
"existing_fillet_note": (
|
||
"这是由局部小半径圆柱面推断出的已有圆角/倒圆候选；"
|
||
"第一版可尝试使用 defeature + 重新倒圆修改半径；"
|
||
"复杂 blend 或支撑面不明确时可能失败并回滚。"
|
||
),
|
||
}
|
||
|
||
def _cylindrical_end_face_groups(
|
||
self,
|
||
face_id: int,
|
||
adjacent_face_ids: list[int],
|
||
info: dict[str, object],
|
||
) -> dict[str, object]:
|
||
axis_point_values = info.get("axis_point")
|
||
axis_values = info.get("axis")
|
||
v_range = info.get("v_range")
|
||
if not isinstance(axis_point_values, tuple) or not isinstance(axis_values, tuple) or not isinstance(v_range, tuple):
|
||
return {
|
||
"end_face_ids": [],
|
||
"start_end_face_ids": [],
|
||
"end_end_face_ids": [],
|
||
"bottom_face_ids": [],
|
||
"opening_face_ids": [],
|
||
"bottom_note": "缺少圆柱轴线或参数范围，无法判断端面/底面。",
|
||
}
|
||
|
||
axis_point = gp_Pnt(*axis_point_values)
|
||
axis_dir = gp_Dir(float(axis_values[0]), float(axis_values[1]), float(axis_values[2]))
|
||
v_min = min(float(v_range[0]), float(v_range[1]))
|
||
v_max = max(float(v_range[0]), float(v_range[1]))
|
||
span = max(v_max - v_min, 1e-9)
|
||
radius = float(info.get("radius", 0.0))
|
||
tolerance = max(span * 0.08, radius * 0.2, 0.05)
|
||
|
||
start_end_face_ids: list[int] = []
|
||
end_end_face_ids: list[int] = []
|
||
for adjacent_id in adjacent_face_ids:
|
||
match = self._axis_end_match_for_planar_face(
|
||
adjacent_id,
|
||
axis_point,
|
||
axis_dir,
|
||
v_min,
|
||
v_max,
|
||
tolerance,
|
||
radial_tolerance=None,
|
||
)
|
||
if match == "start":
|
||
start_end_face_ids.append(adjacent_id)
|
||
elif match == "end":
|
||
end_end_face_ids.append(adjacent_id)
|
||
|
||
if info.get("cylinder_end_type") == "blind" and (not start_end_face_ids or not end_end_face_ids):
|
||
scanned = self._axis_cap_face_candidates(
|
||
face_id,
|
||
axis_point,
|
||
axis_dir,
|
||
v_min,
|
||
v_max,
|
||
radius,
|
||
span,
|
||
set(adjacent_face_ids),
|
||
)
|
||
if not start_end_face_ids:
|
||
start_end_face_ids.extend(scanned["start"])
|
||
if not end_end_face_ids:
|
||
end_end_face_ids.extend(scanned["end"])
|
||
|
||
bottom_face_ids: list[int] = []
|
||
opening_face_ids: list[int] = []
|
||
if info.get("start_end_open") is True:
|
||
opening_face_ids.extend(start_end_face_ids)
|
||
elif info.get("start_end_state") == "inside":
|
||
bottom_face_ids.extend(start_end_face_ids)
|
||
if info.get("end_end_open") is True:
|
||
opening_face_ids.extend(end_end_face_ids)
|
||
elif info.get("end_end_state") == "inside":
|
||
bottom_face_ids.extend(end_end_face_ids)
|
||
|
||
end_face_ids = sorted({*start_end_face_ids, *end_end_face_ids})
|
||
bottom_face_ids = sorted(set(bottom_face_ids))
|
||
opening_face_ids = sorted(set(opening_face_ids))
|
||
bottom_detection = "axis-cap-scan" if any(
|
||
face_id not in adjacent_face_ids for face_id in bottom_face_ids
|
||
) else "adjacent-end-face"
|
||
bottom_confidence = "medium" if bottom_detection == "axis-cap-scan" else "high"
|
||
if not end_face_ids:
|
||
note = "没有在圆柱边界附近找到平面端面。"
|
||
elif bottom_face_ids:
|
||
if bottom_detection == "axis-cap-scan":
|
||
note = "已通过轴线端部采样和轴线附近圆盘面扫描标记疑似底面；这是几何推断，不是 CAD 历史孔深。"
|
||
else:
|
||
note = "已根据圆柱轴线端部 inside/outside 采样标记疑似底面；这是几何推断，不是 CAD 历史孔深。"
|
||
else:
|
||
note = "已找到端面候选，但端部采样显示这些端面更像开口附近的相邻面。"
|
||
return {
|
||
"end_face_ids": end_face_ids,
|
||
"start_end_face_ids": sorted(set(start_end_face_ids)),
|
||
"end_end_face_ids": sorted(set(end_end_face_ids)),
|
||
"bottom_face_ids": bottom_face_ids,
|
||
"opening_face_ids": opening_face_ids,
|
||
"bottom_confidence": bottom_confidence if bottom_face_ids else "none",
|
||
"bottom_detection": bottom_detection if bottom_face_ids else "none",
|
||
"bottom_note": note,
|
||
}
|
||
|
||
def _axis_end_match_for_planar_face(
|
||
self,
|
||
face_id: int,
|
||
axis_point: gp_Pnt,
|
||
axis_dir: gp_Dir,
|
||
v_min: float,
|
||
v_max: float,
|
||
tolerance: float,
|
||
radial_tolerance: float | None,
|
||
) -> str | None:
|
||
surf = BRepAdaptor_Surface(self.faces[face_id])
|
||
if surf.GetType() != GeomAbs_Plane:
|
||
return None
|
||
normal = surf.Plane().Axis().Direction()
|
||
if abs(_direction_dot(normal, axis_dir)) < 0.65:
|
||
return None
|
||
if radial_tolerance is not None:
|
||
center = _surface_center(self.faces[face_id])
|
||
if _point_axis_distance(axis_point, axis_dir, center) > radial_tolerance:
|
||
return None
|
||
parameters = _shape_axis_parameters(self.faces[face_id], axis_point, axis_dir)
|
||
if not parameters:
|
||
return None
|
||
start_distance = min(abs(parameter - v_min) for parameter in parameters)
|
||
end_distance = min(abs(parameter - v_max) for parameter in parameters)
|
||
if min(start_distance, end_distance) > tolerance:
|
||
return None
|
||
return "start" if start_distance <= end_distance else "end"
|
||
|
||
def _axis_cap_face_candidates(
|
||
self,
|
||
face_id: int,
|
||
axis_point: gp_Pnt,
|
||
axis_dir: gp_Dir,
|
||
v_min: float,
|
||
v_max: float,
|
||
radius: float,
|
||
span: float,
|
||
adjacent_face_ids: set[int],
|
||
) -> dict[str, list[int]]:
|
||
source_solid_id = self.face_solid_ids[face_id]
|
||
tolerance = max(span * 0.12, radius * 0.35, 0.08)
|
||
radial_tolerance = max(radius * 1.2, tolerance)
|
||
start: list[int] = []
|
||
end: list[int] = []
|
||
for candidate_id in range(len(self.faces)):
|
||
if candidate_id == face_id or candidate_id in adjacent_face_ids:
|
||
continue
|
||
if source_solid_id >= 0 and self.face_solid_ids[candidate_id] != source_solid_id:
|
||
continue
|
||
match = self._axis_end_match_for_planar_face(
|
||
candidate_id,
|
||
axis_point,
|
||
axis_dir,
|
||
v_min,
|
||
v_max,
|
||
tolerance,
|
||
radial_tolerance=radial_tolerance,
|
||
)
|
||
if match == "start":
|
||
start.append(candidate_id)
|
||
elif match == "end":
|
||
end.append(candidate_id)
|
||
return {"start": sorted(set(start)), "end": sorted(set(end))}
|
||
|
||
def _bottom_face_axis_parameter(
|
||
self,
|
||
bottom_face_ids: Iterable[int],
|
||
axis_point: gp_Pnt,
|
||
axis_dir: gp_Dir,
|
||
expected_parameter: float,
|
||
) -> float | None:
|
||
candidates: list[float] = []
|
||
for bottom_face_id in bottom_face_ids:
|
||
if bottom_face_id < 0 or bottom_face_id >= len(self.faces):
|
||
continue
|
||
parameters = _shape_axis_parameters(self.faces[bottom_face_id], axis_point, axis_dir)
|
||
if not parameters:
|
||
continue
|
||
candidates.append(sum(parameters) / len(parameters))
|
||
if not candidates:
|
||
return None
|
||
return min(candidates, key=lambda parameter: abs(parameter - expected_parameter))
|
||
|
||
def _face_boundary_edge_ids(self, face_id: int) -> list[int]:
|
||
if face_id in self._face_edge_ids_cache:
|
||
return list(self._face_edge_ids_cache[face_id])
|
||
if face_id < 0 or face_id >= len(self.faces):
|
||
return []
|
||
face_edges = list(TopologyExplorer(self.faces[face_id], ignore_orientation=True).edges())
|
||
edge_ids: list[int] = []
|
||
for edge_id, edge in enumerate(self.edges):
|
||
if any(_same_shape(edge, face_edge) for face_edge in face_edges):
|
||
edge_ids.append(edge_id)
|
||
self._face_edge_ids_cache[face_id] = list(edge_ids)
|
||
return edge_ids
|
||
|
||
def face_boundary_edge_ids(self, face_id: int) -> list[int]:
|
||
if face_id < 0 or face_id >= len(self.faces):
|
||
return []
|
||
return self._face_boundary_edge_ids(face_id)
|
||
|
||
def nearest_edge_id_to_point(
|
||
self,
|
||
edge_ids: Iterable[int],
|
||
point: tuple[float, float, float] | None,
|
||
) -> int | None:
|
||
valid_edge_ids = [int(edge_id) for edge_id in edge_ids if 0 <= int(edge_id) < len(self.edges)]
|
||
if not valid_edge_ids:
|
||
return None
|
||
if point is None:
|
||
return valid_edge_ids[0]
|
||
|
||
px, py, pz = (float(point[0]), float(point[1]), float(point[2]))
|
||
best_edge_id: int | None = None
|
||
best_distance = math.inf
|
||
for edge_id in valid_edge_ids:
|
||
try:
|
||
samples = discretize_edge(self.edges[edge_id], 0.35)
|
||
except Exception:
|
||
samples = []
|
||
if len(samples) < 2:
|
||
try:
|
||
curve = BRepAdaptor_Curve(self.edges[edge_id])
|
||
samples = [
|
||
_point_tuple(curve.Value(curve.FirstParameter())),
|
||
_point_tuple(curve.Value(curve.LastParameter())),
|
||
]
|
||
except Exception:
|
||
samples = []
|
||
if not samples:
|
||
continue
|
||
sample_points = [(float(coords[0]), float(coords[1]), float(coords[2])) for coords in samples]
|
||
if len(sample_points) == 1:
|
||
distance = _point_distance_sq((px, py, pz), sample_points[0])
|
||
else:
|
||
distance = min(
|
||
_point_segment_distance_sq((px, py, pz), start, end)
|
||
for start, end in zip(sample_points, sample_points[1:])
|
||
)
|
||
if distance < best_distance:
|
||
best_distance = distance
|
||
best_edge_id = edge_id
|
||
return best_edge_id if best_edge_id is not None else valid_edge_ids[0]
|
||
|
||
def _adjacent_face_ids_for_edges(self, edge_ids: list[int], face_id: int) -> list[int]:
|
||
if not edge_ids:
|
||
return []
|
||
target_edges = [self.edges[edge_id] for edge_id in edge_ids if 0 <= edge_id < len(self.edges)]
|
||
source_solid_id = self.face_solid_ids[face_id]
|
||
adjacent: list[int] = []
|
||
for candidate_id, candidate in enumerate(self.faces):
|
||
if candidate_id == face_id:
|
||
continue
|
||
if source_solid_id >= 0 and self.face_solid_ids[candidate_id] != source_solid_id:
|
||
continue
|
||
candidate_edges = TopologyExplorer(candidate, ignore_orientation=True).edges()
|
||
if any(_same_shape(candidate_edge, target_edge) for candidate_edge in candidate_edges for target_edge in target_edges):
|
||
adjacent.append(candidate_id)
|
||
return adjacent
|
||
|
||
def _connected_coplanar_planar_face_ids(self, face_id: int) -> list[int]:
|
||
if face_id < 0 or face_id >= len(self.faces):
|
||
return []
|
||
source_surf = BRepAdaptor_Surface(self.faces[face_id])
|
||
if source_surf.GetType() != GeomAbs_Plane:
|
||
return [face_id]
|
||
|
||
source_solid_id = self.face_solid_ids[face_id]
|
||
tolerance = min(max(_shape_diagonal(self.shape) * 1e-7, 1e-6), 1e-3)
|
||
visited = {face_id}
|
||
queue = [face_id]
|
||
while queue:
|
||
current_id = queue.pop(0)
|
||
for adjacent_id in self._adjacent_face_ids_for_edges(self._face_boundary_edge_ids(current_id), current_id):
|
||
if adjacent_id in visited:
|
||
continue
|
||
if source_solid_id >= 0 and self.face_solid_ids[adjacent_id] != source_solid_id:
|
||
continue
|
||
candidate_surf = BRepAdaptor_Surface(self.faces[adjacent_id])
|
||
if _surfaces_are_coplanar(source_surf, candidate_surf, tolerance):
|
||
visited.add(adjacent_id)
|
||
queue.append(adjacent_id)
|
||
return sorted(visited)
|
||
|
||
def _region_boundary_edge_ids(self, face_ids: Iterable[int]) -> list[int]:
|
||
counts: dict[int, int] = {}
|
||
for face_id in face_ids:
|
||
for edge_id in self._face_boundary_edge_ids(face_id):
|
||
counts[edge_id] = counts.get(edge_id, 0) + 1
|
||
return sorted(edge_id for edge_id, count in counts.items() if count == 1)
|
||
|
||
def _push_pull_profile_shape(self, face_ids: Iterable[int]) -> TopoDS_Shape:
|
||
profile_faces = [self.faces[face_id] for face_id in face_ids if 0 <= face_id < len(self.faces)]
|
||
if not profile_faces:
|
||
raise ValueError("No planar faces were found for push/pull.")
|
||
return _unify_same_domain_shape(_compound_from_shapes(profile_faces))
|
||
|
||
def edge_info(self, edge_id: int) -> dict[str, object]:
|
||
if edge_id in self._edge_info_cache:
|
||
return dict(self._edge_info_cache[edge_id])
|
||
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],
|
||
"solid_id": self._edge_solid_id(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
|
||
adjacent_face_ids = self._edge_adjacent_face_ids(edge_id)
|
||
info["adjacent_face_ids"] = tuple(adjacent_face_ids)
|
||
info["adjacent_face_count"] = len(adjacent_face_ids)
|
||
self._edge_info_cache[edge_id] = dict(info)
|
||
return dict(info)
|
||
|
||
def _edge_solid_id(self, edge_id: int) -> int:
|
||
if edge_id < 0 or edge_id >= len(self.edges):
|
||
return -1
|
||
return self.edge_solid_ids[edge_id] if edge_id < len(self.edge_solid_ids) else -1
|
||
|
||
def edge_ids_for_solid(self, solid_id: int) -> list[int]:
|
||
if solid_id < 0 or solid_id >= len(self.solids):
|
||
raise ValueError(f"Unknown solid id {solid_id}")
|
||
return [edge_id for edge_id in range(len(self.edges)) if self._edge_solid_id(edge_id) == solid_id]
|
||
|
||
def _edge_adjacent_face_ids(self, edge_id: int) -> list[int]:
|
||
if edge_id < 0 or edge_id >= len(self.edges):
|
||
return []
|
||
if edge_id in self._edge_face_ids_cache:
|
||
return list(self._edge_face_ids_cache[edge_id])
|
||
edge = self.edges[edge_id]
|
||
part_id = self.edge_part_ids[edge_id]
|
||
solid_id = self._edge_solid_id(edge_id)
|
||
adjacent: list[int] = []
|
||
for face_id, face in enumerate(self.faces):
|
||
if self.face_part_ids[face_id] != part_id:
|
||
continue
|
||
if solid_id >= 0 and self.face_solid_ids[face_id] != solid_id:
|
||
continue
|
||
if any(_same_shape(candidate, edge) for candidate in TopologyExplorer(face, ignore_orientation=True).edges()):
|
||
adjacent.append(face_id)
|
||
return adjacent
|
||
|
||
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 // 5)
|
||
candidates: list[dict[str, object]] = []
|
||
|
||
diameter_count = 0
|
||
boss_diameter_count = 0
|
||
depth_count = 0
|
||
suppress_count = 0
|
||
existing_fillet_count = 0
|
||
depth_limit = max(2, min(per_type_limit, limit // 12))
|
||
suppress_limit = max(2, min(per_type_limit, limit // 12))
|
||
existing_fillet_limit = max(2, min(per_type_limit, limit // 12))
|
||
cylinder_scan_limit = max(per_type_limit * 4, 24)
|
||
for item in self.cylindrical_feature_candidates(
|
||
limit=cylinder_scan_limit,
|
||
include_end_info=True,
|
||
progress_callback=progress_callback,
|
||
):
|
||
feature_guess = str(item["feature_guess"])
|
||
if existing_fillet_count < existing_fillet_limit and feature_guess == "round/fillet candidate":
|
||
feature = self.feature_info(int(item["face_id"]))
|
||
support_face_ids = tuple(feature.get("feature_existing_fillet_support_face_ids", ()))
|
||
support_note = (
|
||
f"支撑 Face: {support_face_ids}。"
|
||
if support_face_ids
|
||
else "暂未识别出稳定支撑 Face。"
|
||
)
|
||
candidates.append(
|
||
{
|
||
"operation_key": "inspect_existing_fillet",
|
||
"operation": "修改已有圆角半径",
|
||
"target_kind": "face",
|
||
"target_id": item["face_id"],
|
||
"face_id": item["face_id"],
|
||
"part_id": item["part_id"],
|
||
"solid_id": item["solid_id"],
|
||
"surface": "cylinder",
|
||
"feature_guess": feature_guess,
|
||
"current_value": feature.get("existing_fillet_radius_estimate", item["radius"]),
|
||
"current_value_label": "radius",
|
||
"status": "caution",
|
||
"risk": "medium" if len(support_face_ids) >= 2 else "high",
|
||
"confidence": item["confidence"],
|
||
"note": (
|
||
"这是已有圆角/倒圆候选；点击后会选中并预填目标半径，"
|
||
"再点击“修改已有圆角半径”会尝试 defeature 后重新倒圆。"
|
||
f" {support_note}"
|
||
),
|
||
}
|
||
)
|
||
existing_fillet_count += 1
|
||
|
||
if diameter_count < per_type_limit and feature_guess != "round/fillet candidate":
|
||
candidates.append(
|
||
{
|
||
"operation_key": "resize_cylinder",
|
||
"operation": "调整圆柱孔径",
|
||
"target_kind": "face",
|
||
"target_id": item["face_id"],
|
||
"face_id": item["face_id"],
|
||
"part_id": item["part_id"],
|
||
"solid_id": item["solid_id"],
|
||
"surface": "cylinder",
|
||
"feature_guess": 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"],
|
||
}
|
||
)
|
||
diameter_count += 1
|
||
boss_info = _cylinder_boss_resize_readiness(item)
|
||
if boss_diameter_count < per_type_limit and boss_info["boss_resize_status"] != "blocked":
|
||
candidates.append(
|
||
{
|
||
"operation_key": "resize_boss",
|
||
"operation": "调整圆柱凸台直径",
|
||
"target_kind": "face",
|
||
"target_id": item["face_id"],
|
||
"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": boss_info["boss_resize_status"],
|
||
"risk": boss_info["boss_resize_risk"],
|
||
"confidence": item["confidence"],
|
||
"note": boss_info["boss_resize_note"],
|
||
}
|
||
)
|
||
boss_diameter_count += 1
|
||
suppress_info = _cylinder_suppress_readiness(item)
|
||
if suppress_count < suppress_limit and suppress_info["suppress_status"] != "blocked":
|
||
candidates.append(
|
||
{
|
||
"operation_key": "suppress_cylinder",
|
||
"operation": "封堵圆柱孔",
|
||
"target_kind": "face",
|
||
"target_id": item["face_id"],
|
||
"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": suppress_info["suppress_status"],
|
||
"risk": suppress_info["suppress_risk"],
|
||
"confidence": item["confidence"],
|
||
"note": suppress_info["suppress_note"],
|
||
}
|
||
)
|
||
suppress_count += 1
|
||
depth_info = _cylinder_depth_readiness(item)
|
||
if depth_count < depth_limit and depth_info["depth_status"] != "blocked":
|
||
feature = self.feature_info(int(item["face_id"]))
|
||
bottom_face_ids = tuple(feature.get("feature_bottom_face_ids", ()))
|
||
if not bottom_face_ids:
|
||
continue
|
||
depth_context = self._blind_cylindrical_depth_context(
|
||
int(item["face_id"]),
|
||
item,
|
||
feature,
|
||
float(item["hole_depth_estimate"]),
|
||
)
|
||
current_depth = float(depth_context.get("depth_current_depth", item["hole_depth_estimate"]))
|
||
candidates.append(
|
||
{
|
||
"operation_key": "resize_depth",
|
||
"operation": "调整盲孔深度",
|
||
"target_kind": "face",
|
||
"target_id": item["face_id"],
|
||
"face_id": item["face_id"],
|
||
"part_id": item["part_id"],
|
||
"solid_id": item["solid_id"],
|
||
"surface": "cylinder",
|
||
"feature_guess": item["feature_guess"],
|
||
"current_value": current_depth,
|
||
"current_value_label": "depth",
|
||
"status": depth_info["depth_status"],
|
||
"risk": depth_info["depth_risk"],
|
||
"confidence": item["confidence"],
|
||
"note": (
|
||
f"{depth_info['depth_note']} "
|
||
f"底面: {bottom_face_ids}; "
|
||
f"来源: {feature.get('feature_bottom_detection')}; "
|
||
f"深度来源: {depth_context.get('depth_current_depth_source', 'cylinder-v-range')}。"
|
||
),
|
||
}
|
||
)
|
||
depth_count += 1
|
||
if (
|
||
diameter_count >= per_type_limit
|
||
and boss_diameter_count >= per_type_limit
|
||
and suppress_count >= suppress_limit
|
||
and depth_count >= depth_limit
|
||
and existing_fillet_count >= existing_fillet_limit
|
||
):
|
||
break
|
||
|
||
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": "推拉平面",
|
||
"target_kind": "face",
|
||
"target_id": face_id,
|
||
"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
|
||
|
||
fillet_edge_count = 0
|
||
chamfer_edge_count = 0
|
||
edge_length_count = 0
|
||
edge_type_limit = max(1, per_type_limit // 3)
|
||
for edge_id, edge in enumerate(self.edges):
|
||
if progress_callback is not None and edge_id % 80 == 0:
|
||
progress_callback()
|
||
if (
|
||
fillet_edge_count >= edge_type_limit
|
||
and chamfer_edge_count >= edge_type_limit
|
||
and edge_length_count >= edge_type_limit
|
||
):
|
||
break
|
||
curve = BRepAdaptor_Curve(edge)
|
||
if curve.GetType() != GeomAbs_Line:
|
||
continue
|
||
props = GProp_GProps()
|
||
brepgprop.LinearProperties(edge, props)
|
||
length = props.Mass()
|
||
if length <= 1e-9:
|
||
continue
|
||
solid_id = self._edge_solid_id(edge_id)
|
||
if fillet_edge_count < edge_type_limit:
|
||
candidates.append(
|
||
{
|
||
"operation_key": "fillet_edge",
|
||
"operation": "给边添加圆角",
|
||
"target_kind": "edge",
|
||
"target_id": edge_id,
|
||
"edge_id": edge_id,
|
||
"part_id": self.edge_part_ids[edge_id],
|
||
"solid_id": solid_id,
|
||
"surface": "edge",
|
||
"feature_guess": "linear edge fillet candidate",
|
||
"current_value": length,
|
||
"current_value_label": "length",
|
||
"status": "caution",
|
||
"risk": "medium",
|
||
"confidence": "pending",
|
||
"note": "快速扫描：添加圆角半径会在执行前根据边长和相邻面再详细判断。",
|
||
}
|
||
)
|
||
fillet_edge_count += 1
|
||
if chamfer_edge_count < edge_type_limit:
|
||
candidates.append(
|
||
{
|
||
"operation_key": "chamfer_edge",
|
||
"operation": "给边添加倒角",
|
||
"target_kind": "edge",
|
||
"target_id": edge_id,
|
||
"edge_id": edge_id,
|
||
"part_id": self.edge_part_ids[edge_id],
|
||
"solid_id": solid_id,
|
||
"surface": "edge",
|
||
"feature_guess": "linear edge chamfer candidate",
|
||
"current_value": length,
|
||
"current_value_label": "length",
|
||
"status": "caution",
|
||
"risk": "medium",
|
||
"confidence": "pending",
|
||
"note": "快速扫描：倒角距离会在执行前根据边长和相邻面再详细判断。",
|
||
}
|
||
)
|
||
chamfer_edge_count += 1
|
||
if edge_length_count < edge_type_limit:
|
||
candidates.append(
|
||
{
|
||
"operation_key": "resize_edge_length",
|
||
"operation": "调整直线边长度",
|
||
"target_kind": "edge",
|
||
"target_id": edge_id,
|
||
"edge_id": edge_id,
|
||
"part_id": self.edge_part_ids[edge_id],
|
||
"solid_id": solid_id,
|
||
"surface": "edge",
|
||
"feature_guess": "linear edge length candidate",
|
||
"current_value": length,
|
||
"current_value_label": "length",
|
||
"status": "caution",
|
||
"risk": "medium",
|
||
"confidence": "pending",
|
||
"note": "快速扫描：第一版边长调整会在执行前尝试寻找可推拉的端面，找不到端面会阻止。",
|
||
}
|
||
)
|
||
edge_length_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,
|
||
"resize_boss": 1,
|
||
"suppress_cylinder": 2,
|
||
"resize_depth": 3,
|
||
"inspect_existing_fillet": 4,
|
||
"push_pull_plane": 5,
|
||
"fillet_edge": 6,
|
||
"chamfer_edge": 7,
|
||
"resize_edge_length": 8,
|
||
}
|
||
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.get("target_id", item.get("face_id", item.get("edge_id", -1)))),
|
||
)
|
||
)
|
||
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))
|
||
candidate.update(_cylinder_boss_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)
|
||
delta_diameter = new_diameter - current_diameter
|
||
diameter_delta_ratio = abs(delta_diameter) / max(current_diameter, 1e-9)
|
||
height_estimate = float(info.get("height_estimate", 0.0))
|
||
target_to_height_ratio = new_diameter / height_estimate if height_estimate > 1e-9 else ""
|
||
feature = self.feature_info(face_id)
|
||
cutter_plan = self._bounded_cylinder_cutter_plan(face_id, new_diameter, feature)
|
||
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": delta_diameter,
|
||
"diameter_delta_ratio": diameter_delta_ratio,
|
||
"target_to_height_ratio": target_to_height_ratio,
|
||
"resize_mode": resize_mode,
|
||
"feature_type": feature.get("feature_type"),
|
||
"feature_bottom_face_ids": feature.get("feature_bottom_face_ids"),
|
||
"feature_opening_face_ids": feature.get("feature_opening_face_ids"),
|
||
"feature_bottom_note": feature.get("feature_bottom_note"),
|
||
"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 cylindrical_boss_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_boss_resize_readiness(info, new_diameter)
|
||
resize_mode = _resize_mode(current_diameter, new_diameter)
|
||
delta_diameter = new_diameter - current_diameter
|
||
diameter_delta_ratio = abs(delta_diameter) / max(current_diameter, 1e-9)
|
||
height_estimate = float(info.get("height_estimate", 0.0))
|
||
target_to_height_ratio = new_diameter / height_estimate if height_estimate > 1e-9 else ""
|
||
feature = self.feature_info(face_id)
|
||
tool_plan = self._bounded_boss_resize_tool_plan(face_id, new_diameter)
|
||
return {
|
||
"status": readiness["boss_resize_status"],
|
||
"risk": readiness["boss_resize_risk"],
|
||
"message": readiness["boss_resize_note"],
|
||
"warnings": readiness["boss_resize_warnings"],
|
||
"blockers": readiness["boss_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": delta_diameter,
|
||
"diameter_delta_ratio": diameter_delta_ratio,
|
||
"target_to_height_ratio": target_to_height_ratio,
|
||
"resize_mode": resize_mode,
|
||
"feature_type": feature.get("feature_type"),
|
||
"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"),
|
||
"feature_adjacent_face_ids": feature.get("feature_adjacent_face_ids"),
|
||
"feature_boundary_edge_ids": feature.get("feature_boundary_edge_ids"),
|
||
**tool_plan,
|
||
}
|
||
|
||
def cylindrical_suppress_plan(self, face_id: int) -> 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 不是圆柱面，不能封堵圆柱孔。",
|
||
}
|
||
readiness = _cylinder_suppress_readiness(info)
|
||
feature = self.feature_info(face_id)
|
||
fill_plan = self._bounded_cylinder_fill_plan(face_id)
|
||
return {
|
||
"status": readiness["suppress_status"],
|
||
"risk": readiness["suppress_risk"],
|
||
"message": readiness["suppress_note"],
|
||
"warnings": readiness["suppress_warnings"],
|
||
"blockers": readiness["suppress_blockers"],
|
||
"face_id": face_id,
|
||
"part_id": info["part_id"],
|
||
"solid_id": info["solid_id"],
|
||
"diameter": info.get("diameter"),
|
||
"radius": info.get("radius"),
|
||
"angular_span": info.get("angular_span"),
|
||
"height_estimate": info.get("height_estimate"),
|
||
"feature_type": feature.get("feature_type"),
|
||
"feature_guess": info.get("feature_guess"),
|
||
"confidence": info.get("confidence"),
|
||
"material_vote_summary": info.get("material_vote_summary"),
|
||
"cylinder_end_type": info.get("cylinder_end_type"),
|
||
"feature_bottom_face_ids": feature.get("feature_bottom_face_ids"),
|
||
"feature_opening_face_ids": feature.get("feature_opening_face_ids"),
|
||
"feature_bottom_note": feature.get("feature_bottom_note"),
|
||
**fill_plan,
|
||
}
|
||
|
||
def cylindrical_depth_plan(self, face_id: int, target_depth: 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 不是圆柱面，不能调整盲孔深度。",
|
||
}
|
||
|
||
feature = self.feature_info(face_id)
|
||
context = self._blind_cylindrical_depth_context(face_id, info, feature, target_depth)
|
||
depth_info = dict(info)
|
||
if context.get("context_status") == "ready" and isinstance(context.get("depth_current_depth"), (int, float)):
|
||
depth_info["hole_depth_estimate"] = float(context["depth_current_depth"])
|
||
readiness = _cylinder_depth_readiness(depth_info, target_depth)
|
||
if context.get("context_status") == "blocked":
|
||
readiness = dict(readiness)
|
||
readiness["depth_status"] = "blocked"
|
||
readiness["depth_risk"] = "blocked"
|
||
readiness["depth_blockers"] = _join_nonempty(
|
||
readiness.get("depth_blockers"),
|
||
context.get("context_message"),
|
||
)
|
||
readiness["depth_note"] = readiness["depth_blockers"]
|
||
|
||
current_depth = float(depth_info.get("hole_depth_estimate", 0.0))
|
||
delta_depth = target_depth - current_depth
|
||
depth_delta_ratio = abs(delta_depth) / max(current_depth, 1e-9)
|
||
plan = {
|
||
"status": readiness["depth_status"],
|
||
"risk": readiness["depth_risk"],
|
||
"message": readiness["depth_note"],
|
||
"warnings": readiness["depth_warnings"],
|
||
"blockers": readiness["depth_blockers"],
|
||
"face_id": face_id,
|
||
"part_id": info["part_id"],
|
||
"solid_id": info["solid_id"],
|
||
"current_depth": current_depth,
|
||
"target_depth": target_depth,
|
||
"delta_depth": delta_depth,
|
||
"depth_delta_ratio": depth_delta_ratio,
|
||
"depth_mode": "deepen" if delta_depth > 0 else "shallow",
|
||
"diameter": info.get("diameter"),
|
||
"radius": info.get("radius"),
|
||
"feature_type": feature.get("feature_type"),
|
||
"feature_guess": info.get("feature_guess"),
|
||
"confidence": info.get("confidence"),
|
||
"angular_span": info.get("angular_span"),
|
||
"material_vote_summary": info.get("material_vote_summary"),
|
||
"cylinder_end_type": info.get("cylinder_end_type"),
|
||
"start_end_state": info.get("start_end_state"),
|
||
"end_end_state": info.get("end_end_state"),
|
||
"feature_bottom_face_ids": feature.get("feature_bottom_face_ids"),
|
||
"feature_opening_face_ids": feature.get("feature_opening_face_ids"),
|
||
"feature_bottom_confidence": feature.get("feature_bottom_confidence"),
|
||
"feature_bottom_detection": feature.get("feature_bottom_detection"),
|
||
"feature_bottom_note": feature.get("feature_bottom_note"),
|
||
}
|
||
plan.update(context)
|
||
return plan
|
||
|
||
def _blind_cylindrical_depth_context(
|
||
self,
|
||
face_id: int,
|
||
info: dict[str, object],
|
||
feature: dict[str, object],
|
||
target_depth: float,
|
||
) -> dict[str, object]:
|
||
face = self.faces[face_id]
|
||
surf = BRepAdaptor_Surface(face)
|
||
if surf.GetType() != GeomAbs_Cylinder:
|
||
return {
|
||
"context_status": "blocked",
|
||
"context_message": "当前选中的 face 不是圆柱面。",
|
||
}
|
||
|
||
bottom_face_ids = tuple(feature.get("feature_bottom_face_ids", ()))
|
||
if info.get("cylinder_end_type") != "blind" or not bottom_face_ids:
|
||
return {
|
||
"context_status": "blocked",
|
||
"context_message": "第一版孔深调整只支持已经识别出疑似底面的盲孔/盲槽。",
|
||
}
|
||
|
||
start_open = info.get("start_end_open") is True
|
||
end_open = info.get("end_end_open") is True
|
||
if start_open == end_open:
|
||
return {
|
||
"context_status": "blocked",
|
||
"context_message": "圆柱端部开口方向不唯一，不能可靠判断孔深方向。",
|
||
}
|
||
|
||
cyl = surf.Cylinder()
|
||
radius = float(cyl.Radius())
|
||
axis = cyl.Axis()
|
||
axis_point = axis.Location()
|
||
axis_dir = axis.Direction()
|
||
v_min = min(float(surf.FirstVParameter()), float(surf.LastVParameter()))
|
||
v_max = max(float(surf.FirstVParameter()), float(surf.LastVParameter()))
|
||
if start_open:
|
||
open_parameter = v_min
|
||
nominal_bottom_parameter = v_max
|
||
direction_sign = 1.0
|
||
else:
|
||
open_parameter = v_max
|
||
nominal_bottom_parameter = v_min
|
||
direction_sign = -1.0
|
||
|
||
bottom_parameter = self._bottom_face_axis_parameter(
|
||
bottom_face_ids,
|
||
axis_point,
|
||
axis_dir,
|
||
nominal_bottom_parameter,
|
||
)
|
||
current_depth_source = "bottom-face-axis-parameter" if bottom_parameter is not None else "cylinder-v-range"
|
||
if bottom_parameter is None:
|
||
bottom_parameter = nominal_bottom_parameter
|
||
current_depth = max(abs(bottom_parameter - open_parameter), 1e-9)
|
||
|
||
target_bottom_parameter = open_parameter + direction_sign * target_depth
|
||
delta_depth = target_depth - current_depth
|
||
depth_mode = "deepen" if delta_depth > 0 else "shallow"
|
||
tool_direction = (
|
||
axis_dir.X() * direction_sign,
|
||
axis_dir.Y() * direction_sign,
|
||
axis_dir.Z() * direction_sign,
|
||
)
|
||
open_margin = min(max(radius * 0.05, abs(delta_depth) * 0.2, 0.02), max(current_depth * 0.1, 0.2))
|
||
bottom_overlap = min(max(radius * 0.02, abs(delta_depth) * 0.05, 0.01), max(current_depth * 0.03, 0.08))
|
||
|
||
if depth_mode == "deepen":
|
||
start_parameter = open_parameter - direction_sign * open_margin
|
||
end_parameter = target_bottom_parameter
|
||
tool_height = target_depth + open_margin
|
||
tool_role = "cutter"
|
||
tool_strategy = "bounded-blind-depth-cut"
|
||
tool_radius = radius
|
||
radius_overlap = 0.0
|
||
tool_note = "加深盲孔：沿识别出的开口到疑似底面方向，使用有限长度圆柱 cutter 延伸切削。"
|
||
else:
|
||
start_parameter = target_bottom_parameter
|
||
end_parameter = bottom_parameter + direction_sign * bottom_overlap
|
||
tool_height = current_depth - target_depth + bottom_overlap
|
||
tool_role = "fill"
|
||
tool_strategy = "bounded-bottom-fill"
|
||
radius_overlap = min(max(radius * 0.001, 0.001), 0.05)
|
||
tool_radius = radius + radius_overlap
|
||
tool_note = "变浅盲孔：从目标新底面到旧底面方向补料，并让补料半径略有重叠以便和原实体合并。"
|
||
|
||
return {
|
||
"context_status": "ready",
|
||
"depth_tool_strategy": tool_strategy,
|
||
"depth_tool_role": tool_role,
|
||
"depth_tool_note": tool_note,
|
||
"depth_axis_direction": tool_direction,
|
||
"depth_open_parameter": open_parameter,
|
||
"depth_bottom_parameter": bottom_parameter,
|
||
"depth_nominal_bottom_parameter": nominal_bottom_parameter,
|
||
"depth_bottom_parameter_source": current_depth_source,
|
||
"depth_current_depth": current_depth,
|
||
"depth_current_depth_source": current_depth_source,
|
||
"depth_target_bottom_parameter": target_bottom_parameter,
|
||
"depth_tool_start_parameter": start_parameter,
|
||
"depth_tool_end_parameter": end_parameter,
|
||
"depth_tool_height": max(tool_height, 1e-6),
|
||
"depth_tool_radius": tool_radius,
|
||
"depth_tool_radius_overlap": radius_overlap,
|
||
"depth_open_point": _point_tuple(_point_on_axis(axis_point, axis_dir, open_parameter)),
|
||
"depth_current_bottom_point": _point_tuple(_point_on_axis(axis_point, axis_dir, bottom_parameter)),
|
||
"depth_target_bottom_point": _point_tuple(_point_on_axis(axis_point, axis_dir, target_bottom_parameter)),
|
||
"depth_tool_start_point": _point_tuple(_point_on_axis(axis_point, axis_dir, start_parameter)),
|
||
}
|
||
|
||
def _bounded_cylinder_cutter_plan(
|
||
self,
|
||
face_id: int,
|
||
new_diameter: float,
|
||
feature: dict[str, object] | None = None,
|
||
) -> 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
|
||
feature = feature or self.feature_info(face_id)
|
||
bottom_face_ids = tuple(feature.get("feature_bottom_face_ids", ()))
|
||
opening_face_ids = tuple(feature.get("feature_opening_face_ids", ()))
|
||
bottom_protection = bool(bottom_face_ids)
|
||
if bottom_protection:
|
||
bottom_note = "检测到疑似盲孔底面，封闭端 cutter 只保留很小余量，避免明显加深孔。"
|
||
else:
|
||
bottom_note = "未检测到明确疑似底面，按端部开口/封闭采样设置 cutter 余量。"
|
||
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),
|
||
"cutter_bottom_protection": bottom_protection,
|
||
"cutter_protected_bottom_face_ids": bottom_face_ids,
|
||
"cutter_opening_face_ids": opening_face_ids,
|
||
"cutter_bottom_note": bottom_note,
|
||
**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 _bounded_boss_resize_tool_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 {
|
||
"boss_tool_strategy": "unavailable",
|
||
"boss_tool_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, 1e-6)
|
||
delta_radius = abs(new_radius - old_radius)
|
||
base_radius = max(old_radius, new_radius)
|
||
axial_margin = min(
|
||
max(base_radius * 0.001, delta_radius * 0.01, span * 0.001, 0.001),
|
||
max(span * 0.01, 0.02),
|
||
)
|
||
radial_overlap = min(max(old_radius * 0.001, 0.001), 0.05)
|
||
start_parameter = v_min - axial_margin
|
||
end_parameter = v_max + axial_margin
|
||
height = max(end_parameter - start_parameter, 1e-6)
|
||
axis = cyl.Axis()
|
||
direction = axis.Direction()
|
||
axis_point = axis.Location()
|
||
start = _point_on_axis(axis_point, direction, start_parameter)
|
||
resize_mode = _resize_mode(old_radius * 2.0, new_diameter)
|
||
return {
|
||
"boss_tool_strategy": "bounded-cylinder-fuse" if resize_mode == "enlarge" else "bounded-annular-cut",
|
||
"boss_tool_note": (
|
||
"扩大凸台会在选中圆柱面的 V 范围内生成目标半径圆柱并 Fuse；"
|
||
"缩小凸台会生成环形 cutter 并 Cut。第一版会给轴向两端保留少量重叠，"
|
||
"让布尔结果更容易和原实体合并。"
|
||
),
|
||
"boss_tool_start_parameter": start_parameter,
|
||
"boss_tool_end_parameter": end_parameter,
|
||
"boss_tool_height": height,
|
||
"boss_tool_axial_margin": axial_margin,
|
||
"boss_tool_radius": new_radius,
|
||
"boss_tool_old_radius": old_radius,
|
||
"boss_tool_outer_radius": old_radius + radial_overlap if resize_mode == "shrink" else new_radius,
|
||
"boss_tool_inner_radius": new_radius if resize_mode == "shrink" else "",
|
||
"boss_tool_radial_overlap": radial_overlap if resize_mode == "shrink" else "",
|
||
"boss_tool_axis_point": _point_tuple(axis_point),
|
||
"boss_tool_axis_direction": _dir_tuple(direction),
|
||
"boss_tool_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
|
||
is_fillet_radius = solid_diagonal > 0 and radius <= solid_diagonal * 0.12
|
||
is_quarter_roundish = 0.15 <= angular_span <= math.pi * 1.05
|
||
is_fillet_like_partial = (
|
||
is_partial_cylinder
|
||
and is_quarter_roundish
|
||
and is_fillet_radius
|
||
and boundary_edges >= 4
|
||
)
|
||
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 or is_fillet_like_partial):
|
||
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:
|
||
export_shape = _compound_from_shapes(
|
||
_prepare_shape_for_step_export(part.shape) for part in self.display_parts()
|
||
)
|
||
_write_step(export_shape, Path(filename))
|
||
|
||
def export_quality_info(self, scope: str, target_id: int | None = None) -> dict[str, object]:
|
||
if scope == "all":
|
||
return _shape_quality_info("当前完整模型", self.shape, expect_solid=False)
|
||
if scope == "part":
|
||
if target_id is None:
|
||
raise ValueError("Part id is required.")
|
||
part = self.part_by_id(target_id)
|
||
if part is None:
|
||
raise ValueError(f"Unknown part id {target_id}")
|
||
info = _shape_quality_info(f"零件 {part.id}: {part.name}", part.shape, expect_solid=True)
|
||
info["part_id"] = part.id
|
||
return info
|
||
if scope == "solid":
|
||
if target_id is None or target_id < 0 or target_id >= len(self.solids):
|
||
raise ValueError(f"Unknown solid id {target_id}")
|
||
part_id, solid = self.solids[target_id]
|
||
info = _shape_quality_info(f"Solid {target_id}", solid, expect_solid=True)
|
||
info["part_id"] = part_id
|
||
info["solid_id"] = target_id
|
||
return info
|
||
if scope == "face":
|
||
if target_id is None or target_id < 0 or target_id >= len(self.faces):
|
||
raise ValueError(f"Unknown face id {target_id}")
|
||
info = _shape_quality_info(f"Face {target_id}", self.faces[target_id], expect_solid=False)
|
||
info["part_id"] = self.face_part_ids[target_id]
|
||
info["solid_id"] = self.face_solid_ids[target_id]
|
||
info["face_id"] = target_id
|
||
return info
|
||
if scope == "edge":
|
||
if target_id is None or target_id < 0 or target_id >= len(self.edges):
|
||
raise ValueError(f"Unknown edge id {target_id}")
|
||
info = _shape_quality_info(f"Edge {target_id}", self.edges[target_id], expect_solid=False)
|
||
info["part_id"] = self.edge_part_ids[target_id]
|
||
info["solid_id"] = self._edge_solid_id(target_id)
|
||
info["edge_id"] = target_id
|
||
return info
|
||
if scope == "feature":
|
||
if target_id is None or target_id < 0 or target_id >= len(self.faces):
|
||
raise ValueError(f"Unknown feature source face id {target_id}")
|
||
feature = self.feature_info(target_id)
|
||
face_ids = _int_values(feature.get("feature_highlight_face_ids")) or [target_id]
|
||
shape = _compound_from_shapes(self.faces[face_id] for face_id in face_ids if 0 <= face_id < len(self.faces))
|
||
info = _shape_quality_info(f"Feature from face {target_id}", shape, expect_solid=False)
|
||
info["part_id"] = self.face_part_ids[target_id]
|
||
info["solid_id"] = self.face_solid_ids[target_id]
|
||
info["face_id"] = target_id
|
||
info["feature_face_ids"] = tuple(face_ids)
|
||
return info
|
||
raise ValueError(f"Unknown export quality scope: {scope}")
|
||
|
||
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(_prepare_shape_for_step_export(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(_prepare_shape_for_step_export(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 export_edge(self, edge_id: int, filename: str | Path) -> None:
|
||
if edge_id < 0 or edge_id >= len(self.edges):
|
||
raise ValueError(f"Unknown edge id {edge_id}")
|
||
_write_step(self.edges[edge_id], Path(filename))
|
||
|
||
def export_feature(self, face_id: int, filename: str | Path) -> None:
|
||
if face_id < 0 or face_id >= len(self.faces):
|
||
raise ValueError(f"Unknown feature source face id {face_id}")
|
||
feature = self.feature_info(face_id)
|
||
face_ids = _int_values(feature.get("feature_highlight_face_ids")) or [face_id]
|
||
shapes = [self.faces[item] for item in face_ids if 0 <= item < len(self.faces)]
|
||
if not shapes:
|
||
raise ValueError("Feature export did not find any valid faces.")
|
||
_write_step(_compound_from_shapes(shapes), Path(filename))
|
||
|
||
def translate_part_plan(self, part_id: int, vector: tuple[float, float, float]) -> dict[str, object]:
|
||
part = self.part_by_id(part_id)
|
||
if part is None:
|
||
raise ValueError(f"Unknown part id {part_id}")
|
||
readiness = _translation_readiness(vector, part.shape)
|
||
return {
|
||
"status": readiness["translate_status"],
|
||
"risk": readiness["translate_risk"],
|
||
"message": readiness["translate_note"],
|
||
"warnings": readiness["translate_warnings"],
|
||
"blockers": readiness["translate_blockers"],
|
||
"target_kind": "part",
|
||
"part_id": part.id,
|
||
"name": part.name,
|
||
"translation_vector": vector,
|
||
"translation_distance": _vector_length(vector),
|
||
"bbox_diagonal": _shape_diagonal(part.shape),
|
||
}
|
||
|
||
def translate_solid_plan(self, solid_id: int, vector: tuple[float, float, float]) -> 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]
|
||
readiness = _translation_readiness(vector, solid)
|
||
part = self.part_by_id(part_id)
|
||
part_solid_count = len(_explore(part.shape, TopAbs_SOLID)) if part is not None else 0
|
||
warnings = readiness["translate_warnings"]
|
||
risk = readiness["translate_risk"]
|
||
status = readiness["translate_status"]
|
||
if part_solid_count <= 1 and status != "blocked":
|
||
warnings = _join_nonempty(warnings, "当前 part 只有一个 solid，平移 solid 实际会移动整个 part shape。")
|
||
if risk == "low":
|
||
risk = "medium"
|
||
status = "caution"
|
||
return {
|
||
"status": status,
|
||
"risk": risk,
|
||
"message": _join_nonempty(readiness["translate_note"], warnings),
|
||
"warnings": warnings,
|
||
"blockers": readiness["translate_blockers"],
|
||
"target_kind": "solid",
|
||
"part_id": part_id,
|
||
"solid_id": solid_id,
|
||
"part_solid_count": part_solid_count,
|
||
"translation_vector": vector,
|
||
"translation_distance": _vector_length(vector),
|
||
"bbox_diagonal": _shape_diagonal(solid),
|
||
}
|
||
|
||
def translate_part(self, part_id: int, vector: tuple[float, float, float]) -> str:
|
||
plan = self.translate_part_plan(part_id, vector)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
part = self.part_by_id(part_id)
|
||
if part is None:
|
||
raise ValueError(f"Unknown part id {part_id}")
|
||
part.shape = _translated_shape_by_vector(part.shape, vector)
|
||
_ensure_valid_shape(part.shape)
|
||
self.refresh_topology()
|
||
return (
|
||
f"Part translated: part {part_id}, vector={_format_tuple(vector)}, "
|
||
f"distance={float(plan['translation_distance']):g}, risk={plan['risk']}."
|
||
)
|
||
|
||
def translate_solid(self, solid_id: int, vector: tuple[float, float, float]) -> str:
|
||
plan = self.translate_solid_plan(solid_id, vector)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
part_id, solid = self.solids[solid_id]
|
||
part = self.part_by_id(part_id)
|
||
if part is None:
|
||
raise ValueError(f"Unknown part id {part_id}")
|
||
|
||
part_solids = _explore(part.shape, TopAbs_SOLID)
|
||
if len(part_solids) <= 1:
|
||
part.shape = _translated_shape_by_vector(part.shape, vector)
|
||
else:
|
||
translated = _translated_shape_by_vector(solid, vector)
|
||
replaced = False
|
||
shapes: list[TopoDS_Shape] = []
|
||
for item in part_solids:
|
||
if not replaced and _same_shape(item, solid):
|
||
shapes.append(translated)
|
||
replaced = True
|
||
else:
|
||
shapes.append(item)
|
||
if not replaced:
|
||
raise RuntimeError(f"Could not locate solid {solid_id} inside part {part_id}.")
|
||
part.shape = _compound_from_shapes(shapes)
|
||
|
||
_ensure_valid_shape(part.shape)
|
||
self.refresh_topology()
|
||
return (
|
||
f"Solid translated: solid {solid_id}, part {part_id}, vector={_format_tuple(vector)}, "
|
||
f"distance={float(plan['translation_distance']):g}, risk={plan['risk']}."
|
||
)
|
||
|
||
def rotate_part_plan(self, part_id: int, axis: str, angle_degrees: float) -> dict[str, object]:
|
||
part = self.part_by_id(part_id)
|
||
if part is None:
|
||
raise ValueError(f"Unknown part id {part_id}")
|
||
readiness = _rotation_readiness(axis, angle_degrees)
|
||
return {
|
||
"status": readiness["rotate_status"],
|
||
"risk": readiness["rotate_risk"],
|
||
"message": readiness["rotate_note"],
|
||
"warnings": readiness["rotate_warnings"],
|
||
"blockers": readiness["rotate_blockers"],
|
||
"target_kind": "part",
|
||
"part_id": part.id,
|
||
"name": part.name,
|
||
"rotation_axis": axis.upper(),
|
||
"rotation_angle_degrees": angle_degrees,
|
||
"rotation_center": _shape_center(part.shape),
|
||
"bbox_diagonal": _shape_diagonal(part.shape),
|
||
}
|
||
|
||
def rotate_solid_plan(self, solid_id: int, axis: str, angle_degrees: float) -> 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]
|
||
readiness = _rotation_readiness(axis, angle_degrees)
|
||
part = self.part_by_id(part_id)
|
||
part_solid_count = len(_explore(part.shape, TopAbs_SOLID)) if part is not None else 0
|
||
warnings = readiness["rotate_warnings"]
|
||
risk = readiness["rotate_risk"]
|
||
status = readiness["rotate_status"]
|
||
if part_solid_count <= 1 and status != "blocked":
|
||
warnings = _join_nonempty(warnings, "当前 part 只有一个 solid，旋转 solid 实际会旋转整个 part shape。")
|
||
if risk == "low":
|
||
risk = "medium"
|
||
status = "caution"
|
||
return {
|
||
"status": status,
|
||
"risk": risk,
|
||
"message": _join_nonempty(readiness["rotate_note"], warnings),
|
||
"warnings": warnings,
|
||
"blockers": readiness["rotate_blockers"],
|
||
"target_kind": "solid",
|
||
"part_id": part_id,
|
||
"solid_id": solid_id,
|
||
"part_solid_count": part_solid_count,
|
||
"rotation_axis": axis.upper(),
|
||
"rotation_angle_degrees": angle_degrees,
|
||
"rotation_center": _shape_center(solid),
|
||
"bbox_diagonal": _shape_diagonal(solid),
|
||
}
|
||
|
||
def rotate_part(self, part_id: int, axis: str, angle_degrees: float) -> str:
|
||
plan = self.rotate_part_plan(part_id, axis, angle_degrees)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
part = self.part_by_id(part_id)
|
||
if part is None:
|
||
raise ValueError(f"Unknown part id {part_id}")
|
||
part.shape = _rotated_shape(part.shape, str(plan["rotation_axis"]), float(plan["rotation_angle_degrees"]), plan["rotation_center"])
|
||
_ensure_valid_shape(part.shape)
|
||
self.refresh_topology()
|
||
return (
|
||
f"Part rotated: part {part_id}, axis={plan['rotation_axis']}, "
|
||
f"angle={float(plan['rotation_angle_degrees']):g}, center={_format_tuple(plan['rotation_center'])}, "
|
||
f"risk={plan['risk']}."
|
||
)
|
||
|
||
def rotate_solid(self, solid_id: int, axis: str, angle_degrees: float) -> str:
|
||
plan = self.rotate_solid_plan(solid_id, axis, angle_degrees)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
part_id, solid = self.solids[solid_id]
|
||
part = self.part_by_id(part_id)
|
||
if part is None:
|
||
raise ValueError(f"Unknown part id {part_id}")
|
||
|
||
part_solids = _explore(part.shape, TopAbs_SOLID)
|
||
if len(part_solids) <= 1:
|
||
part.shape = _rotated_shape(part.shape, str(plan["rotation_axis"]), float(plan["rotation_angle_degrees"]), plan["rotation_center"])
|
||
else:
|
||
rotated = _rotated_shape(solid, str(plan["rotation_axis"]), float(plan["rotation_angle_degrees"]), plan["rotation_center"])
|
||
replaced = False
|
||
shapes: list[TopoDS_Shape] = []
|
||
for item in part_solids:
|
||
if not replaced and _same_shape(item, solid):
|
||
shapes.append(rotated)
|
||
replaced = True
|
||
else:
|
||
shapes.append(item)
|
||
if not replaced:
|
||
raise RuntimeError(f"Could not locate solid {solid_id} inside part {part_id}.")
|
||
part.shape = _compound_from_shapes(shapes)
|
||
|
||
_ensure_valid_shape(part.shape)
|
||
self.refresh_topology()
|
||
return (
|
||
f"Solid rotated: solid {solid_id}, part {part_id}, axis={plan['rotation_axis']}, "
|
||
f"angle={float(plan['rotation_angle_degrees']):g}, center={_format_tuple(plan['rotation_center'])}, "
|
||
f"risk={plan['risk']}."
|
||
)
|
||
|
||
def edge_fillet_plan(self, edge_id: int, radius: float) -> dict[str, object]:
|
||
if edge_id < 0 or edge_id >= len(self.edges):
|
||
raise ValueError(f"Unknown edge id {edge_id}")
|
||
info = self.edge_info(edge_id)
|
||
readiness = _edge_fillet_readiness(info, radius)
|
||
part_id = int(info["part_id"])
|
||
part_stats = None
|
||
try:
|
||
part_stats = self.part_topology_stats(part_id)
|
||
except Exception:
|
||
part_stats = None
|
||
if part_stats is not None and part_stats.solids != 1:
|
||
readiness = dict(readiness)
|
||
if readiness["fillet_status"] != "blocked":
|
||
readiness["fillet_status"] = "caution"
|
||
readiness["fillet_risk"] = _max_risk(str(readiness["fillet_risk"]), "high")
|
||
readiness["fillet_warnings"] = _join_nonempty(
|
||
readiness["fillet_warnings"],
|
||
f"当前零件包含 {part_stats.solids} 个 solid，边倒圆会作用在整个 part shape 上，请导出前检查结果。",
|
||
)
|
||
readiness["fillet_note"] = _join_nonempty(readiness["fillet_note"], readiness["fillet_warnings"])
|
||
|
||
length = float(info.get("length", 0.0))
|
||
radius_to_length_ratio = radius / max(length, 1e-9)
|
||
return {
|
||
"status": readiness["fillet_status"],
|
||
"risk": readiness["fillet_risk"],
|
||
"message": readiness["fillet_note"],
|
||
"warnings": readiness["fillet_warnings"],
|
||
"blockers": readiness["fillet_blockers"],
|
||
"edge_id": edge_id,
|
||
"part_id": info["part_id"],
|
||
"solid_id": info.get("solid_id", -1),
|
||
"curve": info.get("curve"),
|
||
"edge_length": length,
|
||
"target_radius": radius,
|
||
"radius_to_length_ratio": radius_to_length_ratio,
|
||
"adjacent_face_ids": info.get("adjacent_face_ids", ()),
|
||
"adjacent_face_count": info.get("adjacent_face_count", 0),
|
||
"start_point": info.get("start_point"),
|
||
"end_point": info.get("end_point"),
|
||
"direction": info.get("direction"),
|
||
}
|
||
|
||
def edge_chamfer_plan(self, edge_id: int, distance: float) -> dict[str, object]:
|
||
if edge_id < 0 or edge_id >= len(self.edges):
|
||
raise ValueError(f"Unknown edge id {edge_id}")
|
||
info = self.edge_info(edge_id)
|
||
readiness = _edge_chamfer_readiness(info, distance)
|
||
part_id = int(info["part_id"])
|
||
part_stats = None
|
||
try:
|
||
part_stats = self.part_topology_stats(part_id)
|
||
except Exception:
|
||
part_stats = None
|
||
if part_stats is not None and part_stats.solids != 1:
|
||
readiness = dict(readiness)
|
||
if readiness["chamfer_status"] != "blocked":
|
||
readiness["chamfer_status"] = "caution"
|
||
readiness["chamfer_risk"] = _max_risk(str(readiness["chamfer_risk"]), "high")
|
||
readiness["chamfer_warnings"] = _join_nonempty(
|
||
readiness["chamfer_warnings"],
|
||
f"当前零件包含 {part_stats.solids} 个 solid，边倒角会作用在整个 part shape 上，请导出前检查结果。",
|
||
)
|
||
readiness["chamfer_note"] = _join_nonempty(readiness["chamfer_note"], readiness["chamfer_warnings"])
|
||
|
||
length = float(info.get("length", 0.0))
|
||
distance_to_length_ratio = distance / max(length, 1e-9)
|
||
return {
|
||
"status": readiness["chamfer_status"],
|
||
"risk": readiness["chamfer_risk"],
|
||
"message": readiness["chamfer_note"],
|
||
"warnings": readiness["chamfer_warnings"],
|
||
"blockers": readiness["chamfer_blockers"],
|
||
"edge_id": edge_id,
|
||
"part_id": info["part_id"],
|
||
"solid_id": info.get("solid_id", -1),
|
||
"curve": info.get("curve"),
|
||
"edge_length": length,
|
||
"target_distance": distance,
|
||
"distance_to_length_ratio": distance_to_length_ratio,
|
||
"adjacent_face_ids": info.get("adjacent_face_ids", ()),
|
||
"adjacent_face_count": info.get("adjacent_face_count", 0),
|
||
"start_point": info.get("start_point"),
|
||
"end_point": info.get("end_point"),
|
||
"direction": info.get("direction"),
|
||
}
|
||
|
||
def straight_edge_length_plan(self, edge_id: int, target_length: float) -> dict[str, object]:
|
||
if edge_id < 0 or edge_id >= len(self.edges):
|
||
raise ValueError(f"Unknown edge id {edge_id}")
|
||
info = self.edge_info(edge_id)
|
||
current_length = float(info.get("length", 0.0))
|
||
delta_length = float(target_length) - current_length
|
||
base: dict[str, object] = {
|
||
"edge_id": edge_id,
|
||
"part_id": info.get("part_id"),
|
||
"solid_id": info.get("solid_id", -1),
|
||
"curve": info.get("curve"),
|
||
"current_length": current_length,
|
||
"target_length": target_length,
|
||
"delta_length": delta_length,
|
||
"length_change_ratio": abs(delta_length) / max(current_length, 1e-9),
|
||
"start_point": info.get("start_point"),
|
||
"end_point": info.get("end_point"),
|
||
"direction": info.get("direction"),
|
||
"resize_strategy": "move-edge-end-plane-by-push-pull",
|
||
}
|
||
|
||
warnings: list[str] = [
|
||
"第一版边长调整是受限功能：只移动直线边端点附近的平面端面，不是通用参数化边长编辑。"
|
||
]
|
||
blockers: list[str] = []
|
||
risk = "low"
|
||
status = "ready"
|
||
|
||
if info.get("curve") != "line":
|
||
blockers.append("当前 edge 不是直线，第一版不能调整长度。")
|
||
if current_length <= 1e-9:
|
||
blockers.append("当前 edge 长度无效。")
|
||
if target_length <= 1e-9:
|
||
blockers.append("目标边长必须大于 0。")
|
||
if abs(delta_length) <= max(current_length * 1e-7, 1e-7):
|
||
blockers.append("目标边长与当前边长几乎相同，不需要修改。")
|
||
|
||
if not blockers:
|
||
ratio = abs(delta_length) / max(current_length, 1e-9)
|
||
if ratio > 0.5:
|
||
risk = _max_risk(risk, "high")
|
||
warnings.append("长度变化超过当前边长的 50%，布尔运算失败或形状异常的概率较高。")
|
||
elif ratio > 0.25:
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append("长度变化超过当前边长的 25%，请确认预览范围。")
|
||
|
||
candidate: dict[str, object] | None = None
|
||
if not blockers:
|
||
candidate = self._straight_edge_length_end_face_candidate(info, delta_length)
|
||
if candidate is None:
|
||
blockers.append("没有找到可用于改变这条直线边长度的平面端面。")
|
||
else:
|
||
base.update(candidate)
|
||
push_plan = self.push_pull_plan(int(candidate["end_face_id"]), float(candidate["push_pull_distance"]))
|
||
if push_plan["status"] == "blocked":
|
||
blockers.append(str(push_plan["message"]))
|
||
else:
|
||
risk = _max_risk(risk, str(push_plan["risk"]))
|
||
push_warnings = str(push_plan.get("warnings", ""))
|
||
if push_warnings:
|
||
warnings.append(push_warnings)
|
||
base.update(
|
||
{
|
||
"push_pull_status": push_plan.get("status"),
|
||
"push_pull_risk": push_plan.get("risk"),
|
||
"push_pull_message": push_plan.get("message"),
|
||
"push_pull_scope_face_ids": push_plan.get("push_pull_scope_face_ids", ()),
|
||
"push_pull_scope_face_count": push_plan.get("push_pull_scope_face_count", 1),
|
||
"push_pull_scope_note": push_plan.get("push_pull_scope_note", ""),
|
||
}
|
||
)
|
||
|
||
if blockers:
|
||
status = "blocked"
|
||
risk = "blocked"
|
||
message = " ".join(blockers)
|
||
elif risk != "low":
|
||
status = "caution"
|
||
message = " ".join(warnings)
|
||
else:
|
||
message = "可以尝试通过端面推拉调整这条直线边长度。"
|
||
|
||
base.update(
|
||
{
|
||
"status": status,
|
||
"risk": risk,
|
||
"message": message,
|
||
"warnings": "；".join(warnings),
|
||
"blockers": "；".join(blockers),
|
||
}
|
||
)
|
||
return base
|
||
|
||
def _straight_edge_length_end_face_candidate(
|
||
self,
|
||
edge_info: dict[str, object],
|
||
delta_length: float,
|
||
) -> dict[str, object] | None:
|
||
start = _tuple_or_none(edge_info.get("start_point"))
|
||
end = _tuple_or_none(edge_info.get("end_point"))
|
||
if start is None or end is None:
|
||
return None
|
||
axis = _tuple_normalized(_tuple_sub(end, start))
|
||
if axis is None:
|
||
return None
|
||
solid_id = int(edge_info.get("solid_id", -1))
|
||
if solid_id < 0 or solid_id >= len(self.solids):
|
||
return None
|
||
solid = self.solids[solid_id][1]
|
||
tolerance = max(_shape_diagonal(solid) * 1e-5, abs(delta_length) * 1e-5, 1e-4)
|
||
candidates: list[tuple[float, dict[str, object]]] = []
|
||
endpoint_specs = [
|
||
("起点端", start, _tuple_scale(axis, -delta_length)),
|
||
("终点端", end, _tuple_scale(axis, delta_length)),
|
||
]
|
||
|
||
for endpoint_label, endpoint, desired_vector in endpoint_specs:
|
||
desired_unit = _tuple_normalized(desired_vector)
|
||
if desired_unit is None:
|
||
continue
|
||
for face_id, face in enumerate(self.faces):
|
||
if self.face_solid_ids[face_id] != solid_id:
|
||
continue
|
||
surf = BRepAdaptor_Surface(face)
|
||
if surf.GetType() != GeomAbs_Plane:
|
||
continue
|
||
plane = surf.Plane()
|
||
plane_origin = _point_tuple(plane.Location())
|
||
plane_normal = _tuple_normalized(_dir_tuple(plane.Axis().Direction()))
|
||
if plane_normal is None:
|
||
continue
|
||
plane_distance = abs(_tuple_dot(_tuple_sub(endpoint, plane_origin), plane_normal))
|
||
if plane_distance > tolerance:
|
||
continue
|
||
axis_alignment = abs(_tuple_dot(plane_normal, axis))
|
||
if axis_alignment < 0.82:
|
||
continue
|
||
face_info = self.face_info(face_id)
|
||
outward = _tuple_normalized(_tuple_or_none(face_info.get("push_pull_outward_direction")))
|
||
if outward is None:
|
||
continue
|
||
movement_alignment = abs(_tuple_dot(outward, desired_unit))
|
||
if movement_alignment < 0.82:
|
||
continue
|
||
push_pull_distance = _tuple_dot(desired_vector, outward)
|
||
if abs(push_pull_distance) <= 1e-9:
|
||
continue
|
||
confidence_bonus = 0.0 if face_info.get("push_pull_confidence") == "high" else 0.2
|
||
score = plane_distance / max(tolerance, 1e-9) + (1.0 - movement_alignment) + confidence_bonus
|
||
candidates.append(
|
||
(
|
||
score,
|
||
{
|
||
"end_face_id": face_id,
|
||
"end_face_label": endpoint_label,
|
||
"end_face_plane_distance": plane_distance,
|
||
"end_face_axis_alignment": axis_alignment,
|
||
"end_face_movement_alignment": movement_alignment,
|
||
"end_face_outward_direction": outward,
|
||
"end_face_push_pull_confidence": face_info.get("push_pull_confidence", ""),
|
||
"push_pull_distance": push_pull_distance,
|
||
"desired_movement_vector": desired_vector,
|
||
},
|
||
)
|
||
)
|
||
if not candidates:
|
||
return None
|
||
candidates.sort(key=lambda item: item[0])
|
||
return candidates[0][1]
|
||
|
||
def existing_fillet_resize_plan(self, face_id: int, target_radius: 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 "radius" not in info:
|
||
return {
|
||
"status": "blocked",
|
||
"risk": "blocked",
|
||
"message": "当前选中的 face 不是圆柱圆角面，不能修改已有圆角半径。",
|
||
"blockers": "当前选中的 face 不是圆柱圆角面。",
|
||
"warnings": "",
|
||
"face_id": face_id,
|
||
}
|
||
|
||
feature = self.feature_info(face_id)
|
||
feature_guess = str(info.get("feature_guess", ""))
|
||
current_radius = float(feature.get("existing_fillet_radius_estimate", info["radius"]))
|
||
support_face_ids = tuple(feature.get("feature_existing_fillet_support_face_ids", ()))
|
||
warnings: list[str] = []
|
||
blockers: list[str] = []
|
||
risk = "medium"
|
||
status = "caution"
|
||
|
||
if feature_guess != "round/fillet candidate":
|
||
blockers.append("当前圆柱面没有被识别为已有圆角/倒圆候选。")
|
||
if target_radius <= 0:
|
||
blockers.append("目标圆角半径必须大于 0。")
|
||
if current_radius <= 0:
|
||
blockers.append("当前圆角半径估算无效。")
|
||
if current_radius > 0 and abs(target_radius - current_radius) <= max(current_radius * 1e-5, 1e-6):
|
||
blockers.append("目标圆角半径与当前估算半径几乎相同，不需要修改。")
|
||
if len(support_face_ids) < 2:
|
||
blockers.append("第一版只对识别到至少两个支撑 face 的已有圆角候选开放。")
|
||
|
||
part_id = int(info.get("part_id", -1))
|
||
part_stats = None
|
||
try:
|
||
part_stats = self.part_topology_stats(part_id)
|
||
except Exception:
|
||
part_stats = None
|
||
if part_stats is not None and part_stats.solids != 1:
|
||
blockers.append(
|
||
f"当前零件包含 {part_stats.solids} 个 solid；已有圆角半径修改第一版只对单 solid 零件开放。"
|
||
)
|
||
|
||
height_estimate = float(info.get("height_estimate", 0.0))
|
||
angular_span = float(info.get("angular_span", 0.0))
|
||
radius_delta = target_radius - current_radius
|
||
radius_delta_ratio = abs(radius_delta) / max(current_radius, 1e-9)
|
||
if not blockers:
|
||
if radius_delta_ratio > 1.0:
|
||
risk = "high"
|
||
warnings.append("目标半径变化超过当前半径的 100%，defeature/refillet 很可能失败。")
|
||
elif radius_delta_ratio > 0.35:
|
||
risk = _max_risk(risk, "high")
|
||
warnings.append("目标半径变化超过当前半径的 35%，请谨慎检查结果。")
|
||
if height_estimate > 0 and target_radius > height_estimate * 0.5:
|
||
risk = _max_risk(risk, "high")
|
||
warnings.append("目标半径超过圆角长度估算的一半，几何比例异常。")
|
||
if angular_span > math.pi * 1.25:
|
||
risk = _max_risk(risk, "high")
|
||
warnings.append("当前圆角圆弧跨度较大，可能不是普通边圆角。")
|
||
if str(info.get("confidence", "low")) != "high":
|
||
warnings.append("已有圆角识别置信度不是 high，执行结果需要重点检查。")
|
||
|
||
if blockers:
|
||
status = "blocked"
|
||
risk = "blocked"
|
||
message = " ".join(blockers + warnings)
|
||
else:
|
||
message = "将尝试先移除已有圆角面，再在恢复出的锐边上按目标半径重新倒圆。"
|
||
if warnings:
|
||
message += " " + " ".join(warnings)
|
||
|
||
return {
|
||
"status": status,
|
||
"risk": risk,
|
||
"message": message,
|
||
"warnings": "；".join(warnings),
|
||
"blockers": "；".join(blockers),
|
||
"face_id": face_id,
|
||
"part_id": info.get("part_id"),
|
||
"solid_id": info.get("solid_id"),
|
||
"feature_type": feature.get("feature_type"),
|
||
"feature_guess": feature_guess,
|
||
"confidence": info.get("confidence"),
|
||
"current_radius": current_radius,
|
||
"target_radius": target_radius,
|
||
"delta_radius": radius_delta,
|
||
"radius_delta_ratio": radius_delta_ratio,
|
||
"height_estimate": info.get("height_estimate"),
|
||
"angular_span": info.get("angular_span"),
|
||
"axis_point": info.get("axis_point"),
|
||
"axis": info.get("axis"),
|
||
"feature_existing_fillet_support_face_ids": support_face_ids,
|
||
"feature_boundary_edge_ids": feature.get("feature_boundary_edge_ids"),
|
||
"resize_strategy": "defeature-existing-fillet-face-then-refillet-axis-edge",
|
||
"resize_note": (
|
||
"第一版已有圆角半径修改只支持由圆柱面表示的直线边圆角。"
|
||
"执行后 face/edge ID 会重建，请重新选择对象确认结果。"
|
||
),
|
||
}
|
||
|
||
def push_pull_plan(self, face_id: int, distance: float) -> dict[str, object]:
|
||
if face_id < 0 or face_id >= len(self.faces):
|
||
raise ValueError(f"Unknown face id {face_id}")
|
||
face = self.faces[face_id]
|
||
surf = BRepAdaptor_Surface(face)
|
||
if surf.GetType() != GeomAbs_Plane:
|
||
return {
|
||
"status": "blocked",
|
||
"risk": "blocked",
|
||
"message": "当前选中的 face 不是平面，不能执行推拉平面。",
|
||
"blockers": "当前选中的 face 不是平面。",
|
||
"warnings": "",
|
||
"face_id": face_id,
|
||
"part_id": self.face_part_ids[face_id],
|
||
"solid_id": self.face_solid_ids[face_id],
|
||
"distance": distance,
|
||
}
|
||
|
||
info = self.face_info(face_id)
|
||
scope_face_ids = self._connected_coplanar_planar_face_ids(face_id)
|
||
if len(scope_face_ids) > 1:
|
||
scope_note = f"将一起推拉 {len(scope_face_ids)} 个共享边且共面的 face，减少 STEP 碎面导致的贴块缝。"
|
||
else:
|
||
scope_note = "只推拉当前 face。"
|
||
direction_confidence = str(info.get("push_pull_confidence", "low"))
|
||
bbox_diagonal = float(info.get("bbox_diagonal", 0.0))
|
||
distance_abs = abs(distance)
|
||
warnings: list[str] = []
|
||
blockers: list[str] = []
|
||
risk = "low"
|
||
status = "ready"
|
||
|
||
if distance_abs <= 1e-9:
|
||
status = "blocked"
|
||
risk = "blocked"
|
||
blockers.append("推拉距离为 0，不需要修改。")
|
||
if direction_confidence != "high":
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append("推拉方向判断置信度较低，可能不是期望的内外方向。")
|
||
if bbox_diagonal > 0 and distance_abs > bbox_diagonal * 0.2:
|
||
risk = _max_risk(risk, "high")
|
||
warnings.append("推拉距离超过当前 face 包围盒对角线的 20%，容易导致布尔失败或大范围变形。")
|
||
elif bbox_diagonal > 0 and distance_abs > bbox_diagonal * 0.08:
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append("推拉距离相对当前 face 尺寸偏大，请确认预览范围。")
|
||
|
||
if risk in {"medium", "high"} and status != "blocked":
|
||
status = "caution"
|
||
if blockers:
|
||
message = " ".join(blockers + warnings)
|
||
elif warnings:
|
||
message = " ".join(warnings)
|
||
else:
|
||
message = "可以尝试推拉该平面。"
|
||
|
||
return {
|
||
"status": status,
|
||
"risk": risk,
|
||
"message": message,
|
||
"warnings": "；".join(warnings),
|
||
"blockers": "；".join(blockers),
|
||
"face_id": face_id,
|
||
"part_id": info["part_id"],
|
||
"solid_id": info["solid_id"],
|
||
"distance": distance,
|
||
"surface": info.get("surface"),
|
||
"area": info.get("area"),
|
||
"bbox_diagonal": info.get("bbox_diagonal"),
|
||
"outward_direction": info.get("push_pull_outward_direction"),
|
||
"direction_confidence": direction_confidence,
|
||
"direction_note": info.get("push_pull_note"),
|
||
"push_pull_scope_face_ids": tuple(scope_face_ids),
|
||
"push_pull_scope_face_count": len(scope_face_ids),
|
||
"push_pull_scope_note": scope_note,
|
||
}
|
||
|
||
def cylindrical_resize_preview_polydata(
|
||
self,
|
||
face_id: int,
|
||
new_diameter: float,
|
||
deflection: float = 0.8,
|
||
) -> list[dict[str, object]]:
|
||
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("Cylinder resize preview currently supports cylindrical faces only.")
|
||
|
||
direction = surf.Cylinder().Axis().Direction()
|
||
previews: list[dict[str, object]] = []
|
||
|
||
if plan["resize_mode"] == "shrink" and "fill_start_point" in plan:
|
||
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()
|
||
BRepMesh_IncrementalMesh(filler, deflection)
|
||
previews.append(
|
||
{
|
||
"role": "fill",
|
||
"label": "补料预览",
|
||
"polydata": _shape_faces_polydata(filler),
|
||
}
|
||
)
|
||
|
||
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,
|
||
float(plan["cutter_radius"]),
|
||
float(plan["cutter_height"]),
|
||
).Shape()
|
||
BRepMesh_IncrementalMesh(cutter, deflection)
|
||
previews.append(
|
||
{
|
||
"role": "cutter",
|
||
"label": "切削预览",
|
||
"polydata": _shape_faces_polydata(cutter),
|
||
}
|
||
)
|
||
return previews
|
||
|
||
def cylindrical_boss_resize_preview_polydata(
|
||
self,
|
||
face_id: int,
|
||
new_diameter: float,
|
||
deflection: float = 0.8,
|
||
) -> list[dict[str, object]]:
|
||
plan = self.cylindrical_boss_resize_plan(face_id, new_diameter)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
|
||
start = gp_Pnt(*plan["boss_tool_start_point"])
|
||
direction = gp_Dir(*plan["boss_tool_axis_direction"])
|
||
axis = gp_Ax2(start, direction)
|
||
height = float(plan["boss_tool_height"])
|
||
if plan["resize_mode"] == "enlarge":
|
||
tool = BRepPrimAPI_MakeCylinder(axis, float(plan["boss_tool_radius"]), height).Shape()
|
||
BRepMesh_IncrementalMesh(tool, deflection)
|
||
return [
|
||
{
|
||
"role": "fill",
|
||
"label": "凸台扩大补料预览",
|
||
"polydata": _shape_faces_polydata(tool),
|
||
}
|
||
]
|
||
|
||
outer = BRepPrimAPI_MakeCylinder(axis, float(plan["boss_tool_outer_radius"]), height).Shape()
|
||
inner = BRepPrimAPI_MakeCylinder(axis, float(plan["boss_tool_inner_radius"]), height).Shape()
|
||
ring_cut = BRepAlgoAPI_Cut(outer, inner)
|
||
ring = _finalize_boolean_result(ring_cut, "boss annular cutter preview")
|
||
BRepMesh_IncrementalMesh(ring, deflection)
|
||
return [
|
||
{
|
||
"role": "cutter",
|
||
"label": "凸台缩小环形切削预览",
|
||
"polydata": _shape_faces_polydata(ring),
|
||
}
|
||
]
|
||
|
||
def cylindrical_suppress_preview_polydata(
|
||
self,
|
||
face_id: int,
|
||
deflection: float = 0.8,
|
||
) -> list[dict[str, object]]:
|
||
plan = self.cylindrical_suppress_plan(face_id)
|
||
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("Cylinder suppress preview currently supports cylindrical faces only.")
|
||
|
||
direction = surf.Cylinder().Axis().Direction()
|
||
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()
|
||
BRepMesh_IncrementalMesh(filler, deflection)
|
||
return [
|
||
{
|
||
"role": "fill",
|
||
"label": "封堵补料预览",
|
||
"polydata": _shape_faces_polydata(filler),
|
||
}
|
||
]
|
||
|
||
def cylindrical_depth_preview_polydata(
|
||
self,
|
||
face_id: int,
|
||
target_depth: float,
|
||
deflection: float = 0.8,
|
||
) -> list[dict[str, object]]:
|
||
plan = self.cylindrical_depth_plan(face_id, target_depth)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
|
||
start = gp_Pnt(*plan["depth_tool_start_point"])
|
||
direction = gp_Dir(*plan["depth_axis_direction"])
|
||
axis = gp_Ax2(start, direction)
|
||
tool = BRepPrimAPI_MakeCylinder(
|
||
axis,
|
||
float(plan["depth_tool_radius"]),
|
||
float(plan["depth_tool_height"]),
|
||
).Shape()
|
||
BRepMesh_IncrementalMesh(tool, deflection)
|
||
role = str(plan["depth_tool_role"])
|
||
return [
|
||
{
|
||
"role": role,
|
||
"label": "切削预览" if role == "cutter" else "补料预览",
|
||
"polydata": _shape_faces_polydata(tool),
|
||
}
|
||
]
|
||
|
||
def existing_fillet_resize_preview_polydata(
|
||
self,
|
||
face_id: int,
|
||
target_radius: float,
|
||
deflection: float = 0.8,
|
||
) -> list[dict[str, object]]:
|
||
plan = self.existing_fillet_resize_plan(face_id, target_radius)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
return [
|
||
{
|
||
"role": "remove",
|
||
"label": "将移除并重建的已有圆角面",
|
||
"polydata": self.build_face_polydata(face_ids=[face_id], deflection=deflection),
|
||
}
|
||
]
|
||
|
||
def push_pull_preview_polydata(self, face_id: int, distance: float, deflection: float = 0.8):
|
||
plan = self.push_pull_plan(face_id, distance)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
face = self.faces[face_id]
|
||
scope_face_ids = _int_values(plan.get("push_pull_scope_face_ids")) or [face_id]
|
||
profile_shape = self._push_pull_profile_shape(scope_face_ids)
|
||
surf = BRepAdaptor_Surface(face)
|
||
if surf.GetType() != GeomAbs_Plane:
|
||
raise ValueError("Push/pull preview currently supports planar faces only.")
|
||
|
||
outward = plan["outward_direction"]
|
||
vec = gp_Vec(
|
||
float(outward[0]) * distance,
|
||
float(outward[1]) * distance,
|
||
float(outward[2]) * distance,
|
||
)
|
||
preview_shape = BRepPrimAPI_MakePrism(profile_shape, vec).Shape()
|
||
BRepMesh_IncrementalMesh(preview_shape, deflection)
|
||
return _shape_faces_polydata(preview_shape)
|
||
|
||
def straight_edge_length_preview_polydata(self, edge_id: int, target_length: float, deflection: float = 0.8):
|
||
plan = self.straight_edge_length_plan(edge_id, target_length)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
return self.push_pull_preview_polydata(int(plan["end_face_id"]), float(plan["push_pull_distance"]), deflection)
|
||
|
||
def resize_straight_edge_length(self, edge_id: int, target_length: float) -> str:
|
||
plan = self.straight_edge_length_plan(edge_id, target_length)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
push_result = self.push_pull_face(int(plan["end_face_id"]), float(plan["push_pull_distance"]))
|
||
return (
|
||
"Straight edge length resize completed: "
|
||
f"edge {edge_id}, current_length={float(plan['current_length']):g}, "
|
||
f"target_length={float(plan['target_length']):g}, "
|
||
f"delta={float(plan['delta_length']):g}, "
|
||
f"end_face={int(plan['end_face_id'])}, "
|
||
f"push_pull_distance={float(plan['push_pull_distance']):g}, "
|
||
f"risk={plan['risk']}. {push_result}"
|
||
)
|
||
|
||
def push_pull_face(self, face_id: int, distance: float) -> str:
|
||
plan = self.push_pull_plan(face_id, distance)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
face = self.faces[face_id]
|
||
surf = BRepAdaptor_Surface(face)
|
||
if surf.GetType() != GeomAbs_Plane:
|
||
raise ValueError("Push/pull currently supports planar faces only.")
|
||
|
||
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}")
|
||
|
||
outward = plan["outward_direction"]
|
||
scope_face_ids = _int_values(plan.get("push_pull_scope_face_ids")) or [face_id]
|
||
profile_shape = self._push_pull_profile_shape(scope_face_ids)
|
||
overlap = _boolean_overlap_distance(part.shape, distance)
|
||
start_offset = -overlap if distance >= 0 else overlap
|
||
tool_distance = distance + overlap if distance >= 0 else distance - overlap
|
||
tool_face = _translated_shape(profile_shape, outward, start_offset)
|
||
vec = gp_Vec(
|
||
float(outward[0]) * tool_distance,
|
||
float(outward[1]) * tool_distance,
|
||
float(outward[2]) * tool_distance,
|
||
)
|
||
tool_shape = BRepPrimAPI_MakePrism(tool_face, vec).Shape()
|
||
op = BRepAlgoAPI_Fuse(part.shape, tool_shape) if distance >= 0 else BRepAlgoAPI_Cut(part.shape, tool_shape)
|
||
result = _finalize_boolean_result(op, "push/pull")
|
||
result = _cleanup_push_pull_result(result, part.shape, profile_shape, distance)
|
||
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"tool_overlap={overlap:g}, "
|
||
f"scope_faces={len(scope_face_ids)}, "
|
||
f"outward_direction={_format_tuple(outward)}, "
|
||
f"direction_confidence={plan['direction_confidence']}, "
|
||
f"risk={plan['risk']}."
|
||
)
|
||
|
||
def resize_existing_fillet(self, face_id: int, target_radius: float) -> str:
|
||
plan = self.existing_fillet_resize_plan(face_id, target_radius)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
|
||
part_id = int(plan["part_id"])
|
||
part = self.part_by_id(part_id)
|
||
if part is None:
|
||
raise ValueError(f"Unknown part id {part_id}")
|
||
|
||
source_face = topods.Face(self.faces[face_id])
|
||
defeatured = _defeature_faces(part.shape, [source_face])
|
||
axis_point = gp_Pnt(*plan["axis_point"])
|
||
axis_dir = gp_Dir(*plan["axis"])
|
||
root_edges = _axis_aligned_edge_candidates(
|
||
defeatured,
|
||
axis_point,
|
||
axis_dir,
|
||
expected_length=float(plan.get("height_estimate") or 0.0),
|
||
reference_radius=float(plan["current_radius"]),
|
||
)
|
||
if not root_edges:
|
||
raise RuntimeError(
|
||
"已尝试移除已有圆角面，但没有找到可重新倒圆的轴向锐边；"
|
||
"该圆角可能不是简单直线边圆角。"
|
||
)
|
||
|
||
result = None
|
||
failures: list[str] = []
|
||
for index, root_edge in enumerate(root_edges[:16], start=1):
|
||
try:
|
||
maker = BRepFilletAPI_MakeFillet(defeatured)
|
||
maker.Add(float(target_radius), topods.Edge(root_edge))
|
||
result = _finalize_builder_result(maker, f"existing fillet resize candidate {index}")
|
||
break
|
||
except Exception as exc:
|
||
failures.append(str(exc))
|
||
if result is None:
|
||
detail = failures[-1] if failures else "没有可用的候选边。"
|
||
raise RuntimeError(
|
||
"已移除已有圆角面，但所有候选锐边都无法重新倒圆；"
|
||
f"该圆角可能是复杂 blend 或支撑面不适合重建。最后错误：{detail}"
|
||
)
|
||
|
||
part.shape = result
|
||
self.refresh_topology()
|
||
return (
|
||
"Existing fillet radius resize completed: "
|
||
f"face {face_id}, current_radius={float(plan['current_radius']):g}, "
|
||
f"target_radius={target_radius:g}, "
|
||
f"delta_radius={float(plan['delta_radius']):g}, "
|
||
f"support_faces={plan.get('feature_existing_fillet_support_face_ids')}, "
|
||
f"risk={plan['risk']}."
|
||
)
|
||
|
||
def fillet_edge(self, edge_id: int, radius: float) -> str:
|
||
plan = self.edge_fillet_plan(edge_id, radius)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
|
||
part_id = self.edge_part_ids[edge_id]
|
||
part = self.part_by_id(part_id)
|
||
if part is None:
|
||
raise ValueError(f"Unknown part id {part_id}")
|
||
|
||
maker = BRepFilletAPI_MakeFillet(part.shape)
|
||
maker.Add(radius, topods.Edge(self.edges[edge_id]))
|
||
result = _finalize_builder_result(maker, "edge fillet")
|
||
part.shape = result
|
||
self.refresh_topology()
|
||
return (
|
||
f"Edge fillet completed: edge {edge_id}, radius={radius:g}, "
|
||
f"edge_length={float(plan['edge_length']):g}, "
|
||
f"radius_to_length_ratio={float(plan['radius_to_length_ratio']):g}, "
|
||
f"risk={plan['risk']}."
|
||
)
|
||
|
||
def chamfer_edge(self, edge_id: int, distance: float) -> str:
|
||
plan = self.edge_chamfer_plan(edge_id, distance)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
|
||
part_id = self.edge_part_ids[edge_id]
|
||
part = self.part_by_id(part_id)
|
||
if part is None:
|
||
raise ValueError(f"Unknown part id {part_id}")
|
||
|
||
maker = BRepFilletAPI_MakeChamfer(part.shape)
|
||
maker.Add(distance, topods.Edge(self.edges[edge_id]))
|
||
result = _finalize_builder_result(maker, "edge chamfer")
|
||
part.shape = result
|
||
self.refresh_topology()
|
||
return (
|
||
f"Edge chamfer completed: edge {edge_id}, distance={distance:g}, "
|
||
f"edge_length={float(plan['edge_length']):g}, "
|
||
f"distance_to_length_ratio={float(plan['distance_to_length_ratio']):g}, "
|
||
f"risk={plan['risk']}."
|
||
)
|
||
|
||
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)
|
||
source_shape = _finalize_boolean_result(fuse, "cylinder fill/fuse")
|
||
|
||
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)
|
||
result = _finalize_boolean_result(op, "cylinder cut")
|
||
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 resize_cylindrical_boss(self, face_id: int, new_diameter: float) -> str:
|
||
plan = self.cylindrical_boss_resize_plan(face_id, new_diameter)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
|
||
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}")
|
||
|
||
start = gp_Pnt(*plan["boss_tool_start_point"])
|
||
direction = gp_Dir(*plan["boss_tool_axis_direction"])
|
||
axis = gp_Ax2(start, direction)
|
||
height = float(plan["boss_tool_height"])
|
||
if plan["resize_mode"] == "enlarge":
|
||
tool = BRepPrimAPI_MakeCylinder(axis, float(plan["boss_tool_radius"]), height).Shape()
|
||
op = BRepAlgoAPI_Fuse(part.shape, tool)
|
||
result = _finalize_boolean_result(op, "cylindrical boss fuse")
|
||
action = "enlarged by bounded fuse"
|
||
else:
|
||
outer = BRepPrimAPI_MakeCylinder(axis, float(plan["boss_tool_outer_radius"]), height).Shape()
|
||
inner = BRepPrimAPI_MakeCylinder(axis, float(plan["boss_tool_inner_radius"]), height).Shape()
|
||
ring_cut = BRepAlgoAPI_Cut(outer, inner)
|
||
ring = _finalize_boolean_result(ring_cut, "cylindrical boss annular cutter")
|
||
op = BRepAlgoAPI_Cut(part.shape, ring)
|
||
result = _finalize_boolean_result(op, "cylindrical boss cut")
|
||
action = "shrunk by bounded annular cut"
|
||
|
||
part.shape = result
|
||
self.refresh_topology()
|
||
return (
|
||
f"Cylindrical boss resize completed: diameter {float(plan['current_diameter']):g} -> {new_diameter:g}, "
|
||
f"mode={plan['resize_mode']}, action={action}, risk={plan['risk']}, "
|
||
f"feature={plan['feature_guess']}, tool={plan['boss_tool_strategy']}, "
|
||
f"height={float(plan['boss_tool_height']):g}."
|
||
)
|
||
|
||
def suppress_cylindrical_hole(self, face_id: int) -> str:
|
||
plan = self.cylindrical_suppress_plan(face_id)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
|
||
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}")
|
||
|
||
face = self.faces[face_id]
|
||
surf = BRepAdaptor_Surface(face)
|
||
if surf.GetType() != GeomAbs_Cylinder:
|
||
raise ValueError("Cylinder suppress currently supports cylindrical faces only.")
|
||
|
||
direction = surf.Cylinder().Axis().Direction()
|
||
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)
|
||
result = _finalize_boolean_result(fuse, "cylinder suppress/fill")
|
||
part.shape = result
|
||
self.refresh_topology()
|
||
return (
|
||
f"Cylindrical hole suppress completed: face {face_id}, "
|
||
f"diameter={float(plan['diameter']):g}, "
|
||
f"height={float(plan['fill_height']):g}, "
|
||
f"risk={plan['risk']}, feature={plan['feature_guess']}."
|
||
)
|
||
|
||
def resize_cylindrical_depth(self, face_id: int, target_depth: float) -> str:
|
||
plan = self.cylindrical_depth_plan(face_id, target_depth)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
|
||
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}")
|
||
|
||
start = gp_Pnt(*plan["depth_tool_start_point"])
|
||
direction = gp_Dir(*plan["depth_axis_direction"])
|
||
axis = gp_Ax2(start, direction)
|
||
tool = BRepPrimAPI_MakeCylinder(
|
||
axis,
|
||
float(plan["depth_tool_radius"]),
|
||
float(plan["depth_tool_height"]),
|
||
).Shape()
|
||
if plan["depth_mode"] == "deepen":
|
||
op = BRepAlgoAPI_Cut(part.shape, tool)
|
||
result = _finalize_boolean_result(op, "blind depth cut")
|
||
action = "deepened by bounded cut"
|
||
else:
|
||
op = BRepAlgoAPI_Fuse(part.shape, tool)
|
||
result = _finalize_boolean_result(op, "blind depth fill/fuse")
|
||
action = "made shallower by bounded fill"
|
||
|
||
part.shape = result
|
||
self.refresh_topology()
|
||
return (
|
||
f"Blind cylindrical depth completed: depth {float(plan['current_depth']):g} -> {target_depth:g}, "
|
||
f"mode={plan['depth_mode']}, action={action}, "
|
||
f"risk={plan['risk']}, feature={plan['feature_guess']}, "
|
||
f"tool={plan['depth_tool_strategy']}, height={float(plan['depth_tool_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,
|
||
edge_ids: Iterable[int] | None = None,
|
||
part_ids: Iterable[int] | None = None,
|
||
deflection: float = 0.8,
|
||
):
|
||
import vtk
|
||
|
||
selected_edges = set(edge_ids) if edge_ids is not None else None
|
||
selected_parts = set(part_ids) if part_ids is not None else None
|
||
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):
|
||
part_id = self.edge_part_ids[edge_id]
|
||
if selected_edges is not None and edge_id not in selected_edges:
|
||
continue
|
||
if selected_parts is not None and part_id not in selected_parts:
|
||
continue
|
||
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(part_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 _prepare_shape_for_step_export(shape: TopoDS_Shape) -> TopoDS_Shape:
|
||
if shape.IsNull():
|
||
return shape
|
||
try:
|
||
repaired = _repair_shape(shape)
|
||
unified = _unify_same_domain_shape(repaired)
|
||
repaired_unified = _repair_shape(unified)
|
||
if repaired_unified.IsNull():
|
||
return shape
|
||
return repaired_unified
|
||
except Exception:
|
||
return shape
|
||
|
||
|
||
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 _same_shape(left: TopoDS_Shape, right: TopoDS_Shape) -> bool:
|
||
try:
|
||
return bool(left.IsSame(right))
|
||
except Exception:
|
||
return False
|
||
|
||
|
||
def _surfaces_are_coplanar(left: BRepAdaptor_Surface, right: BRepAdaptor_Surface, tolerance: float) -> bool:
|
||
if left.GetType() != GeomAbs_Plane or right.GetType() != GeomAbs_Plane:
|
||
return False
|
||
left_plane = left.Plane()
|
||
right_plane = right.Plane()
|
||
left_dir = left_plane.Axis().Direction()
|
||
right_dir = right_plane.Axis().Direction()
|
||
dot = abs(
|
||
left_dir.X() * right_dir.X()
|
||
+ left_dir.Y() * right_dir.Y()
|
||
+ left_dir.Z() * right_dir.Z()
|
||
)
|
||
if dot < 1.0 - 1e-7:
|
||
return False
|
||
left_point = left_plane.Location()
|
||
right_point = right_plane.Location()
|
||
distance = abs(
|
||
(right_point.X() - left_point.X()) * left_dir.X()
|
||
+ (right_point.Y() - left_point.Y()) * left_dir.Y()
|
||
+ (right_point.Z() - left_point.Z()) * left_dir.Z()
|
||
)
|
||
return distance <= tolerance
|
||
|
||
|
||
def _mapped_edge_solid_id(
|
||
edge: TopoDS_Shape,
|
||
solid_edge_maps: list[tuple[int, TopTools_IndexedDataMapOfShapeListOfShape]],
|
||
) -> int:
|
||
for solid_id, edge_map in solid_edge_maps:
|
||
if edge_map.Contains(edge):
|
||
return solid_id
|
||
return -1
|
||
|
||
|
||
def _shape_quality_info(label: str, shape: TopoDS_Shape, expect_solid: bool) -> dict[str, object]:
|
||
warnings: list[str] = []
|
||
if shape.IsNull():
|
||
return {
|
||
"quality_label": label,
|
||
"quality_status": "blocked",
|
||
"brep_valid": False,
|
||
"solids": 0,
|
||
"faces": 0,
|
||
"edges": 0,
|
||
"vertices": 0,
|
||
"quality_warnings": "导出对象是空 shape，不能可靠导出。",
|
||
}
|
||
|
||
try:
|
||
brep_valid = BRepCheck_Analyzer(shape).IsValid()
|
||
except Exception as exc:
|
||
brep_valid = False
|
||
warnings.append(f"B-Rep 校验执行失败：{exc}")
|
||
|
||
topo = TopologyExplorer(shape, ignore_orientation=True)
|
||
solids = len(list(topo.solids()))
|
||
faces = len(list(topo.faces()))
|
||
edges = len(list(topo.edges()))
|
||
vertices = len(list(topo.vertices()))
|
||
|
||
if not brep_valid:
|
||
warnings.append("B-Rep 校验未通过，导出后其他 CAD 软件可能无法正常识别。")
|
||
if faces == 0:
|
||
warnings.append("没有检测到 face，导出结果可能不可用。")
|
||
if expect_solid and solids == 0:
|
||
warnings.append("没有检测到 solid，导出后可能不是实体。")
|
||
elif expect_solid and solids > 1:
|
||
warnings.append(
|
||
f"检测到 {solids} 个 solid。"
|
||
"如果这不是有意的多实体零件，导出后可能看起来像多个体叠在一起或彼此分离。"
|
||
)
|
||
|
||
geometry_info = _shape_volume_info(shape)
|
||
volume = geometry_info.get("volume", "")
|
||
if expect_solid and isinstance(volume, (int, float)) and abs(float(volume)) <= 1e-9:
|
||
warnings.append("实体体积接近 0，请确认导出对象是否为有效实体。")
|
||
|
||
bounds_info = _shape_bounds_info(shape)
|
||
return {
|
||
"quality_label": label,
|
||
"quality_status": "warning" if warnings else "ok",
|
||
"brep_valid": brep_valid,
|
||
"solids": solids,
|
||
"faces": faces,
|
||
"edges": edges,
|
||
"vertices": vertices,
|
||
"volume": volume,
|
||
"bbox_diagonal": bounds_info.get("bbox_diagonal", ""),
|
||
"quality_warnings": "；".join(warnings),
|
||
}
|
||
|
||
|
||
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 _shape_center(shape: TopoDS_Shape) -> tuple[float, float, float]:
|
||
xmin, ymin, zmin, xmax, ymax, zmax = _shape_bounds(shape)
|
||
return ((xmin + xmax) / 2.0, (ymin + ymax) / 2.0, (zmin + zmax) / 2.0)
|
||
|
||
|
||
def _translated_shape(shape: TopoDS_Shape, direction: tuple[float, float, float], distance: float) -> TopoDS_Shape:
|
||
if abs(distance) <= 1e-12:
|
||
return shape
|
||
trsf = gp_Trsf()
|
||
trsf.SetTranslation(
|
||
gp_Vec(
|
||
float(direction[0]) * distance,
|
||
float(direction[1]) * distance,
|
||
float(direction[2]) * distance,
|
||
)
|
||
)
|
||
return BRepBuilderAPI_Transform(shape, trsf, True).Shape()
|
||
|
||
|
||
def _translated_shape_by_vector(shape: TopoDS_Shape, vector: tuple[float, float, float]) -> TopoDS_Shape:
|
||
if _vector_length(vector) <= 1e-12:
|
||
return shape
|
||
trsf = gp_Trsf()
|
||
trsf.SetTranslation(gp_Vec(float(vector[0]), float(vector[1]), float(vector[2])))
|
||
return BRepBuilderAPI_Transform(shape, trsf, True).Shape()
|
||
|
||
|
||
def _rotated_shape(
|
||
shape: TopoDS_Shape,
|
||
axis_name: str,
|
||
angle_degrees: float,
|
||
center: tuple[float, float, float],
|
||
) -> TopoDS_Shape:
|
||
if abs(angle_degrees) <= 1e-12:
|
||
return shape
|
||
axis_dir = _axis_dir_from_name(axis_name)
|
||
trsf = gp_Trsf()
|
||
trsf.SetRotation(gp_Ax1(gp_Pnt(*center), axis_dir), math.radians(angle_degrees))
|
||
return BRepBuilderAPI_Transform(shape, trsf, True).Shape()
|
||
|
||
|
||
def _axis_dir_from_name(axis_name: str) -> gp_Dir:
|
||
axis = axis_name.upper()
|
||
if axis == "X":
|
||
return gp_Dir(1.0, 0.0, 0.0)
|
||
if axis == "Y":
|
||
return gp_Dir(0.0, 1.0, 0.0)
|
||
if axis == "Z":
|
||
return gp_Dir(0.0, 0.0, 1.0)
|
||
raise ValueError("Rotation axis must be X, Y or Z.")
|
||
|
||
|
||
def _vector_length(vector: tuple[float, float, float]) -> float:
|
||
return math.sqrt(float(vector[0]) ** 2 + float(vector[1]) ** 2 + float(vector[2]) ** 2)
|
||
|
||
|
||
def _tuple_or_none(value: object) -> tuple[float, float, float] | None:
|
||
if not isinstance(value, (list, tuple)) or len(value) != 3:
|
||
return None
|
||
try:
|
||
return (float(value[0]), float(value[1]), float(value[2]))
|
||
except (TypeError, ValueError):
|
||
return None
|
||
|
||
|
||
def _tuple_sub(left: tuple[float, float, float], right: tuple[float, float, float]) -> tuple[float, float, float]:
|
||
return (left[0] - right[0], left[1] - right[1], left[2] - right[2])
|
||
|
||
|
||
def _tuple_scale(values: tuple[float, float, float], scale: float) -> tuple[float, float, float]:
|
||
return (values[0] * scale, values[1] * scale, values[2] * scale)
|
||
|
||
|
||
def _tuple_dot(left: tuple[float, float, float], right: tuple[float, float, float]) -> float:
|
||
return left[0] * right[0] + left[1] * right[1] + left[2] * right[2]
|
||
|
||
|
||
def _tuple_normalized(value: tuple[float, float, float] | None) -> tuple[float, float, float] | None:
|
||
if value is None:
|
||
return None
|
||
length = _vector_length(value)
|
||
if length <= 1e-12:
|
||
return None
|
||
return (value[0] / length, value[1] / length, value[2] / length)
|
||
|
||
|
||
def _rotation_readiness(axis_name: str, angle_degrees: float) -> dict[str, object]:
|
||
risk = "low"
|
||
status = "ready"
|
||
warnings: list[str] = []
|
||
blockers: list[str] = []
|
||
axis = axis_name.upper()
|
||
|
||
if axis not in {"X", "Y", "Z"}:
|
||
status = "blocked"
|
||
risk = "blocked"
|
||
blockers.append("旋转轴必须是 X、Y 或 Z。")
|
||
if abs(angle_degrees) <= 1e-9:
|
||
status = "blocked"
|
||
risk = "blocked"
|
||
blockers.append("旋转角度为 0，不需要修改。")
|
||
if abs(angle_degrees) > 360.0:
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append("旋转角度超过 360 度，请确认输入是否符合预期。")
|
||
|
||
if blockers:
|
||
note = " ".join(blockers + warnings)
|
||
elif warnings:
|
||
status = "caution"
|
||
note = " ".join(warnings)
|
||
else:
|
||
note = "可以尝试旋转当前对象。"
|
||
return {
|
||
"rotate_status": status,
|
||
"rotate_risk": risk,
|
||
"rotate_warnings": "；".join(warnings),
|
||
"rotate_blockers": "；".join(blockers),
|
||
"rotate_note": note,
|
||
}
|
||
|
||
|
||
def _translation_readiness(vector: tuple[float, float, float], shape: TopoDS_Shape) -> dict[str, object]:
|
||
risk = "low"
|
||
status = "ready"
|
||
warnings: list[str] = []
|
||
blockers: list[str] = []
|
||
distance = _vector_length(vector)
|
||
diagonal = _shape_diagonal(shape)
|
||
|
||
if distance <= 1e-9:
|
||
status = "blocked"
|
||
risk = "blocked"
|
||
blockers.append("平移向量为 0，不需要修改。")
|
||
elif diagonal > 1e-9:
|
||
ratio = distance / diagonal
|
||
if ratio > 2.0:
|
||
risk = "high"
|
||
warnings.append("平移距离超过目标包围盒对角线的 2 倍，请确认单位和方向。")
|
||
elif ratio > 0.5:
|
||
risk = "medium"
|
||
warnings.append("平移距离超过目标包围盒对角线的 50%，请确认单位和方向。")
|
||
|
||
if blockers:
|
||
note = " ".join(blockers + warnings)
|
||
elif warnings:
|
||
status = "caution"
|
||
note = " ".join(warnings)
|
||
else:
|
||
note = "可以尝试平移当前对象。"
|
||
return {
|
||
"translate_status": status,
|
||
"translate_risk": risk,
|
||
"translate_warnings": "；".join(warnings),
|
||
"translate_blockers": "；".join(blockers),
|
||
"translate_note": note,
|
||
}
|
||
|
||
|
||
def _boolean_overlap_distance(shape: TopoDS_Shape, requested_distance: float) -> float:
|
||
diagonal = _shape_diagonal(shape)
|
||
size_based = diagonal * 1e-5 if diagonal > 0 else 0.01
|
||
distance_based = abs(requested_distance) * 0.02
|
||
return min(max(size_based, distance_based, 0.001), max(abs(requested_distance) * 0.25, 0.01))
|
||
|
||
|
||
def _shape_cleaning_tolerance(
|
||
source_shape: TopoDS_Shape,
|
||
profile_shape: TopoDS_Shape,
|
||
requested_distance: float,
|
||
) -> float:
|
||
source_diagonal = _shape_diagonal(source_shape)
|
||
profile_diagonal = _shape_diagonal(profile_shape)
|
||
reference = max(source_diagonal, profile_diagonal, abs(requested_distance), 1.0)
|
||
size_based = reference * 1e-7
|
||
distance_based = abs(requested_distance) * 1e-5
|
||
lower = max(size_based, distance_based, 1e-5)
|
||
upper = max(reference * 1e-4, 0.02)
|
||
return min(lower, upper)
|
||
|
||
|
||
def _topology_shape_count(shape: TopoDS_Shape, shape_type) -> int:
|
||
explorer = TopExp_Explorer(shape, shape_type)
|
||
count = 0
|
||
while explorer.More():
|
||
count += 1
|
||
explorer.Next()
|
||
return count
|
||
|
||
|
||
def _defeature_faces(shape: TopoDS_Shape, faces: Iterable[TopoDS_Shape]) -> TopoDS_Shape:
|
||
builder = BRepAlgoAPI_Defeaturing()
|
||
builder.SetShape(shape)
|
||
for face in faces:
|
||
builder.AddFaceToRemove(topods.Face(face))
|
||
return _finalize_builder_result(builder, "existing fillet defeature")
|
||
|
||
|
||
def _find_axis_aligned_edge(
|
||
shape: TopoDS_Shape,
|
||
axis_point: gp_Pnt,
|
||
axis_dir: gp_Dir,
|
||
expected_length: float,
|
||
reference_radius: float,
|
||
) -> TopoDS_Shape | None:
|
||
candidates = _axis_aligned_edge_candidates(shape, axis_point, axis_dir, expected_length, reference_radius)
|
||
return candidates[0] if candidates else None
|
||
|
||
|
||
def _axis_aligned_edge_candidates(
|
||
shape: TopoDS_Shape,
|
||
axis_point: gp_Pnt,
|
||
axis_dir: gp_Dir,
|
||
expected_length: float,
|
||
reference_radius: float,
|
||
) -> list[TopoDS_Shape]:
|
||
candidates: list[tuple[float, TopoDS_Shape]] = []
|
||
length_reference = max(expected_length, reference_radius, 1.0)
|
||
distance_limit = max(reference_radius * 1.25, length_reference * 0.08, 0.2)
|
||
|
||
for edge in TopologyExplorer(shape, ignore_orientation=True).edges():
|
||
try:
|
||
curve = BRepAdaptor_Curve(edge)
|
||
if curve.GetType() != GeomAbs_Line:
|
||
continue
|
||
line = curve.Line()
|
||
parallel = abs(_direction_dot(line.Direction(), axis_dir))
|
||
if parallel < 0.96:
|
||
continue
|
||
|
||
props = GProp_GProps()
|
||
brepgprop.LinearProperties(edge, props)
|
||
edge_length = props.Mass()
|
||
if edge_length <= 1e-9:
|
||
continue
|
||
|
||
line_distance = _point_axis_distance(axis_point, axis_dir, line.Location())
|
||
center_distance = _point_axis_distance(axis_point, axis_dir, props.CentreOfMass())
|
||
length_penalty = 0.0
|
||
if expected_length > 1e-9:
|
||
length_penalty = abs(edge_length - expected_length) / expected_length
|
||
score = max(line_distance, center_distance) + length_penalty * max(reference_radius * 0.15, 0.05)
|
||
if score <= distance_limit:
|
||
candidates.append((score, edge))
|
||
except Exception:
|
||
continue
|
||
|
||
candidates.sort(key=lambda item: item[0])
|
||
return [edge for _score, edge in candidates]
|
||
|
||
|
||
def _finalize_boolean_result(op, operation_name: str) -> TopoDS_Shape:
|
||
op.SetNonDestructive(True)
|
||
op.Build()
|
||
if not op.IsDone():
|
||
raise RuntimeError(f"{operation_name} Boolean operation failed.")
|
||
raw_result = _ensure_valid_or_repaired_shape(op.Shape(), operation_name)
|
||
try:
|
||
op.SimplifyResult(True, True)
|
||
simplified = _ensure_valid_or_repaired_shape(
|
||
op.Shape(), f"{operation_name} simplify"
|
||
)
|
||
unified = _unify_same_domain_shape(simplified)
|
||
return _ensure_valid_or_repaired_shape(unified, f"{operation_name} unify")
|
||
except Exception:
|
||
unified = _unify_same_domain_shape(raw_result)
|
||
return _ensure_valid_or_repaired_shape(unified, f"{operation_name} unify")
|
||
|
||
|
||
def _finalize_builder_result(builder, operation_name: str) -> TopoDS_Shape:
|
||
builder.Build()
|
||
if hasattr(builder, "IsDone") and not builder.IsDone():
|
||
raise RuntimeError(f"{operation_name} operation failed.")
|
||
result = _ensure_valid_or_repaired_shape(builder.Shape(), operation_name)
|
||
unified = _unify_same_domain_shape(result)
|
||
return _ensure_valid_or_repaired_shape(unified, f"{operation_name} unify")
|
||
|
||
|
||
def _cleanup_push_pull_result(
|
||
result: TopoDS_Shape,
|
||
source_shape: TopoDS_Shape,
|
||
profile_shape: TopoDS_Shape,
|
||
distance: float,
|
||
) -> TopoDS_Shape:
|
||
base_tolerance = _shape_cleaning_tolerance(source_shape, profile_shape, distance)
|
||
cleaned = result
|
||
for multiplier in (1.0, 5.0, 20.0):
|
||
tolerance = base_tolerance * multiplier
|
||
candidate = _unify_same_domain_shape(
|
||
cleaned,
|
||
linear_tolerance=tolerance,
|
||
angular_tolerance=1e-5,
|
||
allow_internal_edges=False,
|
||
)
|
||
candidate = _ensure_valid_or_repaired_shape(candidate, f"push/pull cleanup {multiplier:g}x")
|
||
if _topology_shape_count(candidate, TopAbs_SOLID) == _topology_shape_count(result, TopAbs_SOLID):
|
||
cleaned = candidate
|
||
return cleaned
|
||
|
||
|
||
def _unify_same_domain_shape(
|
||
shape: TopoDS_Shape,
|
||
linear_tolerance: float | None = None,
|
||
angular_tolerance: float | None = None,
|
||
allow_internal_edges: bool = False,
|
||
) -> TopoDS_Shape:
|
||
try:
|
||
unifier = ShapeUpgrade_UnifySameDomain(shape, True, True, False)
|
||
unifier.SetSafeInputMode(True)
|
||
if hasattr(unifier, "AllowInternalEdges"):
|
||
unifier.AllowInternalEdges(allow_internal_edges)
|
||
if linear_tolerance is not None and hasattr(unifier, "SetLinearTolerance"):
|
||
unifier.SetLinearTolerance(max(float(linear_tolerance), 0.0))
|
||
if angular_tolerance is not None and hasattr(unifier, "SetAngularTolerance"):
|
||
unifier.SetAngularTolerance(max(float(angular_tolerance), 0.0))
|
||
unifier.Build()
|
||
unified = unifier.Shape()
|
||
_ensure_valid_shape(unified)
|
||
return unified
|
||
except Exception:
|
||
return shape
|
||
|
||
|
||
def _ensure_valid_or_repaired_shape(
|
||
shape: TopoDS_Shape, operation_name: str
|
||
) -> TopoDS_Shape:
|
||
try:
|
||
_ensure_valid_shape(shape)
|
||
return shape
|
||
except RuntimeError as original_error:
|
||
repaired = _repair_shape(shape)
|
||
try:
|
||
_ensure_valid_shape(repaired)
|
||
return repaired
|
||
except RuntimeError:
|
||
raise RuntimeError(
|
||
f"{operation_name} returned an invalid B-Rep shape, and automatic repair did not fix it."
|
||
) from original_error
|
||
|
||
|
||
def _repair_shape(shape: TopoDS_Shape) -> TopoDS_Shape:
|
||
if shape.IsNull():
|
||
return shape
|
||
try:
|
||
fixer = ShapeFix_Shape(shape)
|
||
fixer.Perform()
|
||
repaired = fixer.Shape()
|
||
if repaired.IsNull():
|
||
return shape
|
||
return repaired
|
||
except Exception:
|
||
return shape
|
||
|
||
|
||
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))
|
||
height_estimate = float(info.get("height_estimate", 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("目标直径与当前直径几乎相同，不需要修改。")
|
||
else:
|
||
diameter_delta = abs(new_diameter - current_diameter)
|
||
delta_ratio = diameter_delta / max(current_diameter, 1e-9)
|
||
if delta_ratio > 1.0:
|
||
risk = _max_risk(risk, "high")
|
||
warnings.append("目标直径变化超过当前直径的 100%，很可能导致大范围误切或布尔失败。")
|
||
elif delta_ratio > 0.35:
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append("目标直径变化超过当前直径的 35%，请确认预览范围。")
|
||
|
||
if height_estimate > 0 and new_diameter > height_estimate * 2.0:
|
||
risk = _max_risk(risk, "high")
|
||
warnings.append("目标直径超过圆柱面估算高度的 2 倍，几何比例异常。")
|
||
elif height_estimate > 0 and new_diameter > height_estimate:
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append("目标直径超过圆柱面估算高度，可能不是常规孔径修改。")
|
||
|
||
if 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 _cylinder_boss_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))
|
||
current_diameter = float(info.get("diameter", 0.0))
|
||
height_estimate = float(info.get("height_estimate", 0.0))
|
||
|
||
if guess != "boss/outer-round candidate":
|
||
blockers.append("凸台直径调整第一版只支持明确的凸台/外圆柱候选。")
|
||
if angular_span < math.tau * 0.92:
|
||
blockers.append("凸台直径调整第一版只支持接近完整圆柱的凸台，不处理局部外圆角或圆角面。")
|
||
if current_diameter <= 1e-9:
|
||
blockers.append("当前圆柱面的直径估算无效。")
|
||
|
||
if guess == "boss/outer-round candidate" and confidence != "high":
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append("凸台判断置信度不是 high，修改后请重点检查结果。")
|
||
|
||
if new_diameter is not None:
|
||
if new_diameter <= 0:
|
||
blockers.append("目标凸台直径必须大于 0。")
|
||
elif current_diameter > 1e-9 and abs(new_diameter - current_diameter) <= max(current_diameter * 1e-5, 1e-6):
|
||
blockers.append("目标凸台直径与当前直径几乎相同，不需要修改。")
|
||
elif current_diameter > 1e-9:
|
||
delta_ratio = abs(new_diameter - current_diameter) / current_diameter
|
||
if delta_ratio > 0.8:
|
||
risk = _max_risk(risk, "high")
|
||
warnings.append("目标凸台直径变化超过当前直径的 80%，很可能导致大范围布尔失败。")
|
||
elif delta_ratio > 0.3:
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append("目标凸台直径变化超过当前直径的 30%，请确认预览范围。")
|
||
if new_diameter < current_diameter * 0.15:
|
||
risk = _max_risk(risk, "high")
|
||
warnings.append("目标凸台直径非常小，可能生成很薄或断开的几何。")
|
||
if height_estimate > 1e-9 and new_diameter > height_estimate * 3.0:
|
||
risk = _max_risk(risk, "high")
|
||
warnings.append("目标凸台直径超过圆柱面估算高度的 3 倍，几何比例异常。")
|
||
elif height_estimate > 1e-9 and new_diameter > height_estimate * 1.5:
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append("目标凸台直径明显大于圆柱面估算高度，请确认单位。")
|
||
|
||
if blockers:
|
||
status = "blocked"
|
||
risk = "blocked"
|
||
elif risk in {"medium", "high"}:
|
||
status = "caution"
|
||
|
||
if not warnings and not blockers:
|
||
note = "可以尝试调整圆柱凸台直径。"
|
||
else:
|
||
note = " ".join(blockers + warnings)
|
||
return {
|
||
"boss_resize_status": status,
|
||
"boss_resize_risk": risk,
|
||
"boss_resize_warnings": "；".join(warnings),
|
||
"boss_resize_blockers": "；".join(blockers),
|
||
"boss_resize_note": note,
|
||
}
|
||
|
||
|
||
def _cylinder_depth_readiness(
|
||
info: dict[str, object],
|
||
target_depth: 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))
|
||
end_type = str(info.get("cylinder_end_type", "unknown"))
|
||
current_depth = float(info.get("hole_depth_estimate", 0.0))
|
||
|
||
if guess != "hole/groove candidate":
|
||
blockers.append("孔深调整第一版只支持孔/槽候选，不支持圆角、凸柱或未明确圆柱面。")
|
||
if end_type != "blind":
|
||
blockers.append("孔深调整第一版只支持端部类型为 blind 的盲孔/盲槽。")
|
||
if current_depth <= 1e-9:
|
||
blockers.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 target_depth is not None:
|
||
if target_depth <= 0:
|
||
blockers.append("目标深度必须大于 0。")
|
||
elif current_depth > 1e-9 and abs(target_depth - current_depth) <= max(current_depth * 1e-5, 1e-6):
|
||
blockers.append("目标深度与当前深度几乎相同，不需要修改。")
|
||
elif current_depth > 1e-9:
|
||
delta_ratio = abs(target_depth - current_depth) / current_depth
|
||
if delta_ratio > 1.0:
|
||
risk = _max_risk(risk, "high")
|
||
warnings.append("目标深度变化超过当前深度的 100%，很可能导致贯穿、误切或布尔失败。")
|
||
elif delta_ratio > 0.35:
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append("目标深度变化超过当前深度的 35%，请确认预览范围。")
|
||
|
||
if target_depth < current_depth * 0.08:
|
||
risk = _max_risk(risk, "high")
|
||
warnings.append("目标深度非常浅，补料后可能生成很薄的局部面。")
|
||
|
||
if blockers:
|
||
status = "blocked"
|
||
risk = "blocked"
|
||
elif risk in {"medium", "high"}:
|
||
status = "caution"
|
||
|
||
if not warnings and not blockers:
|
||
note = "可以尝试调整盲孔深度。"
|
||
else:
|
||
note = " ".join(blockers + warnings)
|
||
return {
|
||
"depth_status": status,
|
||
"depth_risk": risk,
|
||
"depth_warnings": "；".join(warnings),
|
||
"depth_blockers": "；".join(blockers),
|
||
"depth_note": note,
|
||
}
|
||
|
||
|
||
def _cylinder_suppress_readiness(info: dict[str, object]) -> 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))
|
||
end_type = str(info.get("cylinder_end_type", "unknown"))
|
||
height = float(info.get("height_estimate", 0.0))
|
||
diameter = float(info.get("diameter", 0.0))
|
||
|
||
if guess != "hole/groove candidate":
|
||
blockers.append("封堵圆柱孔第一版只支持孔候选，不支持圆角、凸柱或未明确圆柱面。")
|
||
if angular_span < math.tau * 0.92:
|
||
blockers.append("封堵圆柱孔第一版只支持接近完整圆柱的孔，不支持半孔/槽。")
|
||
if end_type == "closed/internal":
|
||
blockers.append("当前圆柱两端都像在材料内部，不像可封堵的外部孔。")
|
||
if height <= 1e-9 or diameter <= 1e-9:
|
||
blockers.append("当前圆柱孔的直径或高度估算无效。")
|
||
|
||
if guess == "hole/groove candidate" and confidence != "high":
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append("孔判断置信度不是 high，封堵后请重点检查结果。")
|
||
if end_type not in {"blind", "through/open-ended"}:
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append("孔端部类型不明确，补料范围可能不是期望的孔范围。")
|
||
|
||
if blockers:
|
||
status = "blocked"
|
||
risk = "blocked"
|
||
elif risk in {"medium", "high"}:
|
||
status = "caution"
|
||
|
||
if not warnings and not blockers:
|
||
note = "可以尝试封堵该圆柱孔。"
|
||
else:
|
||
note = " ".join(blockers + warnings)
|
||
return {
|
||
"suppress_status": status,
|
||
"suppress_risk": risk,
|
||
"suppress_warnings": "；".join(warnings),
|
||
"suppress_blockers": "；".join(blockers),
|
||
"suppress_note": note,
|
||
}
|
||
|
||
|
||
def _edge_fillet_readiness(
|
||
info: dict[str, object],
|
||
radius: float | None = None,
|
||
) -> dict[str, object]:
|
||
risk = "medium"
|
||
status = "caution"
|
||
warnings: list[str] = ["STEP 没有建模历史，边倒圆依赖当前 B-Rep 拓扑，部分边可能被 OCCT 拒绝。"]
|
||
blockers: list[str] = []
|
||
curve = str(info.get("curve", ""))
|
||
length = float(info.get("length", 0.0))
|
||
adjacent_count = int(info.get("adjacent_face_count", 0))
|
||
|
||
if curve != "line":
|
||
blockers.append("添加圆角第一版只支持直线 edge。")
|
||
if length <= 1e-9:
|
||
blockers.append("当前 edge 长度无效。")
|
||
if adjacent_count < 2:
|
||
blockers.append("当前 edge 没有检测到至少两个相邻 face，不能可靠添加圆角。")
|
||
elif adjacent_count > 2:
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append(f"当前 edge 相邻 face 数为 {adjacent_count}，可能是复杂交汇边。")
|
||
|
||
if radius is not None:
|
||
if radius <= 0:
|
||
blockers.append("圆角半径必须大于 0。")
|
||
elif length > 1e-9:
|
||
ratio = radius / length
|
||
if ratio >= 0.45:
|
||
blockers.append("圆角半径接近或超过 edge 长度的一半，第一版直接阻止。")
|
||
elif ratio > 0.25:
|
||
risk = _max_risk(risk, "high")
|
||
warnings.append("圆角半径超过 edge 长度的 25%，很容易导致倒圆失败。")
|
||
elif ratio > 0.12:
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append("圆角半径相对 edge 长度偏大，请确认预览范围。")
|
||
|
||
if blockers:
|
||
status = "blocked"
|
||
risk = "blocked"
|
||
elif risk in {"medium", "high"}:
|
||
status = "caution"
|
||
|
||
if not warnings and not blockers:
|
||
note = "可以尝试给该直线边添加圆角。"
|
||
else:
|
||
note = " ".join(blockers + warnings)
|
||
return {
|
||
"fillet_status": status,
|
||
"fillet_risk": risk,
|
||
"fillet_warnings": "；".join(warnings),
|
||
"fillet_blockers": "；".join(blockers),
|
||
"fillet_note": note,
|
||
}
|
||
|
||
|
||
def _edge_chamfer_readiness(
|
||
info: dict[str, object],
|
||
distance: float | None = None,
|
||
) -> dict[str, object]:
|
||
risk = "medium"
|
||
status = "caution"
|
||
warnings: list[str] = ["STEP 没有建模历史，边倒角依赖当前 B-Rep 拓扑，部分边可能被 OCCT 拒绝。"]
|
||
blockers: list[str] = []
|
||
curve = str(info.get("curve", ""))
|
||
length = float(info.get("length", 0.0))
|
||
adjacent_count = int(info.get("adjacent_face_count", 0))
|
||
|
||
if curve != "line":
|
||
blockers.append("添加倒角第一版只支持直线 edge。")
|
||
if length <= 1e-9:
|
||
blockers.append("当前 edge 长度无效。")
|
||
if adjacent_count < 2:
|
||
blockers.append("当前 edge 没有检测到至少两个相邻 face，不能可靠添加倒角。")
|
||
elif adjacent_count > 2:
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append(f"当前 edge 相邻 face 数为 {adjacent_count}，可能是复杂交汇边。")
|
||
|
||
if distance is not None:
|
||
if distance <= 0:
|
||
blockers.append("倒角距离必须大于 0。")
|
||
elif length > 1e-9:
|
||
ratio = distance / length
|
||
if ratio >= 0.45:
|
||
blockers.append("倒角距离接近或超过 edge 长度的一半，第一版直接阻止。")
|
||
elif ratio > 0.25:
|
||
risk = _max_risk(risk, "high")
|
||
warnings.append("倒角距离超过 edge 长度的 25%，很容易导致倒角失败。")
|
||
elif ratio > 0.12:
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append("倒角距离相对 edge 长度偏大，请确认预览范围。")
|
||
|
||
if blockers:
|
||
status = "blocked"
|
||
risk = "blocked"
|
||
elif risk in {"medium", "high"}:
|
||
status = "caution"
|
||
|
||
if not warnings and not blockers:
|
||
note = "可以尝试给该直线边添加倒角。"
|
||
else:
|
||
note = " ".join(blockers + warnings)
|
||
return {
|
||
"chamfer_status": status,
|
||
"chamfer_risk": risk,
|
||
"chamfer_warnings": "；".join(warnings),
|
||
"chamfer_blockers": "；".join(blockers),
|
||
"chamfer_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 _join_nonempty(*values: object) -> str:
|
||
return "；".join(str(value) for value in values if value not in {"", None})
|
||
|
||
|
||
def _int_values(value: object) -> list[int]:
|
||
if value is None or value == "":
|
||
return []
|
||
if isinstance(value, int):
|
||
return [value]
|
||
if isinstance(value, (list, tuple, set)):
|
||
result: list[int] = []
|
||
for item in value:
|
||
try:
|
||
result.append(int(item))
|
||
except (TypeError, ValueError):
|
||
continue
|
||
return result
|
||
return []
|
||
|
||
|
||
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 _direction_dot(left, right) -> float:
|
||
return left.X() * right.X() + left.Y() * right.Y() + left.Z() * right.Z()
|
||
|
||
|
||
def _axis_parameter(axis_point: gp_Pnt, direction, point: gp_Pnt) -> float:
|
||
return (
|
||
(point.X() - axis_point.X()) * direction.X()
|
||
+ (point.Y() - axis_point.Y()) * direction.Y()
|
||
+ (point.Z() - axis_point.Z()) * direction.Z()
|
||
)
|
||
|
||
|
||
def _point_axis_distance(axis_point: gp_Pnt, direction, point: gp_Pnt) -> float:
|
||
projected = _point_on_axis(axis_point, direction, _axis_parameter(axis_point, direction, point))
|
||
return _vec_from_points(projected, point).Magnitude()
|
||
|
||
|
||
def _shape_axis_parameters(shape: TopoDS_Shape, axis_point: gp_Pnt, direction) -> list[float]:
|
||
parameters: list[float] = []
|
||
try:
|
||
for vertex in TopologyExplorer(shape, ignore_orientation=True).vertices():
|
||
point = BRep_Tool.Pnt(topods.Vertex(vertex))
|
||
parameters.append(_axis_parameter(axis_point, direction, point))
|
||
except Exception:
|
||
parameters.clear()
|
||
try:
|
||
parameters.append(_axis_parameter(axis_point, direction, _surface_center(shape)))
|
||
except Exception:
|
||
pass
|
||
return parameters
|
||
|
||
|
||
def _surface_center(shape: TopoDS_Shape) -> gp_Pnt:
|
||
props = GProp_GProps()
|
||
brepgprop.SurfaceProperties(shape, props)
|
||
return props.CentreOfMass()
|
||
|
||
|
||
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 _point_distance_sq(
|
||
point: tuple[float, float, float],
|
||
target: tuple[float, float, float],
|
||
) -> float:
|
||
dx = point[0] - target[0]
|
||
dy = point[1] - target[1]
|
||
dz = point[2] - target[2]
|
||
return dx * dx + dy * dy + dz * dz
|
||
|
||
|
||
def _point_segment_distance_sq(
|
||
point: tuple[float, float, float],
|
||
start: tuple[float, float, float],
|
||
end: tuple[float, float, float],
|
||
) -> float:
|
||
vx = end[0] - start[0]
|
||
vy = end[1] - start[1]
|
||
vz = end[2] - start[2]
|
||
wx = point[0] - start[0]
|
||
wy = point[1] - start[1]
|
||
wz = point[2] - start[2]
|
||
length_sq = vx * vx + vy * vy + vz * vz
|
||
if length_sq <= 1e-18:
|
||
return _point_distance_sq(point, start)
|
||
t = (wx * vx + wy * vy + wz * vz) / length_sq
|
||
t = max(0.0, min(1.0, t))
|
||
projection = (start[0] + t * vx, start[1] + t * vy, start[2] + t * vz)
|
||
return _point_distance_sq(point, projection)
|
||
|
||
|
||
def _dot(vec: gp_Vec, direction) -> float:
|
||
return vec.X() * direction.X() + vec.Y() * direction.Y() + vec.Z() * direction.Z()
|