263 lines
13 KiB
Python
263 lines
13 KiB
Python
"""Extrusion/termination-condition planning for the session runtime.
|
|
|
|
These helpers turn a CDSL feature's end condition (blind, mid-plane,
|
|
through-all, up-to-surface, ...) into one or more :class:`ExtentVector`
|
|
displacements. They depend on the session only through its adapter and
|
|
selector resolution, never on executors.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import math
|
|
from typing import TYPE_CHECKING, Any
|
|
|
|
from .runtime_base import ExtentVector, FeatureExecutionError
|
|
from .specs import PlaneSpec, Vector3, vector_dot, vector_scale, vector_subtract, vector_unit
|
|
from .topology import FeaturePlanNode
|
|
|
|
if TYPE_CHECKING: # pragma: no cover - import for type checkers only
|
|
from .session import ExecutionSession
|
|
|
|
|
|
def _normal_from_sketch(sketch: dict[str, Any]) -> Vector3:
|
|
return PlaneSpec.from_mapping(sketch.get("workplane") or {}).normal
|
|
|
|
|
|
def _extent_reference(node: FeaturePlanNode, condition: dict[str, Any] | None = None) -> dict[str, Any]:
|
|
condition = condition or node.params.get("end_condition") or {}
|
|
reference = condition.get("reference")
|
|
if not isinstance(reference, dict):
|
|
raise FeatureExecutionError(
|
|
"missing_extent_reference",
|
|
"This end condition requires a captured target selector",
|
|
extent=condition.get("type"),
|
|
)
|
|
return reference
|
|
|
|
|
|
def _targeted_extent_vector(
|
|
node: FeaturePlanNode,
|
|
faces: list[Any],
|
|
direction: Vector3,
|
|
session: "ExecutionSession",
|
|
condition: str,
|
|
*,
|
|
end_condition: dict[str, Any] | None = None,
|
|
offset_mm: float | None = None,
|
|
) -> ExtentVector:
|
|
reference = _extent_reference(node, end_condition) if condition != "through_next" else None
|
|
source_vertex_point: Vector3 | None = None
|
|
if condition == "up_to_vertex" and isinstance(reference, dict) and reference.get("kind") == "source_vertex":
|
|
raw_point = reference.get("point_mm")
|
|
if not (
|
|
isinstance(raw_point, list)
|
|
and len(raw_point) == 3
|
|
and all(isinstance(value, (int, float)) and math.isfinite(float(value)) for value in raw_point)
|
|
):
|
|
raise FeatureExecutionError(
|
|
"invalid_source_vertex_extent",
|
|
"The source-vertex extent datum must contain one finite 3D point",
|
|
extent=condition,
|
|
)
|
|
source_vertex_point = (float(raw_point[0]), float(raw_point[1]), float(raw_point[2]))
|
|
elif session.body is None:
|
|
raise FeatureExecutionError("missing_extent_body", "Selector-dependent extent requires an existing body", extent=condition)
|
|
if condition == "through_next":
|
|
target = session.body
|
|
elif source_vertex_point is not None:
|
|
target = None
|
|
else:
|
|
assert isinstance(reference, dict)
|
|
resolution = session.resolve(reference)
|
|
if resolution.status != "resolved" or resolution.record is None:
|
|
raise ValueError(resolution.diagnostic.message if resolution.diagnostic else "extent target was not resolved")
|
|
expected_kind = {"up_to_vertex": "vertex", "up_to_body": "body"}.get(condition, "face")
|
|
if resolution.record.kind != expected_kind:
|
|
raise FeatureExecutionError(
|
|
"unsupported_extent_target",
|
|
"The resolved target kind is incompatible with this end condition",
|
|
extent=condition, expected_kind=expected_kind, actual_kind=resolution.record.kind,
|
|
)
|
|
target = resolution.record.value
|
|
if condition == "up_to_vertex":
|
|
target_point = source_vertex_point or session.adapter.vertex_coordinates(target)
|
|
projections = [
|
|
vector_dot(vector_subtract(target_point, point), direction)
|
|
for face in faces
|
|
for point in session.adapter.profile_sample_points(face)
|
|
]
|
|
if not projections or min(projections) <= 1e-6:
|
|
raise FeatureExecutionError("extent_target_not_in_direction", "The target vertex is not ahead of the profile", extent=condition)
|
|
if max(projections) - min(projections) > 1e-5:
|
|
raise FeatureExecutionError("non_uniform_extent_target", "The target vertex does not define one extrusion distance", extent=condition)
|
|
distance = sum(projections) / len(projections)
|
|
else:
|
|
if condition == "up_to_surface" and session.adapter.profile_touches_target(target, faces):
|
|
# 草图轮廓本身就在所选终止面上时，selected face 只是拉伸的起始
|
|
# 边界。应沿实际拉伸方向穿过当前 body，取下一张完整截获 profile
|
|
# 的边界面作为终止面；直接裁剪到 selected face 会生成零厚度工具体。
|
|
try:
|
|
next_face = session.adapter.next_body_face_after(
|
|
session.body, faces, direction, excluded_face=target,
|
|
)
|
|
except ValueError as error:
|
|
raise FeatureExecutionError("extent_target_not_reached", str(error), extent=condition) from error
|
|
return ExtentVector(vector_scale(direction, 1.0), trim_to=next_face)
|
|
try:
|
|
distance = session.adapter.uniform_intersection_distance(target, faces, direction)
|
|
except ValueError as error:
|
|
message = str(error)
|
|
if condition == "up_to_surface" and message == "extent target is not reached by every profile ray":
|
|
# Do not reinterpret a partially hit finite face: that path
|
|
# has explicit trimmed-solid semantics below. Only a wholly
|
|
# unreachable planar face may terminate on its supporting
|
|
# plane, and the adapter proves one positive, uniform
|
|
# profile-to-plane distance before returning it.
|
|
if not session.adapter.target_has_forward_intersection(target, faces, direction):
|
|
try:
|
|
distance = session.adapter.uniform_planar_supporting_surface_distance(target, faces, direction)
|
|
except ValueError:
|
|
pass
|
|
else:
|
|
return ExtentVector(vector_scale(direction, distance))
|
|
code = "non_uniform_extent_target" if "non-uniform" in message else "extent_target_not_reached"
|
|
if condition in {"up_to_surface", "through_next"}:
|
|
# #5 高级终止条件：profile 与目标面非均匀相交（部分采样点未
|
|
# 命中目标 → 悬空；或各点命中距离不一 → 斜目标面）时不再整体
|
|
# 拒绝，而是"裁剪"——只保留从 profile 到目标面之间的材料。
|
|
# extrude_trimmed 内部做穿透拉伸 + 与目标面体层布尔求交，未达
|
|
# 目标的部分被切掉（CAD "拉伸到面"标准语义）。若全部采样点都
|
|
# 未命中（profile 与目标面无交叠），extrude_trimmed 内部仍抛
|
|
# "not reached"，保持显式拒绝。
|
|
# through_next 从当前主体中选取实际命中的下一张面；
|
|
# up_to_vertex/up_to_body/offset_from_surface 无 face 可构造
|
|
# 裁剪体层，仍保持显式拒绝。
|
|
return ExtentVector(vector_scale(direction, 1.0), trim_to=target)
|
|
raise FeatureExecutionError(code, message, extent=condition) from error
|
|
offset = abs(float((end_condition or {}).get("offset_mm") or 0.0))
|
|
if condition == "offset_from_surface":
|
|
offset = abs(float(offset_mm if offset_mm is not None else offset or node.params.get("distance_mm") or 0.0))
|
|
if offset:
|
|
distance -= offset
|
|
if distance <= 1e-6:
|
|
raise FeatureExecutionError(
|
|
"invalid_extent_offset",
|
|
"Offset distance reaches or passes the target extent",
|
|
extent=condition, offset_mm=offset,
|
|
)
|
|
return ExtentVector(vector_scale(direction, distance))
|
|
|
|
|
|
def _side_extent_vectors(
|
|
node: FeaturePlanNode,
|
|
faces: list[Any],
|
|
direction: Vector3,
|
|
session: "ExecutionSession",
|
|
*,
|
|
end_condition: dict[str, Any],
|
|
distance_mm: float,
|
|
) -> list[ExtentVector]:
|
|
"""Resolve one directional extent without borrowing the opposite side.
|
|
|
|
``extrude_add_two_sided`` and ``extrude_cut_two_sided`` call this once for each independently captured
|
|
termination. The regular one-sided executor also uses it for all simple
|
|
termination modes, keeping the geometry adapter interface uniform.
|
|
"""
|
|
condition = str(end_condition.get("type") or "blind")
|
|
distance = abs(float(distance_mm or 0.0))
|
|
if condition == "blind":
|
|
if distance <= 0:
|
|
raise ValueError("blind extent requires distance_mm > 0")
|
|
return [ExtentVector(vector_scale(direction, distance))]
|
|
if condition == "mid_plane":
|
|
if distance <= 0:
|
|
raise ValueError("mid_plane extent requires distance_mm > 0")
|
|
return [
|
|
ExtentVector(vector_scale(direction, distance / 2)),
|
|
ExtentVector(vector_scale(direction, -distance / 2)),
|
|
]
|
|
if condition == "through_all":
|
|
if session.body is None:
|
|
if distance <= 0:
|
|
raise ValueError("through_all on an initial feature has no body and no fallback distance")
|
|
# 注意：Vector3 是 tuple，不能直接做 direction * distance（那是元组
|
|
# 重复），这里必须用 vector_scale 做数乘（顺带修复的隐藏 bug）。
|
|
return [ExtentVector(vector_scale(direction, distance))]
|
|
return [ExtentVector(vector_scale(direction, max(session.adapter.body_span(session.body, direction), 1.0) + 2.0))]
|
|
if condition in {"up_to_surface", "up_to_vertex", "offset_from_surface", "through_next", "up_to_body"}:
|
|
return [
|
|
_targeted_extent_vector(
|
|
node, faces, direction, session, condition,
|
|
end_condition=end_condition, offset_mm=distance,
|
|
)
|
|
]
|
|
raise ValueError(f"unsupported directional extent {condition!r}")
|
|
|
|
|
|
def _extent_vectors(
|
|
node: FeaturePlanNode,
|
|
faces: list[Any],
|
|
sketch: dict[str, Any],
|
|
session: "ExecutionSession",
|
|
) -> list[ExtentVector]:
|
|
return _extent_vectors_from_normal(
|
|
node, faces, vector_unit(_normal_from_sketch(sketch), field_name="sketch normal"), session,
|
|
)
|
|
|
|
|
|
def _extent_vectors_from_normal(
|
|
node: FeaturePlanNode,
|
|
faces: list[Any],
|
|
profile_normal: Vector3,
|
|
session: "ExecutionSession",
|
|
) -> list[ExtentVector]:
|
|
"""Resolve extents from an explicit profile normal.
|
|
|
|
A derived profile can be an actual B-rep face rather than a sketch. Its
|
|
outward normal is just as authoritative as a sketch workplane normal, so
|
|
both profile sources share the same bounded extent semantics.
|
|
"""
|
|
params = node.params
|
|
normal = vector_unit(profile_normal, field_name="profile normal")
|
|
if bool(params.get("reverse")):
|
|
normal = vector_scale(normal, -1)
|
|
end_condition = params.get("end_condition") or {"type": "blind"}
|
|
condition = end_condition.get("type", "blind")
|
|
distance = abs(float(params.get("distance_mm") or 0.0))
|
|
if node.atomic_id in {"extrude_add_two_sided", "extrude_cut_two_sided"} or bool(params.get("two_sided")):
|
|
reverse_condition = params.get("reverse_end_condition") or {"type": "blind"}
|
|
reverse_distance = abs(float(params.get("reverse_distance_mm") or 0.0))
|
|
if reverse_distance <= 0:
|
|
raise ValueError("two-sided extrusion requires reverse_distance_mm > 0")
|
|
return [
|
|
*_side_extent_vectors(
|
|
node, faces, normal, session, end_condition=end_condition, distance_mm=distance,
|
|
),
|
|
*_side_extent_vectors(
|
|
node, faces, vector_scale(normal, -1), session,
|
|
end_condition=reverse_condition, distance_mm=reverse_distance,
|
|
),
|
|
]
|
|
if condition in {"through_all", "through_all_both", "through_all_and_blind"}:
|
|
if session.body is None:
|
|
# A first feature with through-all has no body to terminate
|
|
# against. The source must provide a usable blind component.
|
|
if distance <= 0:
|
|
raise ValueError("through_all on an initial feature has no body and no fallback distance")
|
|
return [ExtentVector(vector_scale(normal, distance))]
|
|
span = max(session.adapter.body_span(session.body, normal), 1.0) + 2.0
|
|
if condition == "through_all":
|
|
return [ExtentVector(vector_scale(normal, span))]
|
|
if condition == "through_all_both":
|
|
return [ExtentVector(vector_scale(normal, span)), ExtentVector(vector_scale(normal, -span))]
|
|
# Through-all-and-blind is represented by a through direction plus
|
|
# its captured opposite blind direction when available.
|
|
reverse_distance = abs(float(params.get("reverse_distance_mm") or 0.0))
|
|
return [
|
|
ExtentVector(vector_scale(normal, span)),
|
|
ExtentVector(vector_scale(normal, -(reverse_distance or span))),
|
|
]
|
|
return _side_extent_vectors(
|
|
node, faces, normal, session, end_condition=end_condition, distance_mm=distance,
|
|
)
|