1418 lines
52 KiB
Python
1418 lines
52 KiB
Python
from __future__ import annotations
|
||
|
||
import math
|
||
from typing import Iterable
|
||
|
||
from OCC.Core.BRep import BRep_Tool
|
||
from OCC.Core.BRepAdaptor import BRepAdaptor_Curve, BRepAdaptor_Surface
|
||
from OCC.Core.BRepAlgoAPI import BRepAlgoAPI_Defeaturing
|
||
from OCC.Core.BRepBndLib import brepbndlib
|
||
from OCC.Core.BOPAlgo import BOPAlgo_GlueFull
|
||
from OCC.Core.BRepBuilderAPI import BRepBuilderAPI_GTransform, BRepBuilderAPI_Transform
|
||
from OCC.Core.BRepCheck import BRepCheck_Analyzer
|
||
from OCC.Core.BRepClass3d import BRepClass3d_SolidClassifier
|
||
from OCC.Core.BRepGProp import brepgprop
|
||
from OCC.Core.Bnd import Bnd_Box
|
||
from OCC.Core.GeomAbs import (
|
||
GeomAbs_Circle,
|
||
GeomAbs_Cylinder,
|
||
GeomAbs_Line,
|
||
GeomAbs_Plane,
|
||
)
|
||
from OCC.Core.GProp import GProp_GProps
|
||
from OCC.Core.ShapeFix import ShapeFix_Shape
|
||
from OCC.Core.ShapeUpgrade import ShapeUpgrade_UnifySameDomain
|
||
from OCC.Core.TopAbs import (
|
||
TopAbs_EDGE,
|
||
TopAbs_FACE,
|
||
TopAbs_IN,
|
||
TopAbs_OUT,
|
||
TopAbs_REVERSED,
|
||
TopAbs_SOLID,
|
||
)
|
||
from OCC.Core.TopExp import TopExp_Explorer
|
||
from OCC.Core.TopLoc import TopLoc_Location
|
||
from OCC.Core.TopoDS import TopoDS_Compound, TopoDS_Shape, topods
|
||
from OCC.Core.TopTools import TopTools_IndexedDataMapOfShapeListOfShape
|
||
from OCC.Core.gp import gp_Ax1, gp_Dir, gp_GTrsf, gp_Pnt, gp_Trsf, gp_Vec, gp_XYZ
|
||
from OCC.Extend.TopologyUtils import TopologyExplorer
|
||
|
||
from .constants import CURVE_TYPES, ORIENTATION_TYPES
|
||
|
||
|
||
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 _surfaces_are_cocylindrical(left: BRepAdaptor_Surface, right: BRepAdaptor_Surface, tolerance: float) -> bool:
|
||
if left.GetType() != GeomAbs_Cylinder or right.GetType() != GeomAbs_Cylinder:
|
||
return False
|
||
left_cylinder = left.Cylinder()
|
||
right_cylinder = right.Cylinder()
|
||
left_axis = left_cylinder.Axis()
|
||
right_axis = right_cylinder.Axis()
|
||
left_dir = left_axis.Direction()
|
||
right_dir = right_axis.Direction()
|
||
axis_dot = abs(_direction_dot(left_dir, right_dir))
|
||
if axis_dot < 1.0 - 1e-6:
|
||
return False
|
||
radius_tolerance = max(tolerance, max(left_cylinder.Radius(), right_cylinder.Radius()) * 1e-6)
|
||
if abs(left_cylinder.Radius() - right_cylinder.Radius()) > radius_tolerance:
|
||
return False
|
||
axis_distance = _point_axis_distance(left_axis.Location(), left_dir, right_axis.Location())
|
||
return axis_distance <= max(tolerance, radius_tolerance)
|
||
|
||
|
||
def _surface_matches_plane_spec(surf: BRepAdaptor_Surface, spec: dict[str, object], tolerance: float) -> bool:
|
||
if surf.GetType() != GeomAbs_Plane:
|
||
return False
|
||
plane = surf.Plane()
|
||
normal = plane.Axis().Direction()
|
||
spec_normal = gp_Dir(*spec["normal"])
|
||
if abs(_direction_dot(normal, spec_normal)) < 1.0 - 1e-7:
|
||
return False
|
||
spec_point = gp_Pnt(*spec["point"])
|
||
distance = abs(_axis_parameter(spec_point, spec_normal, plane.Location()))
|
||
return distance <= tolerance
|
||
|
||
|
||
def _surface_matches_cylinder_spec(surf: BRepAdaptor_Surface, spec: dict[str, object], tolerance: float) -> bool:
|
||
if surf.GetType() != GeomAbs_Cylinder:
|
||
return False
|
||
cylinder = surf.Cylinder()
|
||
axis = cylinder.Axis()
|
||
axis_dir = axis.Direction()
|
||
spec_axis_point = gp_Pnt(*spec["axis_point"])
|
||
spec_axis_dir = gp_Dir(*spec["axis_direction"])
|
||
if abs(_direction_dot(axis_dir, spec_axis_dir)) < 1.0 - 1e-6:
|
||
return False
|
||
radius = float(spec["radius"])
|
||
radius_tolerance = max(tolerance, max(radius, float(cylinder.Radius())) * 1e-6)
|
||
if abs(float(cylinder.Radius()) - radius) > radius_tolerance:
|
||
return False
|
||
return _point_axis_distance(spec_axis_point, spec_axis_dir, axis.Location()) <= max(tolerance, radius_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]:
|
||
if shape.IsNull():
|
||
raise RuntimeError("Shape is null and has no usable bounds.")
|
||
box = Bnd_Box()
|
||
brepbndlib.Add(shape, box)
|
||
try:
|
||
if box.IsVoid():
|
||
raise RuntimeError("Shape has no usable bounds.")
|
||
except AttributeError:
|
||
pass
|
||
try:
|
||
return box.Get()
|
||
except Exception as exc:
|
||
raise RuntimeError("Shape has no usable bounds.") from exc
|
||
|
||
|
||
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 _scaled_shape(shape: TopoDS_Shape, scale: float, center: tuple[float, float, float]) -> TopoDS_Shape:
|
||
if abs(scale - 1.0) <= 1e-12:
|
||
return shape
|
||
if scale <= 0:
|
||
raise ValueError("Scale factor must be greater than 0.")
|
||
trsf = gp_Trsf()
|
||
trsf.SetScale(gp_Pnt(*center), float(scale))
|
||
return BRepBuilderAPI_Transform(shape, trsf, True).Shape()
|
||
|
||
|
||
def _axis_scaled_shape(
|
||
shape: TopoDS_Shape,
|
||
axis_name: str,
|
||
scale: float,
|
||
center: tuple[float, float, float],
|
||
) -> TopoDS_Shape:
|
||
if abs(scale - 1.0) <= 1e-12:
|
||
return shape
|
||
if scale <= 0:
|
||
raise ValueError("Scale factor must be greater than 0.")
|
||
axis = axis_name.upper()
|
||
axis_index = {"X": 0, "Y": 1, "Z": 2}.get(axis)
|
||
if axis_index is None:
|
||
raise ValueError("Scale axis must be X, Y or Z.")
|
||
matrix = [
|
||
[1.0, 0.0, 0.0],
|
||
[0.0, 1.0, 0.0],
|
||
[0.0, 0.0, 1.0],
|
||
]
|
||
matrix[axis_index][axis_index] = float(scale)
|
||
cx, cy, cz = center
|
||
moved_center = (
|
||
matrix[0][0] * cx + matrix[0][1] * cy + matrix[0][2] * cz,
|
||
matrix[1][0] * cx + matrix[1][1] * cy + matrix[1][2] * cz,
|
||
matrix[2][0] * cx + matrix[2][1] * cy + matrix[2][2] * cz,
|
||
)
|
||
translation = (cx - moved_center[0], cy - moved_center[1], cz - moved_center[2])
|
||
transform = gp_GTrsf()
|
||
for row in range(3):
|
||
for column in range(3):
|
||
transform.SetValue(row + 1, column + 1, matrix[row][column])
|
||
transform.SetTranslationPart(gp_XYZ(*translation))
|
||
builder = BRepBuilderAPI_GTransform(shape, transform, True)
|
||
builder.Build()
|
||
if not builder.IsDone():
|
||
raise RuntimeError("Axis scale transform failed.")
|
||
result = builder.Shape()
|
||
if result.IsNull():
|
||
raise RuntimeError("Axis scale transform produced an empty shape.")
|
||
return result
|
||
|
||
|
||
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 _float_or_none(value: object) -> float | None:
|
||
if value is None or value == "":
|
||
return None
|
||
try:
|
||
return float(value)
|
||
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_add(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_cross(left: tuple[float, float, float], right: tuple[float, float, float]) -> tuple[float, float, float]:
|
||
return (
|
||
left[1] * right[2] - left[2] * right[1],
|
||
left[2] * right[0] - left[0] * right[2],
|
||
left[0] * right[1] - left[1] * right[0],
|
||
)
|
||
|
||
|
||
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)
|
||
# A 90-degree edge fillet restores a sharp edge about sqrt(2) * R away
|
||
# from the fillet cylinder axis, so 1.25R misses the common box case.
|
||
distance_limit = max(reference_radius * 1.8, 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, *, use_glue: bool | None = None) -> TopoDS_Shape:
|
||
op.SetNonDestructive(True)
|
||
glue_enabled = "cut" not in operation_name.lower() if use_glue is None else bool(use_glue)
|
||
if glue_enabled and hasattr(op, "SetGlue"):
|
||
try:
|
||
op.SetGlue(BOPAlgo_GlueFull)
|
||
except Exception:
|
||
pass
|
||
if hasattr(op, "SetFuzzyValue"):
|
||
try:
|
||
op.SetFuzzyValue(1e-7)
|
||
except Exception:
|
||
pass
|
||
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:
|
||
_simplify_boolean_builder(op)
|
||
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 _simplify_boolean_builder(builder) -> None:
|
||
if not hasattr(builder, "SimplifyResult"):
|
||
return
|
||
for args in ((True, True, 1e-5), (True, True)):
|
||
try:
|
||
builder.SimplifyResult(*args)
|
||
return
|
||
except TypeError:
|
||
continue
|
||
except Exception:
|
||
return
|
||
|
||
|
||
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
|
||
for safe_input_mode in (True, False):
|
||
candidate = _unify_same_domain_shape(
|
||
cleaned,
|
||
linear_tolerance=tolerance,
|
||
angular_tolerance=1e-5,
|
||
allow_internal_edges=False,
|
||
safe_input_mode=safe_input_mode,
|
||
)
|
||
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,
|
||
safe_input_mode: bool = True,
|
||
concat_bsplines: bool = False,
|
||
) -> TopoDS_Shape:
|
||
try:
|
||
unifier = ShapeUpgrade_UnifySameDomain(shape, True, True, concat_bsplines)
|
||
unifier.SetSafeInputMode(safe_input_mode)
|
||
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.")
|
||
try:
|
||
_shape_bounds(shape)
|
||
except RuntimeError as exc:
|
||
raise RuntimeError("Operation returned a shape without usable geometry.") from exc
|
||
|
||
|
||
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 new_diameter > current_diameter * 2.0:
|
||
status = "blocked"
|
||
risk = "blocked"
|
||
blockers.append(
|
||
"目标直径超过当前直径的 2 倍；当前受限 B-Rep 孔径编辑会直接阻止这种极端放大，"
|
||
"否则很容易出现布尔返回成功但孔壁没有真正变成目标直径。"
|
||
)
|
||
elif 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:
|
||
status = "blocked"
|
||
risk = "blocked"
|
||
blockers.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))
|
||
manual_bottom_face_used = bool(info.get("manual_bottom_face_used"))
|
||
|
||
if guess != "hole/groove candidate":
|
||
blockers.append("孔深调整当前版本只支持孔/槽候选，不支持圆角、凸柱或未明确圆柱面。")
|
||
if end_type != "blind" and not manual_bottom_face_used:
|
||
blockers.append("孔深调整当前版本只支持端部类型为 blind 的盲孔/盲槽。")
|
||
elif end_type != "blind" and manual_bottom_face_used:
|
||
risk = _max_risk(risk, "medium")
|
||
warnings.append("端部类型不是明确 blind，当前按手动底面 Face ID 推断孔深方向。")
|
||
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 _shape_axis_interval(shape: TopoDS_Shape, axis_point: gp_Pnt, direction) -> tuple[float, float] | None:
|
||
parameters = _shape_axis_parameters(shape, axis_point, direction)
|
||
if not parameters:
|
||
return None
|
||
return (min(parameters), max(parameters))
|
||
|
||
|
||
def _shape_plane_interval(
|
||
shape: TopoDS_Shape,
|
||
origin: gp_Pnt,
|
||
u_dir: gp_Dir,
|
||
v_dir: gp_Dir,
|
||
) -> tuple[tuple[float, float], tuple[float, float]] | None:
|
||
u_values = _shape_axis_parameters(shape, origin, u_dir)
|
||
v_values = _shape_axis_parameters(shape, origin, v_dir)
|
||
if not u_values or not v_values:
|
||
return None
|
||
return ((min(u_values), max(u_values)), (min(v_values), max(v_values)))
|
||
|
||
|
||
def _plane_intervals_touch_or_overlap(
|
||
left: tuple[tuple[float, float], tuple[float, float]],
|
||
right: tuple[tuple[float, float], tuple[float, float]],
|
||
tolerance: float,
|
||
) -> bool:
|
||
return _intervals_touch_or_overlap(left[0], right[0], tolerance) and _intervals_touch_or_overlap(left[1], right[1], tolerance)
|
||
|
||
|
||
def _intervals_touch_or_overlap(
|
||
left: tuple[float, float],
|
||
right: tuple[float, float],
|
||
tolerance: float,
|
||
) -> bool:
|
||
left_min, left_max = min(left), max(left)
|
||
right_min, right_max = min(right), max(right)
|
||
return left_max + tolerance >= right_min and right_max + tolerance >= left_min
|
||
|
||
|
||
def _plane_basis_dirs(normal) -> tuple[gp_Dir, gp_Dir]:
|
||
nx, ny, nz = _dir_tuple(normal)
|
||
reference = (1.0, 0.0, 0.0) if abs(nx) < 0.85 else (0.0, 1.0, 0.0)
|
||
u = _tuple_normalized(_tuple_cross((nx, ny, nz), reference)) or (1.0, 0.0, 0.0)
|
||
v = _tuple_normalized(_tuple_cross((nx, ny, nz), u)) or (0.0, 1.0, 0.0)
|
||
return gp_Dir(*u), gp_Dir(*v)
|
||
|
||
|
||
def _edge_duplicate_key(edge: TopoDS_Shape, tolerance: float) -> tuple[object, ...] | None:
|
||
try:
|
||
curve = BRepAdaptor_Curve(edge)
|
||
curve_type = curve.GetType()
|
||
start = curve.Value(curve.FirstParameter())
|
||
end = curve.Value(curve.LastParameter())
|
||
except Exception:
|
||
return None
|
||
|
||
if curve_type == GeomAbs_Circle:
|
||
try:
|
||
circle = curve.Circle()
|
||
endpoint_keys = sorted((_point_quantized_key(start, tolerance), _point_quantized_key(end, tolerance)))
|
||
return (
|
||
"circle",
|
||
_point_quantized_key(circle.Location(), tolerance),
|
||
_direction_quantized_key(circle.Axis().Direction()),
|
||
_number_quantized_key(float(circle.Radius()), tolerance),
|
||
tuple(endpoint_keys),
|
||
)
|
||
except Exception:
|
||
pass
|
||
|
||
endpoint_keys = sorted((_point_quantized_key(start, tolerance), _point_quantized_key(end, tolerance)))
|
||
if curve_type == GeomAbs_Line:
|
||
return ("line", tuple(endpoint_keys))
|
||
return (CURVE_TYPES.get(curve_type, f"type {curve_type}"), tuple(endpoint_keys))
|
||
|
||
|
||
def _point_quantized_key(point, tolerance: float) -> tuple[int, int, int]:
|
||
scale = max(float(tolerance), 1e-9)
|
||
return (
|
||
_number_quantized_key(float(point.X()), scale),
|
||
_number_quantized_key(float(point.Y()), scale),
|
||
_number_quantized_key(float(point.Z()), scale),
|
||
)
|
||
|
||
|
||
def _direction_quantized_key(direction) -> tuple[int, int, int]:
|
||
values = _tuple_normalized((float(direction.X()), float(direction.Y()), float(direction.Z()))) or (1.0, 0.0, 0.0)
|
||
for value in values:
|
||
if abs(value) > 1e-9:
|
||
if value < 0:
|
||
values = (-values[0], -values[1], -values[2])
|
||
break
|
||
return (
|
||
int(round(values[0] * 1_000_000)),
|
||
int(round(values[1] * 1_000_000)),
|
||
int(round(values[2] * 1_000_000)),
|
||
)
|
||
|
||
|
||
def _number_quantized_key(value: float, tolerance: float) -> int:
|
||
return int(round(float(value) / max(float(tolerance), 1e-9)))
|
||
|
||
|
||
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()
|
||
|
||
__all__ = [name for name, value in globals().items() if name.startswith("_") and callable(value)]
|