nikelaluo
26216064e0
将原来的 main.py/step_model.py 拆分为 step_editor 包，补充测量、同域高亮、模型修复、历史导出、槽宽/凸台/边长等 MVP 编辑能力，并更新 README 和忽略规则。
1740 lines
79 KiB
Python
1740 lines
79 KiB
Python
from __future__ import annotations
|
||
|
||
import math
|
||
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.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.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.ShapeFix import ShapeFix_Shape
|
||
from OCC.Core.ShapeUpgrade import ShapeUpgrade_UnifySameDomain
|
||
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.gp import gp_Ax1, gp_Ax2, gp_Dir, gp_GTrsf, gp_Pnt, gp_Trsf, gp_Vec, gp_XYZ
|
||
from OCC.Extend.TopologyUtils import TopologyExplorer, discretize_edge
|
||
|
||
from .constants import CURVE_TYPES, SNAPSHOT_FACE_LOGICAL_IDS_KEY, SURFACE_TYPES
|
||
from .geometry_utils import * # noqa: F403
|
||
from .step_io import _prepare_shape_for_step_export
|
||
|
||
|
||
class OperationMixin:
|
||
def repair_model(self) -> str:
|
||
before_stats = self.stats()
|
||
repaired_parts = 0
|
||
skipped_parts = 0
|
||
for part in self.display_parts():
|
||
if part.shape.IsNull():
|
||
skipped_parts += 1
|
||
continue
|
||
repaired = _prepare_shape_for_step_export(part.shape)
|
||
if repaired.IsNull():
|
||
skipped_parts += 1
|
||
continue
|
||
part.shape = repaired
|
||
repaired_parts += 1
|
||
|
||
if repaired_parts == 0:
|
||
raise RuntimeError("No valid part shape was available for repair.")
|
||
|
||
self.refresh_topology()
|
||
after_stats = self.stats()
|
||
return (
|
||
"Model repair completed: "
|
||
f"parts repaired={repaired_parts}, skipped={skipped_parts}, "
|
||
f"solids {before_stats.solids}->{after_stats.solids}, "
|
||
f"faces {before_stats.faces}->{after_stats.faces}, "
|
||
f"edges {before_stats.edges}->{after_stats.edges}."
|
||
)
|
||
|
||
def repair_part(self, part_id: int) -> str:
|
||
part = self.part_by_id(part_id)
|
||
if part is None:
|
||
raise ValueError(f"Unknown part id {part_id}")
|
||
if part.shape.IsNull():
|
||
raise RuntimeError(f"Part {part_id} has a null shape and cannot be repaired.")
|
||
before_stats = self.part_topology_stats(part_id)
|
||
repaired = _prepare_shape_for_step_export(part.shape)
|
||
if repaired.IsNull():
|
||
raise RuntimeError(f"Part {part_id} repair returned a null shape.")
|
||
part.shape = repaired
|
||
self.refresh_topology()
|
||
after_stats = self.part_topology_stats(part_id)
|
||
return (
|
||
f"Part repair completed: part {part_id}, "
|
||
f"solids {before_stats.solids}->{after_stats.solids}, "
|
||
f"faces {before_stats.faces}->{after_stats.faces}, "
|
||
f"edges {before_stats.edges}->{after_stats.edges}."
|
||
)
|
||
|
||
def repair_solid(self, solid_id: int) -> str:
|
||
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]
|
||
part = self.part_by_id(part_id)
|
||
if part is None:
|
||
raise ValueError(f"Unknown part id {part_id}")
|
||
|
||
before_part_stats = self.part_topology_stats(part_id)
|
||
repaired = _prepare_shape_for_step_export(solid)
|
||
if repaired.IsNull():
|
||
raise RuntimeError(f"Solid {solid_id} repair returned a null shape.")
|
||
|
||
part_solids = _explore(part.shape, TopAbs_SOLID)
|
||
if len(part_solids) <= 1:
|
||
part.shape = repaired
|
||
else:
|
||
replaced = False
|
||
shapes: list[TopoDS_Shape] = []
|
||
for item in part_solids:
|
||
if not replaced and _same_shape(item, solid):
|
||
shapes.append(repaired)
|
||
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()
|
||
after_part_stats = self.part_topology_stats(part_id)
|
||
return (
|
||
f"Solid repair completed: solid {solid_id}, part {part_id}, "
|
||
f"part solids {before_part_stats.solids}->{after_part_stats.solids}, "
|
||
f"faces {before_part_stats.faces}->{after_part_stats.faces}, "
|
||
f"edges {before_part_stats.edges}->{after_part_stats.edges}."
|
||
)
|
||
|
||
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 general_edge_length_plan(
|
||
self,
|
||
edge_id: int,
|
||
target_length: float,
|
||
anchor_mode: str = "auto",
|
||
) -> 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))
|
||
target_length = float(target_length)
|
||
delta_length = target_length - current_length
|
||
curve = str(info.get("curve", ""))
|
||
anchor_mode = self._edge_length_anchor_mode(anchor_mode)
|
||
base: dict[str, object] = {
|
||
"edge_id": edge_id,
|
||
"part_id": info.get("part_id"),
|
||
"solid_id": info.get("solid_id", -1),
|
||
"curve": curve,
|
||
"edge_length_anchor_mode": anchor_mode,
|
||
"edge_length_anchor_label": self._edge_length_anchor_label(anchor_mode),
|
||
"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"),
|
||
"length_center": info.get("length_center"),
|
||
}
|
||
warnings: list[str] = [
|
||
"边长直接修改基于当前 STEP/B-Rep 结果几何，不是 CAD 建模历史里的参数编辑。"
|
||
]
|
||
blockers: list[str] = []
|
||
risk = "low"
|
||
status = "ready"
|
||
|
||
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%，请确认预览范围。")
|
||
|
||
if not blockers and curve == "line" and anchor_mode != "center":
|
||
candidate = self._straight_edge_length_end_face_candidate(info, delta_length, anchor_mode=anchor_mode)
|
||
if candidate is not None:
|
||
push_plan = self.push_pull_plan(int(candidate["end_face_id"]), float(candidate["push_pull_distance"]))
|
||
if push_plan["status"] != "blocked":
|
||
risk = _max_risk(risk, str(push_plan["risk"]))
|
||
push_warnings = str(push_plan.get("warnings", ""))
|
||
if push_warnings:
|
||
warnings.append(push_warnings)
|
||
base.update(candidate)
|
||
base.update(
|
||
{
|
||
"resize_strategy": "move-edge-end-plane-by-push-pull",
|
||
"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", ""),
|
||
}
|
||
)
|
||
else:
|
||
warnings.append(f"端面推拉路径不可用，将尝试通用仿射缩放：{push_plan['message']}")
|
||
elif anchor_mode in {"keep-start", "keep-end"}:
|
||
warnings.append(
|
||
f"未找到可用于{self._edge_length_anchor_label(anchor_mode)}的端面推拉路径，将尝试按该基准缩放所属对象。"
|
||
)
|
||
elif not blockers and curve == "line" and anchor_mode == "center":
|
||
warnings.append("边长基准为固定中心；将使用轴向仿射缩放，让 edge 中心尽量保持不动。")
|
||
|
||
if not blockers and "resize_strategy" not in base and curve == "circle":
|
||
cylinder_candidate, cylinder_notes = self._circular_edge_length_cylinder_candidate(info, target_length)
|
||
if cylinder_candidate is not None:
|
||
risk = _max_risk(risk, str(cylinder_candidate["cylinder_resize_risk"]))
|
||
status = "caution" if risk != "low" else status
|
||
warnings.append("识别到相邻圆柱面；将优先把目标边长换算成圆柱直径做局部编辑。")
|
||
cylinder_warnings = str(cylinder_candidate.get("cylinder_resize_warnings", ""))
|
||
if cylinder_warnings:
|
||
warnings.append(cylinder_warnings)
|
||
base.update(cylinder_candidate)
|
||
elif cylinder_notes:
|
||
warnings.extend(cylinder_notes[:3])
|
||
|
||
if not blockers and "resize_strategy" not in base:
|
||
axis = self._edge_length_affine_axis(info, anchor_mode=anchor_mode)
|
||
if axis is None:
|
||
blockers.append("无法为当前 edge 推断可靠的缩放方向。")
|
||
else:
|
||
part_id = int(info.get("part_id", -1))
|
||
solid_id = int(info.get("solid_id", -1))
|
||
part = self.part_by_id(part_id) if part_id >= 0 else None
|
||
part_solid_count = len(_explore(part.shape, TopAbs_SOLID)) if part is not None else 0
|
||
target_kind = "solid" if solid_id >= 0 and part_solid_count > 1 else "part"
|
||
scale = target_length / max(current_length, 1e-9)
|
||
transform_kind = "axis-affine" if curve == "line" else "uniform"
|
||
risk = _max_risk(risk, "medium")
|
||
if curve != "line" or abs(scale - 1.0) > 0.25:
|
||
risk = _max_risk(risk, "high")
|
||
status = "caution"
|
||
if transform_kind == "axis-affine":
|
||
warnings.append(
|
||
"未找到可推拉端面；将沿该 edge 的几何方向对所属 "
|
||
f"{target_kind} 做仿射缩放。该 fallback 会影响同一 {target_kind} 上的其他尺寸。"
|
||
)
|
||
else:
|
||
warnings.append(
|
||
"当前 edge 不是直线；将以 edge 中心为基准对所属 "
|
||
f"{target_kind} 做均匀缩放。该 fallback 会影响同一 {target_kind} 上的其他尺寸。"
|
||
)
|
||
if curve != "line":
|
||
warnings.append("非直线 edge 的目标长度通过整体比例缩放实现，执行后请复查周边尺寸。")
|
||
base.update(
|
||
{
|
||
"resize_strategy": "scale-owning-shape-from-edge",
|
||
"affine_scale": scale,
|
||
"affine_transform_kind": transform_kind,
|
||
"affine_axis_point": axis["axis_point"],
|
||
"affine_axis_direction": axis["axis_direction"],
|
||
"affine_axis_source": axis["axis_source"],
|
||
"affine_anchor_source": axis["anchor_source"],
|
||
"affine_target_kind": target_kind,
|
||
"part_solid_count": part_solid_count,
|
||
}
|
||
)
|
||
|
||
if blockers:
|
||
status = "blocked"
|
||
risk = "blocked"
|
||
message = " ".join(blockers)
|
||
elif risk != "low":
|
||
status = "caution"
|
||
message = " ".join(warnings)
|
||
else:
|
||
strategy = str(base.get("resize_strategy", ""))
|
||
if strategy == "move-edge-end-plane-by-push-pull":
|
||
message = "可以通过端面推拉调整这条直线 edge 长度。"
|
||
elif strategy == "resize-adjacent-cylinder-from-circular-edge-length":
|
||
message = "可以通过相邻圆柱直径编辑调整这条圆形/圆弧 edge 长度。"
|
||
elif strategy == "scale-owning-shape-from-edge":
|
||
message = "可以通过几何缩放 fallback 尝试调整该 edge 长度。"
|
||
else:
|
||
message = "可以尝试直接修改该 edge 长度。"
|
||
|
||
base.update(
|
||
{
|
||
"status": status,
|
||
"risk": risk,
|
||
"message": message,
|
||
"warnings": "；".join(warnings),
|
||
"blockers": "；".join(blockers),
|
||
}
|
||
)
|
||
return base
|
||
|
||
def _edge_length_anchor_mode(self, anchor_mode: str | None) -> str:
|
||
normalized = str(anchor_mode or "auto").strip().lower()
|
||
aliases = {
|
||
"自动": "auto",
|
||
"auto": "auto",
|
||
"center": "center",
|
||
"centre": "center",
|
||
"固定中心": "center",
|
||
"keep-center": "center",
|
||
"start": "keep-start",
|
||
"起点": "keep-start",
|
||
"固定起点": "keep-start",
|
||
"keep-start": "keep-start",
|
||
"end": "keep-end",
|
||
"终点": "keep-end",
|
||
"固定终点": "keep-end",
|
||
"keep-end": "keep-end",
|
||
}
|
||
return aliases.get(normalized, "auto")
|
||
|
||
def _edge_length_anchor_label(self, anchor_mode: str) -> str:
|
||
return {
|
||
"auto": "自动选择局部端面",
|
||
"center": "固定中心",
|
||
"keep-start": "固定起点",
|
||
"keep-end": "固定终点",
|
||
}.get(anchor_mode, "自动选择局部端面")
|
||
|
||
def _circular_edge_length_cylinder_candidate(
|
||
self,
|
||
edge_info: dict[str, object],
|
||
target_length: float,
|
||
) -> tuple[dict[str, object] | None, list[str]]:
|
||
current_length = float(edge_info.get("length", 0.0))
|
||
current_radius = float(edge_info.get("radius", 0.0))
|
||
if current_length <= 1e-9 or current_radius <= 1e-9:
|
||
return None, []
|
||
|
||
length_scale = float(target_length) / current_length
|
||
target_radius = current_radius * length_scale
|
||
target_diameter = target_radius * 2.0
|
||
if target_diameter <= 1e-9:
|
||
return None, []
|
||
|
||
notes: list[str] = []
|
||
candidates: list[tuple[tuple[int, int, int, int], dict[str, object]]] = []
|
||
risk_rank = {"low": 0, "medium": 1, "high": 2, "blocked": 3}
|
||
status_rank = {"ready": 0, "caution": 1, "blocked": 2}
|
||
adjacent_face_ids = _int_values(edge_info.get("adjacent_face_ids"))
|
||
if not adjacent_face_ids:
|
||
return None, []
|
||
|
||
for face_id in adjacent_face_ids:
|
||
if face_id < 0 or face_id >= len(self.faces):
|
||
continue
|
||
face_info = self.face_info(face_id)
|
||
if face_info.get("surface") != "cylinder" or "diameter" not in face_info:
|
||
continue
|
||
face_radius = float(face_info.get("radius", 0.0))
|
||
if face_radius <= 1e-9:
|
||
continue
|
||
radius_tolerance = max(current_radius * 0.06, face_radius * 0.06, _shape_diagonal(self.faces[face_id]) * 1e-5, 1e-4)
|
||
if abs(face_radius - current_radius) > radius_tolerance:
|
||
continue
|
||
|
||
feature_guess = str(face_info.get("feature_guess", "cylindrical face"))
|
||
if feature_guess == "round/fillet candidate":
|
||
notes.append(f"相邻圆柱 face {face_id} 更像已有圆角，未自动按孔/凸台直径改边长。")
|
||
continue
|
||
|
||
if feature_guess == "hole/groove candidate":
|
||
mode_order = ("hole",)
|
||
elif feature_guess == "boss/outer-round candidate":
|
||
mode_order = ("boss",)
|
||
else:
|
||
notes.append(f"相邻圆柱 face {face_id} 尚未明确识别为孔/槽或凸台，未自动按圆柱直径改边长。")
|
||
continue
|
||
for mode_index, mode in enumerate(mode_order):
|
||
mode_label = "圆柱凸台直径" if mode == "boss" else "圆柱孔/槽直径"
|
||
try:
|
||
cylinder_plan = (
|
||
self.cylindrical_boss_resize_plan(face_id, target_diameter)
|
||
if mode == "boss"
|
||
else self.cylindrical_resize_plan(face_id, target_diameter)
|
||
)
|
||
except Exception as exc:
|
||
notes.append(f"相邻圆柱 face {face_id} 的{mode_label}计划生成失败：{exc}")
|
||
continue
|
||
|
||
plan_status = str(cylinder_plan.get("status", "blocked"))
|
||
plan_risk = str(cylinder_plan.get("risk", "blocked"))
|
||
if plan_status == "blocked":
|
||
notes.append(f"相邻圆柱 face {face_id} 的{mode_label}不可用：{cylinder_plan.get('message', '')}")
|
||
continue
|
||
|
||
candidate = {
|
||
"resize_strategy": "resize-adjacent-cylinder-from-circular-edge-length",
|
||
"circular_edge_current_radius": current_radius,
|
||
"circular_edge_target_radius": target_radius,
|
||
"circular_edge_length_scale": length_scale,
|
||
"circular_edge_cylinder_face_id": face_id,
|
||
"circular_edge_cylinder_mode": mode,
|
||
"circular_edge_cylinder_mode_label": mode_label,
|
||
"cylinder_resize_face_id": face_id,
|
||
"cylinder_resize_operation": "resize_cylindrical_boss" if mode == "boss" else "resize_cylindrical_hole",
|
||
"cylinder_resize_current_diameter": cylinder_plan.get("current_diameter"),
|
||
"cylinder_resize_target_diameter": target_diameter,
|
||
"cylinder_resize_delta_diameter": cylinder_plan.get("delta_diameter"),
|
||
"cylinder_resize_delta_ratio": cylinder_plan.get("diameter_delta_ratio"),
|
||
"cylinder_resize_status": plan_status,
|
||
"cylinder_resize_risk": plan_risk,
|
||
"cylinder_resize_message": cylinder_plan.get("message"),
|
||
"cylinder_resize_warnings": cylinder_plan.get("warnings", ""),
|
||
"cylinder_resize_blockers": cylinder_plan.get("blockers", ""),
|
||
"cylinder_resize_feature_guess": cylinder_plan.get("feature_guess", feature_guess),
|
||
"cylinder_resize_confidence": cylinder_plan.get("confidence", face_info.get("confidence", "")),
|
||
"cylinder_resize_same_domain_face_ids": cylinder_plan.get("same_domain_face_ids", ()),
|
||
"cylinder_resize_same_domain_face_count": cylinder_plan.get("same_domain_face_count", ""),
|
||
}
|
||
score = (
|
||
status_rank.get(plan_status, 9),
|
||
risk_rank.get(plan_risk, 9),
|
||
mode_index,
|
||
face_id,
|
||
)
|
||
candidates.append((score, candidate))
|
||
|
||
if not candidates:
|
||
if notes:
|
||
notes.insert(0, "圆边没有找到可直接复用的相邻圆柱直径编辑路径，将回退到几何缩放。")
|
||
return None, notes
|
||
|
||
candidates.sort(key=lambda item: item[0])
|
||
return candidates[0][1], notes
|
||
|
||
def _edge_length_affine_axis(
|
||
self,
|
||
edge_info: dict[str, object],
|
||
anchor_mode: str = "auto",
|
||
) -> dict[str, object] | None:
|
||
start = _tuple_or_none(edge_info.get("start_point"))
|
||
end = _tuple_or_none(edge_info.get("end_point"))
|
||
center = _tuple_or_none(edge_info.get("length_center"))
|
||
anchor_mode = self._edge_length_anchor_mode(anchor_mode)
|
||
if start is not None and end is not None:
|
||
direction = _tuple_normalized(_tuple_sub(end, start))
|
||
if direction is not None:
|
||
midpoint = (
|
||
(start[0] + end[0]) * 0.5,
|
||
(start[1] + end[1]) * 0.5,
|
||
(start[2] + end[2]) * 0.5,
|
||
)
|
||
if anchor_mode == "keep-start":
|
||
axis_point = start
|
||
anchor_source = "edge start point"
|
||
elif anchor_mode == "keep-end":
|
||
axis_point = end
|
||
anchor_source = "edge end point"
|
||
else:
|
||
axis_point = center or midpoint
|
||
anchor_source = "edge center"
|
||
return {
|
||
"axis_point": axis_point,
|
||
"axis_direction": direction,
|
||
"axis_source": "edge start/end chord",
|
||
"anchor_source": anchor_source,
|
||
}
|
||
bbox_min = _tuple_or_none(edge_info.get("bbox_min"))
|
||
bbox_max = _tuple_or_none(edge_info.get("bbox_max"))
|
||
if bbox_min is not None and bbox_max is not None:
|
||
sizes = [abs(bbox_max[index] - bbox_min[index]) for index in range(3)]
|
||
axis_index = max(range(3), key=lambda index: sizes[index])
|
||
if sizes[axis_index] > 1e-9:
|
||
direction = [0.0, 0.0, 0.0]
|
||
direction[axis_index] = 1.0
|
||
return {
|
||
"axis_point": center or (
|
||
(bbox_min[0] + bbox_max[0]) * 0.5,
|
||
(bbox_min[1] + bbox_max[1]) * 0.5,
|
||
(bbox_min[2] + bbox_max[2]) * 0.5,
|
||
),
|
||
"axis_direction": tuple(direction),
|
||
"axis_source": "edge bounding-box longest axis",
|
||
"anchor_source": "edge bounding-box center",
|
||
}
|
||
return None
|
||
|
||
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,
|
||
anchor_mode: str = "auto",
|
||
) -> 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]]] = []
|
||
anchor_mode = self._edge_length_anchor_mode(anchor_mode)
|
||
if anchor_mode == "keep-start":
|
||
endpoint_specs = [("终点端", end, _tuple_scale(axis, delta_length))]
|
||
elif anchor_mode == "keep-end":
|
||
endpoint_specs = [("起点端", start, _tuple_scale(axis, -delta_length))]
|
||
elif anchor_mode == "center":
|
||
endpoint_specs = []
|
||
else:
|
||
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),
|
||
}
|
||
]
|
||
|
||
removal = BRepPrimAPI_MakeCylinder(axis, float(plan["boss_tool_outer_radius"]), height).Shape()
|
||
replacement = BRepPrimAPI_MakeCylinder(axis, float(plan["boss_tool_inner_radius"]), height).Shape()
|
||
BRepMesh_IncrementalMesh(removal, deflection)
|
||
BRepMesh_IncrementalMesh(replacement, deflection)
|
||
return [
|
||
{
|
||
"role": "cutter",
|
||
"label": "凸台缩小移除范围预览",
|
||
"polydata": _shape_faces_polydata(removal),
|
||
},
|
||
{
|
||
"role": "fill",
|
||
"label": "凸台缩小重建目标预览",
|
||
"polydata": _shape_faces_polydata(replacement),
|
||
},
|
||
]
|
||
|
||
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,
|
||
bottom_face_id: int | None = None,
|
||
deflection: float = 0.8,
|
||
) -> list[dict[str, object]]:
|
||
plan = self.cylindrical_depth_plan(
|
||
face_id,
|
||
target_depth,
|
||
bottom_face_id=bottom_face_id,
|
||
)
|
||
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,
|
||
anchor_mode: str = "auto",
|
||
):
|
||
plan = self.general_edge_length_plan(edge_id, target_length, anchor_mode=anchor_mode)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
if plan.get("resize_strategy") == "move-edge-end-plane-by-push-pull":
|
||
return self.push_pull_preview_polydata(int(plan["end_face_id"]), float(plan["push_pull_distance"]), deflection)
|
||
if plan.get("resize_strategy") == "resize-adjacent-cylinder-from-circular-edge-length":
|
||
face_id = int(plan["cylinder_resize_face_id"])
|
||
target_diameter = float(plan["cylinder_resize_target_diameter"])
|
||
if plan.get("circular_edge_cylinder_mode") == "boss":
|
||
return self.cylindrical_boss_resize_preview_polydata(face_id, target_diameter, deflection)
|
||
return self.cylindrical_resize_preview_polydata(face_id, target_diameter, deflection)
|
||
preview_shape = self._edge_length_affine_preview_shape(plan)
|
||
BRepMesh_IncrementalMesh(preview_shape, deflection)
|
||
return _shape_faces_polydata(preview_shape)
|
||
|
||
def resize_straight_edge_length(self, edge_id: int, target_length: float, anchor_mode: str = "auto") -> str:
|
||
return self.resize_general_edge_length(edge_id, target_length, anchor_mode=anchor_mode)
|
||
|
||
def resize_general_edge_length(self, edge_id: int, target_length: float, anchor_mode: str = "auto") -> str:
|
||
plan = self.general_edge_length_plan(edge_id, target_length, anchor_mode=anchor_mode)
|
||
if plan["status"] == "blocked":
|
||
raise ValueError(str(plan["message"]))
|
||
if plan.get("resize_strategy") == "move-edge-end-plane-by-push-pull":
|
||
push_result = self.push_pull_face(int(plan["end_face_id"]), float(plan["push_pull_distance"]))
|
||
return (
|
||
"Edge length resize completed by end-face push/pull: "
|
||
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"anchor={plan.get('edge_length_anchor_label')}, "
|
||
f"risk={plan['risk']}. {push_result}"
|
||
)
|
||
|
||
if plan.get("resize_strategy") == "resize-adjacent-cylinder-from-circular-edge-length":
|
||
face_id = int(plan["cylinder_resize_face_id"])
|
||
target_diameter = float(plan["cylinder_resize_target_diameter"])
|
||
if plan.get("circular_edge_cylinder_mode") == "boss":
|
||
resize_result = self.resize_cylindrical_boss(face_id, target_diameter)
|
||
else:
|
||
resize_result = self.resize_cylindrical_hole(face_id, target_diameter)
|
||
return (
|
||
"Edge length resize completed by adjacent cylinder diameter edit: "
|
||
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"cylinder_face={face_id}, "
|
||
f"target_diameter={target_diameter:g}, "
|
||
f"mode={plan.get('circular_edge_cylinder_mode_label')}, "
|
||
f"risk={plan['risk']}. {resize_result}"
|
||
)
|
||
|
||
self._apply_edge_length_affine_transform(plan)
|
||
return (
|
||
"Edge length resize completed by geometric scale fallback: "
|
||
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"scale={float(plan['affine_scale']):g}, "
|
||
f"axis_source={plan.get('affine_axis_source')}, "
|
||
f"anchor={plan.get('edge_length_anchor_label')}, "
|
||
f"target={plan.get('affine_target_kind')}, "
|
||
f"risk={plan['risk']}."
|
||
)
|
||
|
||
def _edge_length_affine_preview_shape(self, plan: dict[str, object]) -> TopoDS_Shape:
|
||
target_kind, source_shape, _part, _solid = self._edge_length_affine_target(plan)
|
||
return self._affine_scaled_shape_along_edge(source_shape, plan)
|
||
|
||
def _apply_edge_length_affine_transform(self, plan: dict[str, object]) -> None:
|
||
target_kind, source_shape, part, solid = self._edge_length_affine_target(plan)
|
||
transformed = self._affine_scaled_shape_along_edge(source_shape, plan)
|
||
_ensure_valid_shape(transformed)
|
||
if target_kind == "part":
|
||
part.shape = transformed
|
||
else:
|
||
part_solids = _explore(part.shape, TopAbs_SOLID)
|
||
replaced = False
|
||
shapes: list[TopoDS_Shape] = []
|
||
for item in part_solids:
|
||
if not replaced and _same_shape(item, solid):
|
||
shapes.append(transformed)
|
||
replaced = True
|
||
else:
|
||
shapes.append(item)
|
||
if not replaced:
|
||
raise RuntimeError(f"Could not locate solid {plan.get('solid_id')} inside part {plan.get('part_id')}.")
|
||
part.shape = _compound_from_shapes(shapes)
|
||
_ensure_valid_shape(part.shape)
|
||
self.refresh_topology()
|
||
|
||
def _edge_length_affine_target(
|
||
self,
|
||
plan: dict[str, object],
|
||
) -> tuple[str, TopoDS_Shape, object, TopoDS_Shape | None]:
|
||
part_id = int(plan.get("part_id", -1))
|
||
solid_id = int(plan.get("solid_id", -1))
|
||
part = self.part_by_id(part_id)
|
||
if part is None:
|
||
raise ValueError(f"Unknown part id {part_id}")
|
||
target_kind = str(plan.get("affine_target_kind", "part"))
|
||
if target_kind == "solid" and 0 <= solid_id < len(self.solids):
|
||
return target_kind, self.solids[solid_id][1], part, self.solids[solid_id][1]
|
||
return "part", part.shape, part, None
|
||
|
||
def _affine_scaled_shape_along_edge(self, shape: TopoDS_Shape, plan: dict[str, object]) -> TopoDS_Shape:
|
||
axis_point = _tuple_or_none(plan.get("affine_axis_point"))
|
||
axis_direction = _tuple_normalized(_tuple_or_none(plan.get("affine_axis_direction")))
|
||
scale = float(plan.get("affine_scale", 1.0))
|
||
transform_kind = str(plan.get("affine_transform_kind", "axis-affine"))
|
||
if axis_point is None:
|
||
raise ValueError("Missing affine edge-length axis.")
|
||
if transform_kind == "uniform":
|
||
transform = gp_Trsf()
|
||
transform.SetScale(gp_Pnt(*axis_point), scale)
|
||
builder = BRepBuilderAPI_Transform(shape, transform, True)
|
||
builder.Build()
|
||
if not builder.IsDone():
|
||
raise RuntimeError("Uniform edge-length scale transform failed.")
|
||
result = builder.Shape()
|
||
if result.IsNull():
|
||
raise RuntimeError("Uniform edge-length scale transform produced an empty shape.")
|
||
return result
|
||
|
||
if axis_direction is None:
|
||
raise ValueError("Missing affine edge-length axis direction.")
|
||
ux, uy, uz = axis_direction
|
||
matrix = [
|
||
[1.0 + (scale - 1.0) * ux * ux, (scale - 1.0) * ux * uy, (scale - 1.0) * ux * uz],
|
||
[(scale - 1.0) * uy * ux, 1.0 + (scale - 1.0) * uy * uy, (scale - 1.0) * uy * uz],
|
||
[(scale - 1.0) * uz * ux, (scale - 1.0) * uz * uy, 1.0 + (scale - 1.0) * uz * uz],
|
||
]
|
||
cx, cy, cz = axis_point
|
||
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("Affine edge-length transform failed.")
|
||
result = builder.Shape()
|
||
if result.IsNull():
|
||
raise RuntimeError("Affine edge-length transform produced an empty shape.")
|
||
return 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)
|
||
boundary_edge_ids = self._region_boundary_edge_ids(scope_face_ids)
|
||
side_face_ids = sorted(
|
||
set(self._adjacent_face_ids_for_edges(boundary_edge_ids, face_id)) - set(scope_face_ids)
|
||
)
|
||
side_region_mapping_specs = self._face_region_mapping_specs(side_face_ids)
|
||
|
||
cap_extension = self._cylindrical_cap_extension_plan(face_id, distance, outward)
|
||
if cap_extension is not None:
|
||
op = BRepAlgoAPI_Fuse(part.shape, cap_extension["tool_shape"])
|
||
result = _finalize_boolean_result(op, "cylindrical cap push/pull")
|
||
result = _cleanup_push_pull_result(result, part.shape, profile_shape, distance)
|
||
part.shape = result
|
||
self.refresh_topology()
|
||
self._apply_face_region_mapping_specs(side_region_mapping_specs)
|
||
return (
|
||
"Planar face push/pull completed: cylindrical cap extension, "
|
||
f"semantic_distance={distance:g}, "
|
||
f"radius={float(cap_extension['radius']):g}, "
|
||
f"old_height={float(cap_extension['old_height']):g}, "
|
||
f"new_height={float(cap_extension['new_height']):g}, "
|
||
f"side_faces={cap_extension['side_face_ids']}, "
|
||
f"outward_direction={_format_tuple(outward)}, "
|
||
f"direction_confidence={plan['direction_confidence']}, "
|
||
f"risk={plan['risk']}."
|
||
)
|
||
|
||
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()
|
||
self._apply_face_region_mapping_specs(side_region_mapping_specs)
|
||
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 _cylindrical_cap_extension_plan(
|
||
self,
|
||
face_id: int,
|
||
distance: float,
|
||
outward: tuple[float, float, float],
|
||
) -> dict[str, object] | None:
|
||
if distance <= 0:
|
||
return None
|
||
if face_id < 0 or face_id >= len(self.faces):
|
||
return None
|
||
|
||
cap_center = _surface_center(self.faces[face_id])
|
||
boundary_edge_ids = self._face_boundary_edge_ids(face_id)
|
||
adjacent_face_ids = self._adjacent_face_ids_for_edges(boundary_edge_ids, face_id)
|
||
if not adjacent_face_ids:
|
||
return None
|
||
|
||
diagonal = _shape_diagonal(self.shape)
|
||
tolerance = min(max(diagonal * 1e-7, 1e-6), 1e-3)
|
||
outward_dir = gp_Dir(float(outward[0]), float(outward[1]), float(outward[2]))
|
||
best: tuple[float, dict[str, object]] | None = None
|
||
|
||
for adjacent_id in adjacent_face_ids:
|
||
side_surf = BRepAdaptor_Surface(self.faces[adjacent_id])
|
||
if side_surf.GetType() != GeomAbs_Cylinder:
|
||
continue
|
||
angular_span = abs(side_surf.LastUParameter() - side_surf.FirstUParameter())
|
||
if angular_span < math.tau * 0.92:
|
||
continue
|
||
|
||
cylinder = side_surf.Cylinder()
|
||
radius = float(cylinder.Radius())
|
||
axis = cylinder.Axis()
|
||
axis_point = axis.Location()
|
||
axis_dir = axis.Direction()
|
||
axis_alignment = _direction_dot(outward_dir, axis_dir)
|
||
if abs(axis_alignment) < 0.92:
|
||
continue
|
||
if _point_axis_distance(axis_point, axis_dir, cap_center) > max(radius * 0.08, tolerance * 10.0):
|
||
continue
|
||
|
||
axis_range = self._cylindrical_axis_range(adjacent_id, side_surf)
|
||
v_min = float(axis_range["v_min"])
|
||
v_max = float(axis_range["v_max"])
|
||
old_height = max(v_max - v_min, 1e-9)
|
||
cap_parameter = _axis_parameter(axis_point, axis_dir, cap_center)
|
||
start_distance = abs(cap_parameter - v_min)
|
||
end_distance = abs(cap_parameter - v_max)
|
||
end_tolerance = max(old_height * 0.05, radius * 0.2, tolerance * 10.0, 0.05)
|
||
|
||
if axis_alignment > 0 and end_distance <= end_tolerance:
|
||
new_min = v_min
|
||
new_max = v_max + distance
|
||
end_score = end_distance
|
||
elif axis_alignment < 0 and start_distance <= end_tolerance:
|
||
new_min = v_min - distance
|
||
new_max = v_max
|
||
end_score = start_distance
|
||
else:
|
||
continue
|
||
|
||
height = max(new_max - new_min, 1e-6)
|
||
start = _point_on_axis(axis_point, axis_dir, new_min)
|
||
tool_shape = BRepPrimAPI_MakeCylinder(gp_Ax2(start, gp_Dir(axis_dir.X(), axis_dir.Y(), axis_dir.Z())), radius, height).Shape()
|
||
score = end_score + _point_axis_distance(axis_point, axis_dir, cap_center)
|
||
candidate = {
|
||
"tool_shape": tool_shape,
|
||
"side_face_ids": axis_range["same_domain_face_ids"],
|
||
"radius": radius,
|
||
"old_height": old_height,
|
||
"new_height": height,
|
||
"axis_alignment": axis_alignment,
|
||
"cap_axis_parameter": cap_parameter,
|
||
"start_parameter": new_min,
|
||
"end_parameter": new_max,
|
||
}
|
||
if best is None or score < best[0]:
|
||
best = (score, candidate)
|
||
|
||
return best[1] if best is not None else None
|
||
|
||
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:
|
||
removal = BRepPrimAPI_MakeCylinder(axis, float(plan["boss_tool_outer_radius"]), height).Shape()
|
||
replacement = BRepPrimAPI_MakeCylinder(axis, float(plan["boss_tool_inner_radius"]), height).Shape()
|
||
remove_op = BRepAlgoAPI_Cut(part.shape, removal)
|
||
removed = _finalize_boolean_result(remove_op, "cylindrical boss shrink remove envelope")
|
||
if _topology_shape_count(removed, TopAbs_FACE) == 0:
|
||
exact_start = gp_Pnt(*plan["boss_tool_exact_start_point"])
|
||
exact_axis = gp_Ax2(exact_start, direction)
|
||
exact_replacement = BRepPrimAPI_MakeCylinder(
|
||
exact_axis,
|
||
float(plan["boss_tool_inner_radius"]),
|
||
float(plan["boss_tool_exact_height"]),
|
||
).Shape()
|
||
result = _ensure_valid_or_repaired_shape(exact_replacement, "cylindrical boss shrink replacement")
|
||
else:
|
||
fuse_op = BRepAlgoAPI_Fuse(removed, replacement)
|
||
result = _finalize_boolean_result(fuse_op, "cylindrical boss shrink rebuild")
|
||
action = "shrunk by removing old envelope and fusing target cylinder"
|
||
|
||
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,
|
||
bottom_face_id: int | None = None,
|
||
) -> str:
|
||
plan = self.cylindrical_depth_plan(
|
||
face_id,
|
||
target_depth,
|
||
bottom_face_id=bottom_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}")
|
||
|
||
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}."
|
||
)
|
||
|