feat(cadfs): 补齐核心建模能力并建立代表性回归
- 新增 loft、双向切除、through-all/up-to-next 等 CADFS lowering 与 engine 支持 - 支持多种 reference plane、B-spline profile 和 circular pattern replay - 保留 transform 历史，并烘焙安全的单源平移/旋转变换 - 改进 selector 绑定、拓扑快照和 pattern 变换处理 - 建立 17 个代表样本的转换、重建与比较回归工具链 - 补充 schema、author guidance、运行时和几何回归测试
This commit is contained in:
+416
-18
@@ -8,7 +8,7 @@ from .ir import Call, FeatureIR, ModelIR, SketchIR
|
||||
from .query_parser import parse_query, walk_calls
|
||||
|
||||
|
||||
UNSUPPORTED = {"shell", "loft", "sweep", "draft", "thicken", "split", "booleanBodies", "circularPattern", "moveFace", "replaceFace", "deleteFace", "import", "derive"}
|
||||
UNSUPPORTED = {"shell", "sweep", "draft", "thicken", "split", "booleanBodies", "moveFace", "replaceFace", "deleteFace", "import", "derive"}
|
||||
PLANES = {
|
||||
"Top": {"origin_mm": [0., 0., 0.], "x_dir": [1., 0., 0.], "normal": [0., 0., 1.]},
|
||||
"Front": {"origin_mm": [0., 0., 0.], "x_dir": [1., 0., 0.], "normal": [0., -1., 0.]},
|
||||
@@ -65,6 +65,43 @@ def _cross(a: list[float], b: list[float]) -> list[float]:
|
||||
return [a[1]*b[2]-a[2]*b[1], a[2]*b[0]-a[0]*b[2], a[0]*b[1]-a[1]*b[0]]
|
||||
|
||||
|
||||
def _dot(a: list[float], b: list[float]) -> float: return sum(left * right for left, right in zip(a, b))
|
||||
|
||||
|
||||
def _unit(value: list[float], message: str) -> list[float]:
|
||||
length = math.sqrt(_dot(value, value))
|
||||
if length <= 1e-9: raise ValueError(message)
|
||||
return [component / length for component in value]
|
||||
|
||||
|
||||
def _sub(a: list[float], b: list[float]) -> list[float]: return [a[index] - b[index] for index in range(3)]
|
||||
|
||||
|
||||
def _rotate(value: list[float], axis: list[float], angle_rad: float) -> list[float]:
|
||||
axis = _unit(axis, "rotation axis is degenerate")
|
||||
cosine, sine = math.cos(angle_rad), math.sin(angle_rad)
|
||||
cross = _cross(axis, value); projection = _dot(axis, value) * (1.0 - cosine)
|
||||
return [value[index] * cosine + cross[index] * sine + axis[index] * projection for index in range(3)]
|
||||
|
||||
|
||||
def _translate_frame(frame: dict[str, Any], offset: list[float]) -> dict[str, Any]:
|
||||
return {**frame, "origin_mm": [frame["origin_mm"][index] + offset[index] for index in range(3)]}
|
||||
|
||||
|
||||
def _rotate_point(point: list[float], axis: dict[str, list[float]], angle_rad: float) -> list[float]:
|
||||
relative = _rotate(_sub(point, axis["origin_mm"]), axis["direction"], angle_rad)
|
||||
return [axis["origin_mm"][index] + relative[index] for index in range(3)]
|
||||
|
||||
|
||||
def _rotate_frame(frame: dict[str, Any], axis: dict[str, list[float]], angle_rad: float) -> dict[str, Any]:
|
||||
return {
|
||||
**frame,
|
||||
"origin_mm": _rotate_point(frame["origin_mm"], axis, angle_rad),
|
||||
"x_dir": _rotate(frame["x_dir"], axis["direction"], angle_rad),
|
||||
"normal": _rotate(frame["normal"], axis["direction"], angle_rad),
|
||||
}
|
||||
|
||||
|
||||
def _y_dir(plane: dict[str, Any]) -> list[float]: return _cross(plane["normal"], plane["x_dir"])
|
||||
|
||||
|
||||
@@ -81,6 +118,12 @@ def _oriented_plane(plane: dict[str, Any], normal_sign: float, distance: float =
|
||||
return {**shifted, "normal": [normal_sign * value for value in plane["normal"]]}
|
||||
|
||||
|
||||
def _frame(origin: list[float], x_dir: list[float], normal: list[float]) -> dict[str, list[float]]:
|
||||
normal = _unit(normal, "reference plane normal is degenerate")
|
||||
x_dir = _sub(x_dir, [normal[index] * _dot(x_dir, normal) for index in range(3)])
|
||||
return {"origin_mm": origin, "x_dir": _unit(x_dir, "reference plane x direction is degenerate"), "normal": normal}
|
||||
|
||||
|
||||
def _plane_from_query(value: Any, feature_frames: dict[str, dict[str, Any]], sketch_by_source: dict[str, dict[str, Any]] | None = None) -> dict[str, Any]:
|
||||
for call in walk_calls(value):
|
||||
if call.name in {"makeId", "qCreatedBy"}:
|
||||
@@ -107,6 +150,7 @@ def _end_condition(value: Any) -> dict[str, Any]:
|
||||
if name == "BLIND": return {"type": "blind", "solidworks_code": 0}
|
||||
if name == "SYMMETRIC": return {"type": "mid_plane", "solidworks_code": 8}
|
||||
if name == "THROUGH_ALL": return {"type": "through_all", "solidworks_code": 1}
|
||||
if name == "UP_TO_NEXT": return {"type": "through_next", "solidworks_code": 4}
|
||||
raise UnsupportedCapability(f"extrude_extent:{name.lower()}", f"current CDSL atomic set has no exact extrusion operation for {name}")
|
||||
|
||||
|
||||
@@ -137,12 +181,13 @@ def _contours(segments: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], lis
|
||||
if _endpoint(item, True) == tail:
|
||||
item["start"], item["end"] = item["end"], item["start"]
|
||||
if item["type"] == "arc": item["clockwise"] = not item["clockwise"]
|
||||
elif item["type"] == "bspline": item["points"] = list(reversed(item["points"]))
|
||||
contour.append(item); tail = _endpoint(item, True)
|
||||
if tail == first: contours.append({"role": "unknown", "closed": True, "segments": contour})
|
||||
return contours + circles, construction
|
||||
|
||||
|
||||
def _lower_sketch(sketch: SketchIR, plane: dict[str, Any]) -> tuple[dict[str, Any], dict[str, dict[str, Any]]]:
|
||||
def _lower_sketch(sketch: SketchIR, plane: dict[str, Any], allow_open: bool = False) -> tuple[dict[str, Any], dict[str, dict[str, Any]]]:
|
||||
segments: list[dict[str, Any]] = []; explicit_construction: list[dict[str, Any]] = []; entities: dict[str, dict[str, Any]] = {}; unsupported = []
|
||||
for entity in sketch.entities:
|
||||
p = entity.params
|
||||
@@ -150,6 +195,10 @@ def _lower_sketch(sketch: SketchIR, plane: dict[str, Any]) -> tuple[dict[str, An
|
||||
if entity.operation == "skLineSegment": item = {"type": "line", "start": _point(p["start"]), "end": _point(p["end"])}
|
||||
elif entity.operation == "skCircle": item = {"type": "circle", "center": _point(p["center"]), "radius_mm": _number(p["radius"], True)}
|
||||
elif entity.operation == "skArc": item = _arc(_point(p["start"]), _point(p["mid"]), _point(p["end"]))
|
||||
elif entity.operation == "skFitSpline":
|
||||
points = [_point(point) for point in p.get("points") or []]
|
||||
if len(points) < 3: raise ValueError("fit spline needs at least 3 points")
|
||||
item = {"type": "bspline", "start": points[0], "end": points[-1], "points": points}
|
||||
else: unsupported.append(entity.operation); continue
|
||||
(explicit_construction if _bool(p.get("construction")) else segments).append(item); entities[entity.feature_id] = item
|
||||
if unsupported: raise ValueError("unsupported sketch entities: " + ",".join(sorted(set(unsupported))))
|
||||
@@ -162,7 +211,9 @@ def _lower_sketch(sketch: SketchIR, plane: dict[str, Any]) -> tuple[dict[str, An
|
||||
else:
|
||||
contours, open_segments = _contours(segments)
|
||||
if open_segments:
|
||||
raise ValueError(f"sketch has {len(open_segments)} open non-construction segment(s)")
|
||||
if not allow_open: raise ValueError(f"sketch has {len(open_segments)} open non-construction segment(s)")
|
||||
profile = {"type": "analytic_contours", "contours": [], "construction": explicit_construction + open_segments}
|
||||
return {"id": f"sketch_{sketch.feature_id}", "name": sketch.feature_id, "workplane": plane, "profile": profile, "role": "reference"}, entities
|
||||
construction = list(explicit_construction)
|
||||
if not contours:
|
||||
profile = {"type": "analytic_contours", "contours": [], "construction": construction}
|
||||
@@ -193,6 +244,89 @@ def _source_sketch(params: dict[str, Any]) -> str | None:
|
||||
return None
|
||||
|
||||
|
||||
def _pattern_source_features(value: Any, previous: list[str]) -> list[str]:
|
||||
sources = []
|
||||
for call in walk_calls(value):
|
||||
if call.name != "makeQuery" or not call.args:
|
||||
continue
|
||||
owner = symbolic_string(call.args[0])
|
||||
if "F" not in owner:
|
||||
continue
|
||||
source = "f_" + owner[owner.find("F"):].split(".", 1)[0]
|
||||
if source in previous and source not in sources:
|
||||
sources.append(source)
|
||||
if not sources:
|
||||
raise ValueError("pattern source features are unresolved")
|
||||
return sources
|
||||
|
||||
|
||||
def _transform_source_features(value: Any, previous: list[str]) -> list[str]:
|
||||
sources = []
|
||||
for call in walk_calls(value):
|
||||
if call.name not in {"makeQuery", "qCreatedBy"} or not call.args:
|
||||
continue
|
||||
owner = symbolic_string(call.args[0])
|
||||
if "F" not in owner:
|
||||
continue
|
||||
source = "f_" + owner[owner.find("F"):].split(".", 1)[0]
|
||||
if source in previous and source not in sources:
|
||||
sources.append(source)
|
||||
if not sources:
|
||||
raise ValueError("transform source features are unresolved")
|
||||
return sources
|
||||
|
||||
|
||||
def _circular_pattern_axis(
|
||||
value: Any,
|
||||
feature_frames: dict[str, dict[str, Any]],
|
||||
sketch_by_source: dict[str, dict[str, Any]],
|
||||
entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
|
||||
) -> dict[str, list[float]]:
|
||||
query = parse_query(value)
|
||||
entity = (entity_by_sketch.get(query.source_sketch or "") or {}).get(query.source_entity or "")
|
||||
if entity is None or query.source_sketch not in sketch_by_source:
|
||||
raise ValueError("circular pattern axis is unresolved")
|
||||
plane = sketch_by_source[query.source_sketch]["workplane"]
|
||||
if entity["type"] == "line":
|
||||
start = _global(plane, entity["start"]); end = _global(plane, entity["end"])
|
||||
direction = [end[index] - start[index] for index in range(3)]
|
||||
norm = math.sqrt(sum(component * component for component in direction))
|
||||
if norm <= 1e-9:
|
||||
raise ValueError("circular pattern axis line is degenerate")
|
||||
return {"origin_mm": start, "direction": [component / norm for component in direction]}
|
||||
if entity["type"] == "circle":
|
||||
frame = feature_frames.get(query.owner_feature or "")
|
||||
if frame and query.is_start is not None:
|
||||
plane = frame["start" if query.is_start else "end"]
|
||||
return {"origin_mm": _global(plane, entity["center"]), "direction": list(plane["normal"])}
|
||||
raise ValueError("circular pattern axis must be a sketch line or circular edge")
|
||||
|
||||
|
||||
def _loft_profile_sketches(params: dict[str, Any]) -> list[str]:
|
||||
# CADFS loft 的 profile 是草图 IMPRINT 面；几何仍来自原始闭合草图，
|
||||
# 保留草图 source，不能把前序实体的选中面近似为新的放样轮廓。
|
||||
profiles = params.get("sheetProfilesArray")
|
||||
if not isinstance(profiles, list):
|
||||
raise ValueError("loft sheetProfilesArray is unresolved")
|
||||
sources: list[str] = []
|
||||
for profile in profiles:
|
||||
query_value = profile.get("sheetProfileEntities") if isinstance(profile, dict) else profile
|
||||
query = parse_query(query_value)
|
||||
if query.topology_type and query.topology_type != "IMPRINT":
|
||||
raise UnsupportedCapability(
|
||||
f"loft_profile_topology:{query.topology_type.lower()}",
|
||||
f"current CDSL loft only supports sketch-imprint profiles, not {query.topology_type}",
|
||||
)
|
||||
if not query.source_sketch:
|
||||
raise ValueError("loft profile sketch query is unresolved")
|
||||
sources.append(query.source_sketch)
|
||||
if len(sources) < 2:
|
||||
raise ValueError("loft requires at least two profile sketches")
|
||||
if len(set(sources)) != len(sources):
|
||||
raise ValueError("loft profile sketches must be distinct")
|
||||
return sources
|
||||
|
||||
|
||||
def _profile_query_kind(params: dict[str, Any]) -> str | None:
|
||||
for key in ("entities", "sheetProfilesArray"):
|
||||
if key in params:
|
||||
@@ -215,18 +349,243 @@ def _default_plane(value: Any) -> dict[str, Any] | None:
|
||||
return None
|
||||
|
||||
|
||||
def _entity_from_query(
|
||||
query: Any,
|
||||
sketch_by_source: dict[str, dict[str, Any]],
|
||||
entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
|
||||
) -> tuple[dict[str, Any], dict[str, Any], str]:
|
||||
info = parse_query(query); source = info.source_sketch or ""; token = info.source_entity or ""
|
||||
available = entity_by_sketch.get(source) or {}
|
||||
entity = available.get(token)
|
||||
if entity is None:
|
||||
entity_id = max((key for key in available if token.startswith(key + ".")), key=len, default="")
|
||||
entity = available.get(entity_id)
|
||||
sketch = sketch_by_source.get(source)
|
||||
if entity is None or sketch is None:
|
||||
raise ValueError("reference geometry source is unresolved")
|
||||
return entity, sketch["workplane"], token
|
||||
|
||||
|
||||
def _entity_point(entity: dict[str, Any], plane: dict[str, Any], token: str) -> list[float]:
|
||||
if entity["type"] == "point": return _global(plane, entity["point"])
|
||||
if entity["type"] == "line":
|
||||
local = entity["end"] if ".end" in token else entity["start"]
|
||||
return _global(plane, local)
|
||||
if entity["type"] == "bspline":
|
||||
index = next((int(part) - 1 for part in token.split(".") if part.isdigit()), 0)
|
||||
points = entity.get("points") or []
|
||||
if not points: raise ValueError("B-spline reference point is unresolved")
|
||||
return _global(plane, points[max(0, min(index, len(points) - 1))])
|
||||
raise ValueError("reference entity does not define a point")
|
||||
|
||||
|
||||
def _entity_line(entity: dict[str, Any], plane: dict[str, Any]) -> tuple[list[float], list[float]]:
|
||||
if entity["type"] != "line": raise ValueError("reference entity is not a line")
|
||||
return _global(plane, entity["start"]), _global(plane, entity["end"])
|
||||
|
||||
|
||||
def _query_plane(
|
||||
query: Any,
|
||||
feature_frames: dict[str, dict[str, Any]],
|
||||
sketch_by_source: dict[str, dict[str, Any]],
|
||||
entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
|
||||
) -> dict[str, Any]:
|
||||
try:
|
||||
return _plane_from_query(query, feature_frames, sketch_by_source)
|
||||
except ValueError:
|
||||
info = parse_query(query)
|
||||
if info.topology_type != "SWEPT_FACE" or not info.owner_feature:
|
||||
raise
|
||||
entity, source_plane, _ = _entity_from_query(query, sketch_by_source, entity_by_sketch)
|
||||
start, end = _entity_line(entity, source_plane); frame = feature_frames.get(info.owner_feature)
|
||||
if frame is None: raise ValueError("swept face owner frame is unresolved")
|
||||
direction = _unit(_sub(end, start), "swept face source line is degenerate")
|
||||
normal = _cross(direction, frame["end"]["normal"])
|
||||
return _frame(start, direction, normal)
|
||||
|
||||
|
||||
def _query_line(
|
||||
query: Any,
|
||||
feature_frames: dict[str, dict[str, Any]],
|
||||
sketch_by_source: dict[str, dict[str, Any]],
|
||||
entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
|
||||
) -> tuple[list[float], list[float]]:
|
||||
info = parse_query(query)
|
||||
entity, plane, _ = _entity_from_query(query, sketch_by_source, entity_by_sketch)
|
||||
if info.topology_type == "CAP_EDGE" and info.owner_feature in feature_frames:
|
||||
frame = feature_frames[info.owner_feature]["start" if info.is_start else "end"]
|
||||
plane = frame
|
||||
return _entity_line(entity, plane)
|
||||
|
||||
|
||||
def _transform_axis(
|
||||
query: Any,
|
||||
feature_frames: dict[str, dict[str, Any]],
|
||||
sketch_by_source: dict[str, dict[str, Any]],
|
||||
entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
|
||||
) -> dict[str, list[float]]:
|
||||
start, end = _query_line(query, feature_frames, sketch_by_source, entity_by_sketch)
|
||||
return {"origin_mm": start, "direction": _unit(_sub(end, start), "transform axis is degenerate")}
|
||||
|
||||
|
||||
def _bake_transform(
|
||||
params: dict[str, Any],
|
||||
previous: list[str],
|
||||
feature_by_id: dict[str, dict[str, Any]],
|
||||
feature_source_by_id: dict[str, str],
|
||||
sketches_by_id: dict[str, dict[str, Any]],
|
||||
feature_frames: dict[str, dict[str, Any]],
|
||||
sketch_by_source: dict[str, dict[str, Any]],
|
||||
entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
|
||||
) -> None:
|
||||
if _bool(params.get("makeCopy")):
|
||||
raise UnsupportedCapability("transform", "current CDSL engine cannot exactly copy transformed CADFS source bodies")
|
||||
sources = _transform_source_features(params.get("entities"), previous)
|
||||
if len(sources) != 1:
|
||||
raise UnsupportedCapability("transform", "current CDSL engine cannot exactly transform multiple selected CADFS source bodies")
|
||||
source_id = sources[0]; source = feature_by_id.get(source_id)
|
||||
if source is None or source.get("atomic_id") not in {"extrude_add_blind", "extrude_add_two_sided", "revolve_add"}:
|
||||
raise UnsupportedCapability("transform", "current CDSL engine can only bake a direct additive extrusion or revolve transform")
|
||||
sketch = sketches_by_id.get(str(source.get("sketch_id") or ""))
|
||||
source_feature_id = feature_source_by_id.get(source_id)
|
||||
if sketch is None or source_feature_id is None:
|
||||
raise UnsupportedCapability("transform", "current CDSL engine cannot resolve the transformed source feature geometry")
|
||||
transform_type = str(params.get("transformType") or "").split(".")[-1].upper()
|
||||
if transform_type == "TRANSLATION_3D":
|
||||
offset = [_number(params.get(key, 0.0), True) for key in ("dx", "dy", "dz")]
|
||||
transform_frame = lambda frame: _translate_frame(frame, offset)
|
||||
transform_axis = lambda axis: {**axis, "origin_mm": [axis["origin_mm"][index] + offset[index] for index in range(3)]}
|
||||
elif transform_type == "ROTATION":
|
||||
axis = _transform_axis(params.get("transformAxis"), feature_frames, sketch_by_source, entity_by_sketch)
|
||||
angle_rad = math.radians(_number(params.get("angle"), True))
|
||||
transform_frame = lambda frame: _rotate_frame(frame, axis, angle_rad)
|
||||
transform_axis = lambda value: {
|
||||
**value,
|
||||
"origin_mm": _rotate_point(value["origin_mm"], axis, angle_rad),
|
||||
"direction": _rotate(value["direction"], axis["direction"], angle_rad),
|
||||
}
|
||||
else:
|
||||
raise UnsupportedCapability("transform", f"current CDSL engine cannot exactly bake {transform_type or 'unknown'} transform")
|
||||
sketch["workplane"] = transform_frame(sketch["workplane"])
|
||||
frame = feature_frames.get(source_feature_id)
|
||||
if frame is not None:
|
||||
feature_frames[source_feature_id] = {key: transform_frame(value) for key, value in frame.items()}
|
||||
source_axis = source.get("params", {}).get("axis")
|
||||
if isinstance(source_axis, dict) and source_axis.get("origin_mm") and source_axis.get("direction"):
|
||||
source["params"]["axis"] = transform_axis(source_axis)
|
||||
|
||||
|
||||
def _query_point(
|
||||
query: Any,
|
||||
feature_frames: dict[str, dict[str, Any]],
|
||||
sketch_by_source: dict[str, dict[str, Any]],
|
||||
entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
|
||||
) -> list[float]:
|
||||
info = parse_query(query)
|
||||
if info.topology_type == "CAP_VERTEX" and info.owner_feature in feature_frames:
|
||||
references = _source_refs(query)
|
||||
if len(references) >= 2:
|
||||
plane = feature_frames[info.owner_feature]["start" if info.is_start else "end"]
|
||||
lines = []
|
||||
for source, token in references:
|
||||
available = entity_by_sketch.get(source) or {}
|
||||
entity = available.get(token)
|
||||
if entity is None:
|
||||
entity_id = max((key for key in available if token.startswith(key + ".")), key=len, default="")
|
||||
entity = available.get(entity_id)
|
||||
if entity and entity.get("type") == "line": lines.append(_entity_line(entity, plane))
|
||||
if len(lines) >= 2:
|
||||
pairs = [(math.dist(left, right), left) for left in lines[0] for right in lines[1]]
|
||||
distance, point = min(pairs, key=lambda item: item[0])
|
||||
if distance <= 1e-5: return point
|
||||
entity, plane, token = _entity_from_query(query, sketch_by_source, entity_by_sketch)
|
||||
if info.topology_type == "CAP_VERTEX" and info.owner_feature in feature_frames:
|
||||
plane = feature_frames[info.owner_feature]["start" if info.is_start else "end"]
|
||||
return _entity_point(entity, plane, token)
|
||||
|
||||
|
||||
def _cplane(
|
||||
params: dict[str, Any],
|
||||
feature_frames: dict[str, dict[str, Any]],
|
||||
sketch_by_source: dict[str, dict[str, Any]],
|
||||
entity_by_sketch: dict[str, dict[str, dict[str, Any]]],
|
||||
) -> dict[str, Any]:
|
||||
plane_type = str(params.get("cplaneType") or "OFFSET").split(".")[-1].upper()
|
||||
entities = _queries(params.get("entities"))
|
||||
if plane_type == "OFFSET":
|
||||
return _shift_plane(_query_plane(entities[0], feature_frames, sketch_by_source, entity_by_sketch), _number(params.get("offset", 0), True))
|
||||
if plane_type == "LINE_ANGLE":
|
||||
line_query = next((item for item in entities if parse_query(item).source_entity), None)
|
||||
if line_query is None: raise ValueError("line-angle reference line is unresolved")
|
||||
base_query = next((item for item in entities if item is not line_query), line_query)
|
||||
try:
|
||||
base = _query_plane(base_query, feature_frames, sketch_by_source, entity_by_sketch)
|
||||
except ValueError:
|
||||
_, base, _ = _entity_from_query(line_query, sketch_by_source, entity_by_sketch)
|
||||
start, end = _query_line(line_query, feature_frames, sketch_by_source, entity_by_sketch)
|
||||
axis = _sub(end, start); angle = _number(params.get("angle", 0.0))
|
||||
if _bool(params.get("oppositeDirection")): angle = -angle
|
||||
return _frame(start, _rotate(base["x_dir"], axis, math.radians(angle)), _rotate(base["normal"], axis, math.radians(angle)))
|
||||
if plane_type == "PLANE_POINT":
|
||||
base_query = next((item for item in entities if _default_plane(item) or "qCreatedBy" in parse_query(item).calls), None)
|
||||
point_query = next((item for item in entities if item is not base_query), None)
|
||||
if base_query is None or point_query is None: raise ValueError("plane-point references are unresolved")
|
||||
base = _query_plane(base_query, feature_frames, sketch_by_source, entity_by_sketch)
|
||||
return _frame(_query_point(point_query, feature_frames, sketch_by_source, entity_by_sketch), base["x_dir"], base["normal"])
|
||||
if plane_type == "CURVE_POINT":
|
||||
point_query = next((item for item in entities if parse_query(item).kind and "vertex" in parse_query(item).kind), None)
|
||||
curve_query = next((item for item in entities if item is not point_query), None)
|
||||
if point_query is None or curve_query is None: raise ValueError("curve-point references are unresolved")
|
||||
point = _query_point(point_query, feature_frames, sketch_by_source, entity_by_sketch)
|
||||
start, end = _query_line(curve_query, feature_frames, sketch_by_source, entity_by_sketch)
|
||||
_, source_plane, _ = _entity_from_query(curve_query, sketch_by_source, entity_by_sketch)
|
||||
return _frame(point, source_plane["normal"], _sub(end, start))
|
||||
if plane_type == "THREE_POINT":
|
||||
if len(entities) != 3: raise ValueError("three-point plane requires exactly three points")
|
||||
first, second, third = [_query_point(item, feature_frames, sketch_by_source, entity_by_sketch) for item in entities]
|
||||
normal = _cross(_sub(second, first), _sub(third, first))
|
||||
if _bool(params.get("oppositeDirection")): normal = [-value for value in normal]
|
||||
return _frame(first, _sub(second, first), normal)
|
||||
if plane_type == "LINE_POINT":
|
||||
line_query = next((item for item in entities if "edge" in (parse_query(item).kind or "")), None)
|
||||
point_query = next((item for item in entities if item is not line_query), None)
|
||||
if line_query is None or point_query is None: raise ValueError("line-point references are unresolved")
|
||||
start, end = _query_line(line_query, feature_frames, sketch_by_source, entity_by_sketch)
|
||||
point = _query_point(point_query, feature_frames, sketch_by_source, entity_by_sketch)
|
||||
direction = _sub(end, start); normal = _cross(direction, _sub(point, start))
|
||||
if _bool(params.get("oppositeDirection")): normal = [-value for value in normal]
|
||||
return _frame(start, direction, normal)
|
||||
if plane_type == "MID_PLANE":
|
||||
if len(entities) != 2: raise ValueError("mid-plane requires exactly two reference planes")
|
||||
first, second = [_query_plane(item, feature_frames, sketch_by_source, entity_by_sketch) for item in entities]
|
||||
alignment = 1.0 if _dot(first["normal"], second["normal"]) >= 0 else -1.0
|
||||
offset = _dot(_sub(second["origin_mm"], first["origin_mm"]), first["normal"]) * alignment
|
||||
return _shift_plane(first, offset / 2.0)
|
||||
raise UnsupportedCapability(f"reference_plane:{plane_type.lower()}", f"current converter has no exact {plane_type} reference plane")
|
||||
|
||||
|
||||
def lower_model(model: ModelIR, provenance: dict[str, Any]) -> LoweringResult:
|
||||
diagnostics: list[dict[str, Any]] = []; history = []
|
||||
sketches: list[dict[str, Any]] = []; sketch_by_source: dict[str, dict[str, Any]] = {}; entity_by_sketch: dict[str, dict[str, dict[str, Any]]] = {}
|
||||
sketches: list[dict[str, Any]] = []; sketches_by_id: dict[str, dict[str, Any]] = {}; sketch_by_source: dict[str, dict[str, Any]] = {}; entity_by_sketch: dict[str, dict[str, dict[str, Any]]] = {}
|
||||
feature_frames: dict[str, dict[str, Any]] = {}
|
||||
features: list[dict[str, Any]] = []; complete = True; previous: list[str] = []
|
||||
feature_by_id: dict[str, dict[str, Any]] = {}; feature_source_by_id: dict[str, str] = {}
|
||||
for step in model.steps:
|
||||
if isinstance(step, SketchIR):
|
||||
history.append({"feature_id": step.feature_id, "operation": "newSketch", "parameters": {"sketchPlane": plain(step.workplane)}, "entities": [{"entity_id": e.feature_id, "operation": e.operation, "parameters": plain(e.params)} for e in step.entities]})
|
||||
try:
|
||||
plane = _plane_from_query(step.workplane, feature_frames, sketch_by_source)
|
||||
lowered, entities = _lower_sketch(step, plane); sketches.append(lowered); sketch_by_source[step.feature_id] = lowered; entity_by_sketch[step.feature_id] = entities
|
||||
lowered, entities = _lower_sketch(step, plane); sketches.append(lowered); sketches_by_id[lowered["id"]] = lowered; sketch_by_source[step.feature_id] = lowered; entity_by_sketch[step.feature_id] = entities
|
||||
except Exception as exc:
|
||||
# 开放草图不能作为实体 profile，但其几何仍可能是后续基准面、
|
||||
# 阵列轴或旋转轴的精确引用。保留为 reference 草图，后续实体
|
||||
# 特征仍由 _profile_executable 明确拒绝，不能静默把开放轮廓实体化。
|
||||
try:
|
||||
plane = _plane_from_query(step.workplane, feature_frames, sketch_by_source)
|
||||
lowered, entities = _lower_sketch(step, plane, allow_open=True)
|
||||
sketches.append(lowered); sketches_by_id[lowered["id"]] = lowered; sketch_by_source[step.feature_id] = lowered; entity_by_sketch[step.feature_id] = entities
|
||||
except Exception:
|
||||
pass
|
||||
diagnostics.append({"code": "sketch_deferred", "feature_id": step.feature_id, "message": str(exc)}); complete = False
|
||||
continue
|
||||
item = step
|
||||
@@ -235,12 +594,14 @@ def lower_model(model: ModelIR, provenance: dict[str, Any]) -> LoweringResult:
|
||||
diagnostics.append({"code": "unsupported_operation", "feature_id": item.feature_id, "operation": item.operation}); complete = False; continue
|
||||
try:
|
||||
fid = f"f_{item.feature_id}"; depends = list(previous[-1:]); p = item.params; feature: dict[str, Any]
|
||||
if item.operation == "cPlane":
|
||||
plane_type = str(p.get("cplaneType") or "OFFSET").split(".")[-1].upper()
|
||||
if plane_type != "OFFSET":
|
||||
raise UnsupportedCapability(f"reference_plane:{plane_type.lower()}", f"current converter only supports exact OFFSET reference planes, not {plane_type}")
|
||||
base = _plane_from_query(p.get("entities"), feature_frames, sketch_by_source); offset = _number(p.get("offset", 0), True); plane = _shift_plane(base, offset)
|
||||
feature = {"id": fid, "name": item.feature_id, "atomic_id": "reference_plane", "depends_on": depends, "params": {"plane": plane, "offset_mm": offset}, "execution_status": "supported"}
|
||||
if item.operation == "transform":
|
||||
# 仅将单一、直接的原始实体变换烘焙回其输入几何。不能移动当前
|
||||
# 聚合主体：CADFS transform 可能只选择 pattern copy 或多 body。
|
||||
_bake_transform(p, previous, feature_by_id, feature_source_by_id, sketches_by_id, feature_frames, sketch_by_source, entity_by_sketch)
|
||||
continue
|
||||
elif item.operation == "cPlane":
|
||||
plane = _cplane(p, feature_frames, sketch_by_source, entity_by_sketch)
|
||||
feature = {"id": fid, "name": item.feature_id, "atomic_id": "reference_plane", "depends_on": depends, "params": {"plane": plane}, "execution_status": "supported"}
|
||||
feature_frames[item.feature_id] = {"start": plane, "end": plane}
|
||||
elif item.operation == "extrude":
|
||||
if p.get("surfaceOperationType") is not None:
|
||||
@@ -255,19 +616,21 @@ def lower_model(model: ModelIR, provenance: dict[str, Any]) -> LoweringResult:
|
||||
depth_value = p.get("depth"); depth = _number(depth_value, True) if depth_value is not None else 1.0
|
||||
operation = str(p.get("operationType") or "NEW").upper(); reverse = _bool(p.get("oppositeDirection")); cutting = any(x in operation for x in ("REMOVE", "CUT"))
|
||||
second = _bool(p.get("hasSecondDirection"))
|
||||
if cutting and (second or end["type"] != "blind"):
|
||||
capability = "extrude_cut_two_sided" if second or end["type"] == "mid_plane" else f"extrude_cut_{end['type']}"
|
||||
if cutting and not second and end["type"] not in {"blind", "mid_plane", "through_all", "through_next"}:
|
||||
capability = f"extrude_cut_{end['type']}"
|
||||
raise UnsupportedCapability(capability, f"current CDSL atomic set has no exact {capability} operation")
|
||||
if not cutting and not second and end["type"] not in {"blind", "mid_plane"}:
|
||||
if not cutting and not second and end["type"] not in {"blind", "mid_plane", "through_all", "through_next"}:
|
||||
capability = f"extrude_add_{end['type']}"
|
||||
raise UnsupportedCapability(capability, f"current CDSL atomic set has no exact {capability} operation")
|
||||
if second:
|
||||
atomic = "extrude_add_two_sided"; params = {"distance_mm": depth, "reverse": reverse, "end_condition": end}
|
||||
atomic = "extrude_cut_two_sided" if cutting else "extrude_add_two_sided"
|
||||
params = {"distance_mm": depth, "reverse": reverse, "end_condition": end}
|
||||
reverse_depth = _number(p.get("secondDirectionDepth", depth), True)
|
||||
params.update({"reverse_distance_mm": reverse_depth, "reverse_end_condition": _end_condition(p.get("secondDirectionBound"))})
|
||||
elif end["type"] == "mid_plane" and not cutting:
|
||||
elif end["type"] == "mid_plane":
|
||||
blind = _end_condition("BLIND")
|
||||
atomic = "extrude_add_two_sided"; params = {"distance_mm": depth / 2, "reverse_distance_mm": depth / 2, "reverse": reverse, "end_condition": blind, "reverse_end_condition": dict(blind)}
|
||||
atomic = "extrude_cut_two_sided" if cutting else "extrude_add_two_sided"
|
||||
params = {"distance_mm": depth / 2, "reverse_distance_mm": depth / 2, "reverse": reverse, "end_condition": blind, "reverse_end_condition": dict(blind)}
|
||||
else:
|
||||
atomic = "extrude_cut_blind" if cutting else "extrude_add_blind"
|
||||
params = {"distance_mm": depth, "reverse": reverse, "end_condition": end}
|
||||
@@ -279,6 +642,22 @@ def lower_model(model: ModelIR, provenance: dict[str, Any]) -> LoweringResult:
|
||||
elif end["type"] == "mid_plane":
|
||||
direction = -1 if reverse else 1
|
||||
feature_frames[item.feature_id] = {"start": _shift_plane(plane, -direction * depth / 2), "end": _shift_plane(plane, direction * depth / 2)}
|
||||
elif item.operation == "loft":
|
||||
sources = _loft_profile_sketches(p)
|
||||
missing = [source for source in sources if source not in sketch_by_source]
|
||||
if missing:
|
||||
raise ValueError("loft profile sketches are unresolved: " + ", ".join(missing))
|
||||
non_closed = [source for source in sources if not _profile_executable(sketch_by_source[source])]
|
||||
if non_closed:
|
||||
raise ValueError("loft profile sketches have no closed profile: " + ", ".join(non_closed))
|
||||
feature = {
|
||||
"id": fid,
|
||||
"name": item.feature_id,
|
||||
"atomic_id": "loft_add",
|
||||
"depends_on": depends,
|
||||
"params": {"profile_sketch_ids": [sketch_by_source[source]["id"] for source in sources]},
|
||||
"execution_status": "supported",
|
||||
}
|
||||
elif item.operation == "revolve":
|
||||
if p.get("surfaceOperationType") is not None and p.get("operationType") is None:
|
||||
raise UnsupportedCapability("revolve_surface", "current CDSL engine has no exact surface-revolve operation")
|
||||
@@ -365,6 +744,25 @@ def lower_model(model: ModelIR, provenance: dict[str, Any]) -> LoweringResult:
|
||||
hole_params["counterbore"] = {"diameter_mm": _number(p.get("counterboreDiameter") or p.get("cBoreDiameter") or p.get("majorDiameter"), True), "depth_mm": _number(p.get("counterboreDepth") or p.get("cBoreDepth"), True)}
|
||||
if _bool(p.get("isTappedThrough")) or p.get("tapSize") is not None: hole_params["thread"] = {"source": "CADFS", "decorative": True}
|
||||
feature = {"id": fid, "name": item.feature_id, "atomic_id": "hole_wizard", "depends_on": depends, "params": hole_params, "execution_status": "supported"}
|
||||
elif item.operation == "circularPattern":
|
||||
sources = _pattern_source_features(p.get("entities"), previous)
|
||||
axis = _circular_pattern_axis(p.get("axis"), feature_frames, sketch_by_source, entity_by_sketch)
|
||||
count = int(_number(p.get("instanceCount")))
|
||||
if count < 1:
|
||||
raise ValueError("circular pattern instanceCount must be positive")
|
||||
feature = {
|
||||
"id": fid,
|
||||
"name": item.feature_id,
|
||||
"atomic_id": "pattern_circular",
|
||||
"depends_on": list(dict.fromkeys(sources + depends)),
|
||||
"params": {
|
||||
"source_feature_ids": sources,
|
||||
"axis": axis,
|
||||
"pattern_count": count,
|
||||
"sweep_angle_deg": _number(p.get("angle", 360.0)),
|
||||
},
|
||||
"execution_status": "supported",
|
||||
}
|
||||
elif item.operation == "mirror":
|
||||
owners = []
|
||||
for call in walk_calls(p.get("entities")):
|
||||
@@ -387,7 +785,7 @@ def lower_model(model: ModelIR, provenance: dict[str, Any]) -> LoweringResult:
|
||||
feature = {"id": fid, "name": item.feature_id, "atomic_id": "pattern_mirror", "depends_on": list(dict.fromkeys(owners + [plane_owner])), "params": {"source_feature_ids": owners, "mirror_plane": mirror_plane}, "selectors": [mirror_plane], "execution_status": "supported"}
|
||||
else:
|
||||
raise ValueError(f"operation mapping not implemented: {item.operation}")
|
||||
features.append(feature); previous.append(fid)
|
||||
features.append(feature); feature_by_id[fid] = feature; feature_source_by_id[fid] = item.feature_id; previous.append(fid)
|
||||
except UnsupportedCapability as exc:
|
||||
diagnostics.append({"code": "unsupported_engine_capability", "capability": exc.capability, "feature_id": item.feature_id, "operation": item.operation, "message": str(exc)}); complete = False
|
||||
except Exception as exc:
|
||||
|
||||
Reference in New Issue
Block a user