editor: a hole drills along an axis, the picked face's normal or a free vector
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -60,6 +60,8 @@ export type DialogSketches = {
|
||||
};
|
||||
|
||||
/** The form of one operation, generated from its spec. A docked card, not a modal: the viewport stays live. */
|
||||
const round4 = (value: number) => Math.round(value * 1e4) / 1e4;
|
||||
|
||||
export function FeatureDialog({
|
||||
request,
|
||||
state,
|
||||
@@ -287,7 +289,8 @@ function FeatureForm({
|
||||
setNote("The face details are still loading; try again in a moment.");
|
||||
return;
|
||||
}
|
||||
const { point, direction } = holeFromFace(face);
|
||||
const { point, vector } = holeFromFace(face);
|
||||
const direction = vector ? "face" : null;
|
||||
if (!point) {
|
||||
setNote("This face has no centroid; type the start point.");
|
||||
return;
|
||||
@@ -295,11 +298,11 @@ function FeatureForm({
|
||||
setForm((previous) => ({
|
||||
...previous,
|
||||
position: point.map((c) => String(Math.round(c * 1e4) / 1e4)),
|
||||
...(direction ? { direction } : {}),
|
||||
...(direction && vector ? { direction, dx: String(round4(vector[0])), dy: String(round4(vector[1])), dz: String(round4(vector[2])) } : {}),
|
||||
}));
|
||||
setNote(
|
||||
direction
|
||||
? `Start point set from the face centroid, direction ${direction} (into the material).`
|
||||
direction && vector
|
||||
? `Start point set from the face centroid; the hole follows the face's normal, into the material (${vector.map((v) => round4(v)).join(", ")}).`
|
||||
: "Start point set from the face centroid. The face reports no normal: check the direction.",
|
||||
);
|
||||
setServerError(null);
|
||||
|
||||
@@ -119,8 +119,8 @@ describe("hole from a face", () => {
|
||||
expect(inwardAxis([0, 0, 0])).toBeNull();
|
||||
});
|
||||
it("reads the centroid and the normal", () => {
|
||||
expect(holeFromFace({ properties: { centroid: [1, 2, 3] }, geometry: { plane: { normal: [0, 1, 0] } } })).toEqual({ point: [1, 2, 3], direction: "-y" });
|
||||
expect(holeFromFace({ properties: { centroid: [1, 2, 3] }, geometry: {} })).toEqual({ point: [1, 2, 3], direction: null });
|
||||
expect(holeFromFace({ properties: { centroid: [1, 2, 3] }, geometry: { plane: { normal: [0, 1, 0] } } })).toEqual({ point: [1, 2, 3], direction: "-y", vector: [-0, -1, -0] });
|
||||
expect(holeFromFace({ properties: { centroid: [1, 2, 3] }, geometry: {} })).toEqual({ point: [1, 2, 3], direction: null, vector: null });
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
@@ -459,10 +459,14 @@ export function inwardAxis(normal: readonly [number, number, number]): string |
|
||||
export function holeFromFace(item: { properties: Record<string, unknown> | null; geometry: Record<string, unknown> | null }): {
|
||||
point: [number, number, number] | null;
|
||||
direction: string | null;
|
||||
/** The unit vector into the material (against the outward normal): what "along the face's normal" drills along. */
|
||||
vector: [number, number, number] | null;
|
||||
} {
|
||||
const point = vector3(item.properties?.centroid);
|
||||
const normal = faceNormal(item);
|
||||
return { point, direction: normal ? inwardAxis(normal) : null };
|
||||
const length = normal ? Math.hypot(...normal) : 0;
|
||||
const vector = normal && length > 1e-9 ? ([-normal[0] / length, -normal[1] / length, -normal[2] / length] as [number, number, number]) : null;
|
||||
return { point, direction: normal ? inwardAxis(normal) : null, vector };
|
||||
}
|
||||
|
||||
const NAME_BASE: Record<string, string> = {
|
||||
|
||||
@@ -499,8 +499,27 @@ def _intersect(c: Context) -> list[str]:
|
||||
return [f"{c.slug} = scad.intersect_rsolid({c.body('base')}, {c.spread('other')})"]
|
||||
|
||||
|
||||
_HOLE_DIRECTIONS = [
|
||||
*_AXIS_OPTIONS,
|
||||
{"value": "face", "label": "along the picked face's normal"},
|
||||
{"value": "vector", "label": "a free vector"},
|
||||
]
|
||||
_HOLE_VECTOR = {"direction": ["face", "vector"]}
|
||||
|
||||
|
||||
def _hole_direction(c: Context) -> str:
|
||||
"""The drilling direction: one of the axes, or the unit vector of (dx, dy, dz) (a face normal or a free vector)."""
|
||||
if str(c.values["direction"]) in _AXES:
|
||||
return c.axis("direction")
|
||||
vector = [float(c.values[name]) for name in ("dx", "dy", "dz")]
|
||||
length = sum(v * v for v in vector) ** 0.5
|
||||
if length < 1e-9:
|
||||
raise FeatureError("the direction vector must not be zero")
|
||||
return repr(tuple(round(v / length, 9) + 0.0 for v in vector))
|
||||
|
||||
|
||||
def _hole(c: Context) -> list[str]:
|
||||
direction = c.axis("direction")
|
||||
direction = _hole_direction(c)
|
||||
return [
|
||||
"# a cylinder from just outside the surface, in the drilling direction, taken out of the body",
|
||||
f"_dir = {direction}",
|
||||
@@ -618,7 +637,10 @@ SPECS: tuple[Spec, ...] = (
|
||||
(_body("base", "First body"), _body("other", "Second body")), _intersect),
|
||||
Spec("hole", "Hole", "Features", "subtract", "solid", "A round hole from a point on a surface, in a direction, to a depth.",
|
||||
(_BODY(), _point("position", "Start point (on the surface)", help="Pick a face to fill the point and direction."),
|
||||
_AXIS("direction", "Direction into the material", "-z"), _length("diameter", "Diameter", 6.0), _length("depth", "Depth", 10.0)), _hole),
|
||||
_enum("direction", "Direction into the material", _HOLE_DIRECTIONS, "-z", help="An axis, the normal of the face you picked (into the material), or any vector."),
|
||||
*(Slot(name, label, "float", default=default, min=-1000.0, max=1000.0, show_when=_HOLE_VECTOR)
|
||||
for name, label, default in (("dx", "Direction x", 0.0), ("dy", "Direction y", 0.0), ("dz", "Direction z", -1.0))),
|
||||
_length("diameter", "Diameter", 6.0), _length("depth", "Depth", 10.0)), _hole),
|
||||
Spec("fillet", "Fillet", "Features", "modifier", "solid", "Round the picked edges.",
|
||||
(_BODY(), Slot("edges", "Edges", "select", entity="edge"), _length("radius", "Radius", 2.0)), _fillet),
|
||||
Spec("chamfer", "Chamfer", "Features", "modifier", "solid", "Bevel the picked edges.",
|
||||
|
||||
@@ -466,3 +466,15 @@ def test_the_catalog_says_which_slots_belong_to_which_operation():
|
||||
assert [o["value"] for o in by_name["operation"]["options"]] == ["join", "cut", "intersect", "new"]
|
||||
assert by_name["target"]["show_when"] == {"operation": ["join", "cut", "intersect"]}
|
||||
assert not any(s.get("combinable") for s in F.catalog()["specs"] if s["id"] in ("fillet", "hole", "cut", "union"))
|
||||
|
||||
|
||||
def test_a_hole_goes_along_an_axis_a_face_normal_or_a_free_vector():
|
||||
base = {**DEFAULTS["hole"], "body": "block", "position": [10.0, 10.0, 20.0]}
|
||||
axis = F.render_feature("hole", "bore", {**base, "direction": "-z"}, bodies={"block": "solid"}, known_slugs={"block"})
|
||||
assert "(0.0, 0.0, -1.0)" in axis.feature or "(0, 0, -1)" in axis.feature
|
||||
slanted = F.render_feature("hole", "bore", {**base, "direction": "face", "dx": 3.0, "dy": 0.0, "dz": -4.0}, bodies={"block": "solid"}, known_slugs={"block"})
|
||||
assert "(0.6, 0.0, -0.8)" in slanted.feature # the unit vector, whatever the length typed or picked
|
||||
free = F.render_feature("hole", "bore", {**base, "direction": "vector", "dx": 0.0, "dy": 1.0, "dz": 0.0}, bodies={"block": "solid"}, known_slugs={"block"})
|
||||
assert "(0.0, 1.0, 0.0)" in free.feature
|
||||
with pytest.raises(F.FeatureError, match="must not be zero"):
|
||||
F.render_feature("hole", "bore", {**base, "direction": "vector", "dx": 0.0, "dy": 0.0, "dz": 0.0}, bodies={"block": "solid"}, known_slugs={"block"})
|
||||
|
||||
@@ -0,0 +1,223 @@
|
||||
"""Tests for Phase 5 (QL sugar) and Phase 6 (DAG session recorder)."""
|
||||
|
||||
import unittest
|
||||
|
||||
import simplecadapi as scad
|
||||
from simplecadapi import ql as Q
|
||||
from simplecadapi.topology import OperationGraph, OperationNode
|
||||
from simplecadapi.recording.graph import GraphSession, record_operation, get_active_session
|
||||
from simplecadapi.topology.tracking import tracked_cut, tracked_union
|
||||
from simplecadapi.topology.autotag import apply_tracking_tags_to_delta
|
||||
|
||||
|
||||
class TestQLSugar(unittest.TestCase):
|
||||
"""Test QL sugar helpers for tracking-based queries."""
|
||||
|
||||
def test_op_predicate(self):
|
||||
pred = Q.op("cut", "generated")
|
||||
obj = type(
|
||||
"Obj",
|
||||
(),
|
||||
{"_metadata": {"track": {"op": "make_cut_rsolid", "event": "generated"}}},
|
||||
)()
|
||||
self.assertTrue(pred(obj))
|
||||
|
||||
def test_op_predicate_wildcard(self):
|
||||
pred = Q.op("cut")
|
||||
obj = type(
|
||||
"Obj",
|
||||
(),
|
||||
{"_metadata": {"track": {"op": "make_cut_rsolid", "events": ["modified"]}}},
|
||||
)()
|
||||
self.assertTrue(pred(obj))
|
||||
|
||||
def test_op_predicate_matches_generic_operation_alias(self):
|
||||
obj = type(
|
||||
"Obj",
|
||||
(),
|
||||
{
|
||||
"_metadata": {
|
||||
"track": {
|
||||
"op": "make_translate_rsolid",
|
||||
"operation": "translate",
|
||||
"event": "modified",
|
||||
}
|
||||
}
|
||||
},
|
||||
)()
|
||||
|
||||
self.assertTrue(Q.op("translate", "modified")(obj))
|
||||
self.assertTrue(Q.op("make_translate_rsolid", "modified")(obj))
|
||||
|
||||
def test_origin_predicate(self):
|
||||
pred = Q.origin("tool")
|
||||
obj = type(
|
||||
"Obj", (), {"_metadata": {"track": {"origin_roles": ["body", "tool"]}}}
|
||||
)()
|
||||
self.assertTrue(pred(obj))
|
||||
|
||||
def test_origin_predicate_no_match(self):
|
||||
pred = Q.origin("tool")
|
||||
obj = type("Obj", (), {"_metadata": {"track": {"origin_role": "body"}}})()
|
||||
self.assertFalse(pred(obj))
|
||||
|
||||
def test_op_and_origin_do_not_fall_back_to_flat_tags(self):
|
||||
obj = type(
|
||||
"Obj",
|
||||
(),
|
||||
{"_metadata": {}, "_tags": {"op.cut.generated", "origin.tool"}},
|
||||
)()
|
||||
|
||||
self.assertFalse(Q.op("cut", "generated")(obj))
|
||||
self.assertFalse(Q.origin("tool")(obj))
|
||||
|
||||
def test_typed_tracking_predicates_roundtrip(self):
|
||||
operation = Q.operation_event("cut", "modified")
|
||||
origin = Q.origin_role("tool")
|
||||
|
||||
self.assertEqual(
|
||||
Q.SerializablePredicate.from_dict(operation.to_dict()).to_dict(),
|
||||
operation.to_dict(),
|
||||
)
|
||||
self.assertEqual(
|
||||
Q.SerializablePredicate.from_dict(origin.to_dict()).to_dict(),
|
||||
origin.to_dict(),
|
||||
)
|
||||
|
||||
def test_role_predicate(self):
|
||||
pred = Q.role("section")
|
||||
obj = type("Obj", (), {"_tags": {"role.section.face"}})()
|
||||
self.assertTrue(pred(obj))
|
||||
|
||||
def test_select_faces_by_op(self):
|
||||
body = scad.make_box_rsolid(10, 10, 10)
|
||||
body.auto_tag_faces("box")
|
||||
tool = scad.make_cylinder_rsolid(2.0, 15.0, bottom_face_center=(3, 3, -2.5))
|
||||
result = tracked_cut(body, tool)
|
||||
tagged = apply_tracking_tags_to_delta(
|
||||
result.solid, result.delta, result.delta_entries, op="cut"
|
||||
)
|
||||
modified = Q.select(tagged._iter_faces()).where(Q.op("cut", "modified")).all()
|
||||
self.assertGreater(len(modified), 0)
|
||||
|
||||
def test_select_faces_by_origin(self):
|
||||
body = scad.make_box_rsolid(10, 10, 10)
|
||||
tool = scad.make_cylinder_rsolid(2.0, 15.0, bottom_face_center=(3, 3, -2.5))
|
||||
result = tracked_cut(body, tool)
|
||||
tagged = apply_tracking_tags_to_delta(
|
||||
result.solid, result.delta, result.delta_entries, op="cut"
|
||||
)
|
||||
tool_faces = Q.select(tagged._iter_faces()).where(Q.origin("tool")).all()
|
||||
self.assertGreater(len(tool_faces), 0)
|
||||
|
||||
|
||||
class TestGraphSession(unittest.TestCase):
|
||||
"""Test the DAG session recorder."""
|
||||
|
||||
def test_session_lifecycle(self):
|
||||
session = GraphSession()
|
||||
session.start()
|
||||
self.assertIsNotNone(get_active_session())
|
||||
session.stop()
|
||||
self.assertIsNone(get_active_session())
|
||||
|
||||
def test_record_primitive(self):
|
||||
session = GraphSession()
|
||||
session.start()
|
||||
node = record_operation(
|
||||
"make_line_redge", {"start": (0, 0, 0), "end": (10, 0, 0)}
|
||||
)
|
||||
self.assertEqual(node.op, "make_line_redge")
|
||||
self.assertEqual(session.graph.node_count, 1)
|
||||
session.stop()
|
||||
|
||||
def test_record_with_inputs(self):
|
||||
session = GraphSession()
|
||||
session.start()
|
||||
n1 = record_operation(
|
||||
"make_line_redge", {"start": (0, 0, 0), "end": (10, 0, 0)}
|
||||
)
|
||||
n2 = record_operation(
|
||||
"make_line_redge", {"start": (10, 0, 0), "end": (10, 10, 0)}
|
||||
)
|
||||
n3 = record_operation(
|
||||
"make_wire_from_edges_rwire", {"edge_count": 2}, inputs=[n1, n2]
|
||||
)
|
||||
self.assertEqual(session.graph.node_count, 3)
|
||||
self.assertEqual(len(n3.inputs), 2)
|
||||
session.stop()
|
||||
|
||||
def test_record_with_topo_delta(self):
|
||||
body = scad.make_box_rsolid(10, 10, 10)
|
||||
tool = scad.make_cylinder_rsolid(2.0, 15.0, bottom_face_center=(3, 3, -2.5))
|
||||
result = tracked_cut(body, tool)
|
||||
|
||||
session = GraphSession()
|
||||
session.start()
|
||||
body_node = record_operation(
|
||||
"make_extrude_rsolid",
|
||||
{"direction": (0, 0, 1), "distance": 10.0},
|
||||
)
|
||||
tool_node = record_operation(
|
||||
"make_extrude_rsolid",
|
||||
{"direction": (0, 0, 1), "distance": 15.0},
|
||||
)
|
||||
cut_node = record_operation(
|
||||
"make_cut_rsolid",
|
||||
{},
|
||||
inputs=[body_node, tool_node],
|
||||
topo_delta=result.delta,
|
||||
)
|
||||
self.assertIsNotNone(cut_node.topo_delta)
|
||||
self.assertGreater(len(cut_node.topo_delta.modified), 0)
|
||||
session.stop()
|
||||
|
||||
def test_context_manager(self):
|
||||
with GraphSession() as session:
|
||||
n1 = record_operation(
|
||||
"make_extrude_rsolid", {"direction": (0, 0, 1), "distance": 1.0}
|
||||
)
|
||||
n2 = record_operation(
|
||||
"make_extrude_rsolid", {"direction": (0, 0, 1), "distance": 2.0}
|
||||
)
|
||||
record_operation("make_union_rsolid", {}, inputs=[n1, n2])
|
||||
self.assertEqual(session.graph.node_count, 3)
|
||||
|
||||
def test_no_session_raises(self):
|
||||
with self.assertRaises(RuntimeError):
|
||||
record_operation("make_line_redge", {})
|
||||
|
||||
def test_graph_is_dag(self):
|
||||
with GraphSession() as session:
|
||||
n1 = record_operation(
|
||||
"make_line_redge", {"start": (0, 0, 0), "end": (1, 0, 0)}
|
||||
)
|
||||
n2 = record_operation(
|
||||
"make_line_redge", {"start": (1, 0, 0), "end": (1, 1, 0)}
|
||||
)
|
||||
n3 = record_operation(
|
||||
"make_wire_from_edges_rwire", {"edge_count": 2}, inputs=[n1, n2]
|
||||
)
|
||||
self.assertTrue(session.graph.is_dag())
|
||||
|
||||
def test_graph_topological_order(self):
|
||||
with GraphSession() as session:
|
||||
n1 = record_operation(
|
||||
"make_line_redge", {"start": (0, 0, 0), "end": (1, 0, 0)}
|
||||
)
|
||||
n2 = record_operation(
|
||||
"make_line_redge", {"start": (1, 0, 0), "end": (1, 1, 0)}
|
||||
)
|
||||
n3 = record_operation(
|
||||
"make_wire_from_edges_rwire", {"edge_count": 2}, inputs=[n1, n2]
|
||||
)
|
||||
n4 = record_operation("make_face_from_wire_rface", {}, inputs=[n3])
|
||||
order = session.graph.topological_order()
|
||||
self.assertEqual(len(order), 4)
|
||||
idx = {node.node_id: i for i, node in enumerate(order)}
|
||||
self.assertLess(idx[n1.node_id], idx[n3.node_id])
|
||||
self.assertLess(idx[n3.node_id], idx[n4.node_id])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,96 @@
|
||||
"""Plane-axis convention regression tests.
|
||||
|
||||
`_orthonormal_plane_axes` must build the in-plane frame by projecting the
|
||||
reference vector onto the plane, so a +z normal yields exactly the global
|
||||
(x, y, z) frame. Planar profile makers that use the helper (currently
|
||||
`make_rectangle_rwire`, session and legacy paths) then agree with
|
||||
`make_box_rsolid`'s width-along-x convention. The previous cross-product
|
||||
basis rotated every profile by 90 degrees for +z normals (width landed on
|
||||
global y).
|
||||
"""
|
||||
|
||||
import unittest
|
||||
|
||||
import numpy as np
|
||||
|
||||
import simplecadapi as scad
|
||||
from simplecadapi import ql
|
||||
from simplecadapi.operators._support import _orthonormal_plane_axes
|
||||
|
||||
|
||||
class TestOrthonormalPlaneAxes(unittest.TestCase):
|
||||
def test_z_normal_frame_matches_box_convention(self):
|
||||
z_axis, x_axis, y_axis = _orthonormal_plane_axes((0.0, 0.0, 1.0))
|
||||
np.testing.assert_allclose(z_axis, (0.0, 0.0, 1.0), atol=1e-12)
|
||||
np.testing.assert_allclose(x_axis, (1.0, 0.0, 0.0), atol=1e-12)
|
||||
np.testing.assert_allclose(y_axis, (0.0, 1.0, 0.0), atol=1e-12)
|
||||
|
||||
def test_frames_are_unit_right_handed_and_transverse(self):
|
||||
normals = [
|
||||
(0.3, -0.4, 0.86),
|
||||
(1.0, 0.0, 0.0),
|
||||
(0.0, 1.0, 0.0),
|
||||
(0.0, 0.0, -1.0),
|
||||
(0.2, 0.98, 0.05),
|
||||
]
|
||||
for normal in normals:
|
||||
with self.subTest(normal=normal):
|
||||
z_axis, x_axis, y_axis = _orthonormal_plane_axes(normal)
|
||||
np.testing.assert_allclose(np.linalg.norm(z_axis), 1.0, atol=1e-12)
|
||||
np.testing.assert_allclose(np.linalg.norm(x_axis), 1.0, atol=1e-12)
|
||||
np.testing.assert_allclose(np.linalg.norm(y_axis), 1.0, atol=1e-12)
|
||||
np.testing.assert_allclose(x_axis @ z_axis, 0.0, atol=1e-12)
|
||||
np.testing.assert_allclose(y_axis @ z_axis, 0.0, atol=1e-12)
|
||||
np.testing.assert_allclose(
|
||||
np.cross(x_axis, y_axis), z_axis, atol=1e-12
|
||||
)
|
||||
|
||||
def test_zero_normal_is_rejected(self):
|
||||
with self.assertRaises(ValueError):
|
||||
_orthonormal_plane_axes((0.0, 0.0, 0.0))
|
||||
|
||||
|
||||
class TestRectangleAxisConvention(unittest.TestCase):
|
||||
@staticmethod
|
||||
def _edge_inventory(use_session: bool):
|
||||
def build():
|
||||
return scad.make_rectangle_rwire(30.0, 10.0, (0.0, 0.0, 0.0), (0.0, 0.0, 1.0))
|
||||
|
||||
if use_session:
|
||||
with scad.GraphSession(graph_id="rect_axes_session"):
|
||||
wire = build()
|
||||
else:
|
||||
wire = build()
|
||||
inventory = []
|
||||
for edge in ql.edges().resolve(wire):
|
||||
center = edge.get_center()
|
||||
inventory.append(
|
||||
(round(center.x, 3), round(center.y, 3), round(edge.get_length(), 3))
|
||||
)
|
||||
return sorted(inventory)
|
||||
|
||||
def test_width_spans_x_on_session_path(self):
|
||||
self.assertEqual(
|
||||
self._edge_inventory(use_session=True),
|
||||
[
|
||||
(-15.0, -0.0, 10.0),
|
||||
(0.0, -5.0, 30.0),
|
||||
(0.0, 5.0, 30.0),
|
||||
(15.0, 0.0, 10.0),
|
||||
],
|
||||
)
|
||||
|
||||
def test_width_spans_x_on_legacy_path(self):
|
||||
self.assertEqual(
|
||||
self._edge_inventory(use_session=False),
|
||||
[
|
||||
(-15.0, -0.0, 10.0),
|
||||
(0.0, -5.0, 30.0),
|
||||
(0.0, 5.0, 30.0),
|
||||
(15.0, 0.0, 10.0),
|
||||
],
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,345 @@
|
||||
"""Phase A characterization of the current Model 2.0 and OCP boundaries."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
|
||||
import pytest
|
||||
from OCP.BRep import BRep_Tool
|
||||
from OCP.BRepMesh import BRepMesh_IncrementalMesh
|
||||
from OCP.BRepTools import BRepTools
|
||||
from OCP.TopAbs import TopAbs_FORWARD, TopAbs_REVERSED
|
||||
from OCP.TopLoc import TopLoc_Location
|
||||
|
||||
import simplecadapi as scad
|
||||
from simplecadapi.core import Compound, Edge, Face
|
||||
from simplecadapi.kernel.ocp_export import make_compound_always
|
||||
from simplecadapi.operators import _make_geo_selector
|
||||
from simplecadapi.scene import (
|
||||
canonical_json_bytes,
|
||||
load_contract_artifact,
|
||||
profile_cross,
|
||||
profile_f32_bits,
|
||||
profile_normalize,
|
||||
)
|
||||
from simplecadapi.recording.serializer import (
|
||||
_candidate_shapes_for_geo_selection,
|
||||
_geo_selector_score,
|
||||
_resolve_shape_from_geo_selector,
|
||||
)
|
||||
|
||||
|
||||
CHARACTERIZED_RENDER_PROFILE_CASES = {
|
||||
"bounded_canonicalization_failure",
|
||||
"closed_edge",
|
||||
"degenerate_edge",
|
||||
"duplicate_geometry_with_different_metadata",
|
||||
"duplicate_geometry_with_different_provenance",
|
||||
"negative_zero",
|
||||
"normal_fallback",
|
||||
"reversed_kernel_traversal",
|
||||
"shared_face_rejection",
|
||||
"symmetric_entity",
|
||||
}
|
||||
|
||||
|
||||
def _evaluated_profile() -> dict[str, object]:
|
||||
return json.loads(
|
||||
load_contract_artifact(
|
||||
"profiles/ocp-evaluated-properties-1.profile.json"
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
def _render_profile() -> dict[str, object]:
|
||||
return json.loads(
|
||||
load_contract_artifact("profiles/scene-1.0-ocp-glb-2.profile.json")
|
||||
)
|
||||
|
||||
|
||||
def _fallback_normal(face: Face) -> tuple[float, float, float]:
|
||||
BRepTools.Clean_s(face.wrapped, False)
|
||||
mesher = BRepMesh_IncrementalMesh(face.wrapped, 0.35, False, 0.22, False)
|
||||
mesher.Perform()
|
||||
location = TopLoc_Location()
|
||||
triangulation = BRep_Tool.Triangulation_s(face.wrapped, location, 0)
|
||||
assert triangulation is not None
|
||||
assert triangulation.HasNormals() is False
|
||||
indices = list(triangulation.Triangle(1).Get())
|
||||
if face.wrapped.Orientation() == TopAbs_REVERSED:
|
||||
indices = [indices[0], indices[2], indices[1]]
|
||||
points = []
|
||||
transform = location.Transformation()
|
||||
for index in indices:
|
||||
point = triangulation.Node(index).Transformed(transform)
|
||||
points.append((point.X() / 1000, point.Z() / 1000, -point.Y() / 1000))
|
||||
first = tuple(points[1][index] - points[0][index] for index in range(3))
|
||||
second = tuple(points[2][index] - points[0][index] for index in range(3))
|
||||
return profile_normalize(profile_cross(first, second))
|
||||
|
||||
|
||||
def test_all_render_profile_characterization_cases_have_targeted_evidence():
|
||||
profile = _render_profile()
|
||||
assert set(profile["rules"]["required_characterization_cases"]) == (
|
||||
CHARACTERIZED_RENDER_PROFILE_CASES
|
||||
)
|
||||
|
||||
|
||||
def test_model_schema_2_topology_witnesses_and_roles_survive_clean_replay():
|
||||
with scad.GraphSession(graph_id="scene-characterization") as session:
|
||||
profile = scad.make_rectangle_rface(width=5, height=3)
|
||||
scad.extrude_rsolid(
|
||||
profile=profile,
|
||||
direction=(0, 0, 1),
|
||||
distance=2,
|
||||
start_face_tag="role.start",
|
||||
end_face_tag="role.end",
|
||||
)
|
||||
|
||||
model_json = scad.export_model_json(session=session)
|
||||
payload = json.loads(model_json)
|
||||
assert payload["schema_version"] == "2.0"
|
||||
assert payload["graph"]["schema_version"] == "2.0"
|
||||
assert {
|
||||
key: payload["graph"]["capabilities"][key]
|
||||
for key in (
|
||||
"topology_delta_entries",
|
||||
"durable_topology_parent_refs",
|
||||
"operation_output_roles",
|
||||
)
|
||||
} == {
|
||||
"topology_delta_entries": True,
|
||||
"durable_topology_parent_refs": True,
|
||||
"operation_output_roles": True,
|
||||
}
|
||||
|
||||
assert len(payload["topology_delta_log"]) == 1
|
||||
witness = payload["topology_delta_log"][0]
|
||||
delta = witness["delta"]
|
||||
assert sorted({entry["role"] for entry in delta["roles"]}) == [
|
||||
"extrusion.end",
|
||||
"extrusion.side",
|
||||
"extrusion.start",
|
||||
]
|
||||
assert all(
|
||||
entry["ref"]["graph_id"] == "scene-characterization"
|
||||
and entry["ref"]["node_id"] == witness["node_id"]
|
||||
for entry in delta["entries"]
|
||||
)
|
||||
|
||||
replayed = scad.replay_model_json(json_str=model_json)
|
||||
assert len(replayed) == 1
|
||||
solid = replayed[0]
|
||||
assert {
|
||||
role: sum(scad.ql.output_role(role)(face) for face in solid._iter_faces())
|
||||
for role in ("extrusion.start", "extrusion.end", "extrusion.side")
|
||||
} == {
|
||||
"extrusion.start": 1,
|
||||
"extrusion.end": 1,
|
||||
"extrusion.side": 4,
|
||||
}
|
||||
|
||||
|
||||
def test_profile_forces_reversed_edges_forward_before_selector_evaluation():
|
||||
profile = _evaluated_profile()
|
||||
preparation = profile["rules"]["shape_preparation"]
|
||||
assert preparation["edge_orientation_call"] == "edge.Oriented(TopAbs_FORWARD)"
|
||||
assert preparation["edge_orientation_order"] == "force_forward_before_location_bake"
|
||||
|
||||
edge = scad.make_line_redge(start=(0, 0, 0), end=(3, 4, 0))
|
||||
reversed_edge = Edge(edge.wrapped.Oriented(TopAbs_REVERSED))
|
||||
forward_edge = Edge(reversed_edge.wrapped.Oriented(TopAbs_FORWARD))
|
||||
|
||||
assert edge.wrapped.Orientation() == TopAbs_FORWARD
|
||||
assert reversed_edge.wrapped.Orientation() == TopAbs_REVERSED
|
||||
assert forward_edge.wrapped.Orientation() == TopAbs_FORWARD
|
||||
assert _make_geo_selector(forward_edge) == _make_geo_selector(edge)
|
||||
assert _geo_selector_score(
|
||||
forward_edge, _make_geo_selector(edge)
|
||||
) == pytest.approx(0.0)
|
||||
|
||||
|
||||
def test_reversed_kernel_traversal_preserves_normalized_evaluated_properties():
|
||||
first = scad.make_box_rsolid(
|
||||
width=1,
|
||||
height=2,
|
||||
depth=3,
|
||||
bottom_face_center=(-5, 0, 0),
|
||||
)
|
||||
second = scad.make_box_rsolid(
|
||||
width=2,
|
||||
height=3,
|
||||
depth=4,
|
||||
bottom_face_center=(5, 0, 0),
|
||||
)
|
||||
forward_root = Compound(
|
||||
make_compound_always([first.wrapped, second.wrapped])
|
||||
)
|
||||
reversed_root = Compound(
|
||||
make_compound_always([second.wrapped, first.wrapped])
|
||||
)
|
||||
forward_solids = forward_root._iter_solids()
|
||||
reversed_solids = reversed_root._iter_solids()
|
||||
|
||||
assert len(forward_solids) == len(reversed_solids) == 2
|
||||
assert forward_solids[0].wrapped.IsSame(first.wrapped)
|
||||
assert forward_solids[1].wrapped.IsSame(second.wrapped)
|
||||
assert reversed_solids[0].wrapped.IsSame(second.wrapped)
|
||||
assert reversed_solids[1].wrapped.IsSame(first.wrapped)
|
||||
|
||||
def evaluated_property_records(root: Compound) -> list[bytes]:
|
||||
records = []
|
||||
for solid in root._iter_solids():
|
||||
selector = _make_geo_selector(solid)
|
||||
records.append(
|
||||
canonical_json_bytes(
|
||||
{
|
||||
"bounds": selector["bbox"],
|
||||
"kind": selector["kind"],
|
||||
"volume": selector["volume"],
|
||||
}
|
||||
)
|
||||
)
|
||||
return records
|
||||
|
||||
forward_records = evaluated_property_records(forward_root)
|
||||
reversed_records = evaluated_property_records(reversed_root)
|
||||
assert forward_records != reversed_records
|
||||
assert tuple(sorted(forward_records)) == tuple(sorted(reversed_records))
|
||||
|
||||
|
||||
def test_symmetric_entities_are_selector_ambiguous_even_if_legacy_resolver_picks_one():
|
||||
profile = _evaluated_profile()
|
||||
selector_rules = profile["rules"]["geo_exact_selector"]
|
||||
threshold = selector_rules["threshold"]
|
||||
assert selector_rules["multiple_match_status"] == "selector_ambiguous"
|
||||
|
||||
first = scad.make_box_rsolid(width=2, height=2, depth=2)
|
||||
second = scad.make_box_rsolid(width=2, height=2, depth=2)
|
||||
compound = Compound(make_compound_always([first.wrapped, second.wrapped]))
|
||||
selector = _make_geo_selector(compound.get_edges(0))
|
||||
candidates = _candidate_shapes_for_geo_selection(compound, "edge")
|
||||
passing = [
|
||||
candidate
|
||||
for candidate in candidates
|
||||
if _geo_selector_score(candidate, selector) <= threshold
|
||||
]
|
||||
|
||||
assert len(passing) == 2
|
||||
legacy_result = _resolve_shape_from_geo_selector(compound, selector)
|
||||
assert any(legacy_result.same_topology(candidate) for candidate in passing)
|
||||
|
||||
|
||||
def test_serialized_closed_edge_connector_replays_but_has_no_current_frame():
|
||||
profile = _evaluated_profile()
|
||||
assert (
|
||||
profile["rules"]["connector_frame"]["edge_undefined"]
|
||||
== "missing_endpoint_or_coincident_endpoints"
|
||||
)
|
||||
|
||||
with scad.GraphSession(graph_id="closed-edge-characterization") as session:
|
||||
edge = scad.make_circle_redge(center=(0, 0, 0), radius=2)
|
||||
scad.make_edge_connector_rconnector(
|
||||
connector_id="closed_edge",
|
||||
edge=edge,
|
||||
)
|
||||
|
||||
replayed = scad.replay_model_json(
|
||||
json_str=scad.export_model_json(session=session)
|
||||
)
|
||||
assert len(replayed) == 1
|
||||
connector = replayed[0]
|
||||
selector = connector.geometry_ref.geo_selector
|
||||
assert selector["start"] == selector["end"]
|
||||
with pytest.raises(ValueError, match="direction must be a non-zero vector"):
|
||||
_ = connector.placement
|
||||
|
||||
|
||||
def test_profile_canonicalizes_negative_zero_before_render_keys():
|
||||
profile = _render_profile()
|
||||
assert profile["rules"]["numeric"]["negative_zero"] == (
|
||||
"canonicalize_to_positive_zero"
|
||||
)
|
||||
assert profile_f32_bits(-0.0) == profile_f32_bits(0.0) == 0
|
||||
|
||||
|
||||
def test_short_valid_ocp_edge_collapses_after_gltf_float32_conversion():
|
||||
profile = _render_profile()
|
||||
assert profile["rules"]["canonical_blocks"]["edge_empty_policy"] == (
|
||||
"retain_degenerate_entity_without_render_block"
|
||||
)
|
||||
edge = scad.make_line_redge(
|
||||
start=(1000, 0, 0),
|
||||
end=(1000.00001, 0, 0),
|
||||
)
|
||||
start = edge.get_start_vertex().get_coordinates()
|
||||
end = edge.get_end_vertex().get_coordinates()
|
||||
|
||||
assert edge.get_length() > 0
|
||||
assert tuple(profile_f32_bits(component / 1000) for component in start) == tuple(
|
||||
profile_f32_bits(component / 1000) for component in end
|
||||
)
|
||||
|
||||
|
||||
def test_missing_kernel_normals_use_oriented_triangle_fallback():
|
||||
profile = _render_profile()
|
||||
assert profile["rules"]["normal"]["fallback"] == (
|
||||
"oriented_triangle_cross_product_after_coordinate_conversion"
|
||||
)
|
||||
face = scad.make_rectangle_rface(width=2, height=3)
|
||||
reversed_face = Face(face.wrapped.Oriented(TopAbs_REVERSED))
|
||||
|
||||
assert _fallback_normal(face) == pytest.approx((0, 1, 0))
|
||||
assert _fallback_normal(reversed_face) == pytest.approx((0, -1, 0))
|
||||
|
||||
|
||||
def test_duplicate_geometry_metadata_changes_selector_bytes_but_not_score():
|
||||
first = scad.make_line_redge(start=(0, 0, 0), end=(1, 0, 0))
|
||||
second = scad.make_line_redge(start=(0, 0, 0), end=(1, 0, 0))
|
||||
first.set_metadata("geo", {"label": "first"})
|
||||
second.set_metadata("geo", {"label": "second"})
|
||||
first_selector = _make_geo_selector(first)
|
||||
second_selector = _make_geo_selector(second)
|
||||
|
||||
assert first_selector["metadata_geo"] != second_selector["metadata_geo"]
|
||||
assert _geo_selector_score(first, second_selector) == pytest.approx(0.0)
|
||||
assert _geo_selector_score(second, first_selector) == pytest.approx(0.0)
|
||||
|
||||
|
||||
def test_duplicate_geometry_provenance_is_distinct_but_not_selector_scored():
|
||||
with scad.GraphSession(graph_id="duplicate-provenance"):
|
||||
first = scad.make_line_redge(start=(0, 0, 0), end=(1, 0, 0))
|
||||
second = scad.make_line_redge(start=(0, 0, 0), end=(1, 0, 0))
|
||||
|
||||
first_node = first._get_runtime("graph.node")
|
||||
second_node = second._get_runtime("graph.node")
|
||||
assert first_node.node_id != second_node.node_id
|
||||
assert _make_geo_selector(first) == _make_geo_selector(second)
|
||||
assert _geo_selector_score(first, _make_geo_selector(second)) == pytest.approx(0.0)
|
||||
|
||||
|
||||
def test_shared_shape_compound_violates_disjoint_solid_ownership_target():
|
||||
profile = _evaluated_profile()
|
||||
topology = profile["rules"]["topology"]
|
||||
assert topology["accepted_root"] == (
|
||||
"single_manifold_solid_or_compound_of_disjoint_manifold_solids"
|
||||
)
|
||||
assert "shared_face_between_solids" in topology["rejected_roots"]
|
||||
|
||||
solid = scad.make_box_rsolid(width=2, height=2, depth=2)
|
||||
compound = Compound(make_compound_always([solid.wrapped, solid.wrapped]))
|
||||
solids = compound._iter_solids()
|
||||
assert len(solids) == 2
|
||||
assert solids[0].wrapped.IsSame(solids[1].wrapped)
|
||||
assert len(compound._iter_faces()) == 12
|
||||
assert len({face.topo_id for face in compound._iter_faces()}) == 6
|
||||
|
||||
|
||||
def test_symmetric_graph_canonicalization_has_a_hard_failure_budget():
|
||||
profile = _evaluated_profile()
|
||||
labeling = profile["rules"]["canonical_labeling"]
|
||||
assert labeling["maximum_states"] == 1_000_000
|
||||
assert labeling["budget_error"] == "entity_canonicalization_budget_exceeded"
|
||||
assert labeling["exact_candidate_ties"] == (
|
||||
"arbitrary_order_but_evaluate_every_branch"
|
||||
)
|
||||
@@ -0,0 +1,389 @@
|
||||
"""Tests for BRep tracking: boolean operation history capture via OCC Modified/Generated/IsDeleted."""
|
||||
|
||||
import unittest
|
||||
|
||||
import simplecadapi as scad
|
||||
from simplecadapi.topology import (
|
||||
TopoKind,
|
||||
TopoEvent,
|
||||
TopoRef,
|
||||
TopoDelta,
|
||||
OperationNode,
|
||||
OperationGraph,
|
||||
)
|
||||
from simplecadapi.topology.tracking import (
|
||||
tracked_cut,
|
||||
tracked_union,
|
||||
tracked_intersect,
|
||||
TrackedBooleanResult,
|
||||
)
|
||||
|
||||
|
||||
class TestTrackedCut(unittest.TestCase):
|
||||
"""Test cut with full face-level history."""
|
||||
|
||||
def setUp(self):
|
||||
self.body = scad.make_box_rsolid(10, 10, 10)
|
||||
self.tool = scad.make_cylinder_rsolid(
|
||||
2.0, 15.0, bottom_face_center=(3, 3, -2.5)
|
||||
)
|
||||
|
||||
def test_tracked_cut_returns_solid_and_delta(self):
|
||||
result = tracked_cut(self.body, self.tool)
|
||||
self.assertIsInstance(result, TrackedBooleanResult)
|
||||
self.assertIsNotNone(result.solid)
|
||||
self.assertIsInstance(result.delta, TopoDelta)
|
||||
|
||||
def test_tracked_cut_has_preserved_faces(self):
|
||||
result = tracked_cut(self.body, self.tool)
|
||||
preserved_face_refs = [
|
||||
r for r in result.delta.preserved if r.kind == TopoKind.FACE
|
||||
]
|
||||
# After a cylinder cut through a box, most original faces should be
|
||||
# either modified or preserved; some should survive
|
||||
self.assertGreater(len(preserved_face_refs), 0)
|
||||
|
||||
def test_tracked_cut_has_proven_changed_faces(self):
|
||||
result = tracked_cut(self.body, self.tool)
|
||||
changed_faces = [
|
||||
entry
|
||||
for entry in result.delta.entries
|
||||
if entry.ref.kind == TopoKind.FACE
|
||||
and entry.event in {TopoEvent.MODIFIED, TopoEvent.GENERATED}
|
||||
and entry.metadata["status"] == "proven"
|
||||
]
|
||||
self.assertGreater(len(changed_faces), 0)
|
||||
|
||||
def test_tracked_cut_volume_decreased(self):
|
||||
result = tracked_cut(self.body, self.tool)
|
||||
original_vol = self.body.get_volume()
|
||||
result_vol = result.solid.get_volume()
|
||||
self.assertLess(result_vol, original_vol)
|
||||
|
||||
def test_tracked_cut_total_faces_increased(self):
|
||||
"""A cylinder cut through a box adds the cylindrical hole face."""
|
||||
result = tracked_cut(self.body, self.tool)
|
||||
original_faces = len(self.body._iter_faces())
|
||||
result_faces = len(result.solid._iter_faces())
|
||||
# Cylinder through box: at least 1 new face (cylindrical hole)
|
||||
self.assertGreaterEqual(result_faces, original_faces)
|
||||
|
||||
def test_tracked_cut_tool_with_tool_face_labels(self):
|
||||
"""Faces from the tool should be labeled with origin_role='tool'."""
|
||||
result = tracked_cut(self.body, self.tool)
|
||||
tool_outputs = [
|
||||
entry
|
||||
for entry in result.delta.entries
|
||||
if entry.ref.kind == TopoKind.FACE
|
||||
and entry.origin_role == "tool"
|
||||
and entry.event in {TopoEvent.MODIFIED, TopoEvent.GENERATED}
|
||||
]
|
||||
self.assertGreater(len(tool_outputs), 0)
|
||||
self.assertTrue(all(entry.parent_refs for entry in tool_outputs))
|
||||
|
||||
def test_tracked_cut_preserves_volume_accuracy(self):
|
||||
result = tracked_cut(self.body, self.tool)
|
||||
# Volume should be original minus roughly the cylinder volume
|
||||
expected_min = self.body.get_volume() - 3.14159 * 2.0**2 * 15.0
|
||||
self.assertGreater(result.solid.get_volume(), 0)
|
||||
|
||||
|
||||
|
||||
class TestMultiToolCut(unittest.TestCase):
|
||||
"""A cut with many tools records one delta merged from its steps."""
|
||||
|
||||
@staticmethod
|
||||
def _cut_entries():
|
||||
with scad.GraphSession(graph_id="multi_cut"):
|
||||
plate = scad.make_box_rsolid(60.0, 40.0, 4.0)
|
||||
# Overlapping tools: each step modifies faces the step before
|
||||
# made, and those intermediate faces are freed.
|
||||
tools = [
|
||||
scad.make_box_rsolid(3.0, 18.0, 6.0, bottom_face_center=(-26.0 + 2.0 * k, 0.0, -1.0))
|
||||
for k in range(16)
|
||||
]
|
||||
tools += [
|
||||
scad.make_cylinder_rsolid(2.0, 6.0, bottom_face_center=(-26.0 + 2.0 * k, 9.0, -1.0))
|
||||
for k in range(16)
|
||||
]
|
||||
result = scad.cut_rsolid(plate, tools)
|
||||
return result._get_runtime("graph.node").topo_delta.entries
|
||||
|
||||
def test_the_merged_delta_is_the_same_on_every_run(self):
|
||||
# A freed intermediate face's address can be reused by an output
|
||||
# face; a stale step entry then resolved to it, run-dependently.
|
||||
first = self._cut_entries()
|
||||
for _ in range(3):
|
||||
self.assertEqual(self._cut_entries(), first)
|
||||
|
||||
class TestTrackedUnion(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.body = scad.make_box_rsolid(10, 10, 10)
|
||||
# Use a cylinder to ensure curved intersection edges
|
||||
self.tool = scad.make_cylinder_rsolid(4.0, 10.0, bottom_face_center=(3, 3, 0))
|
||||
|
||||
def test_tracked_union_returns_solid_and_delta(self):
|
||||
result = tracked_union(self.body, self.tool)
|
||||
self.assertIsInstance(result, TrackedBooleanResult)
|
||||
self.assertIsNotNone(result.solid)
|
||||
|
||||
def test_tracked_union_volume_increased(self):
|
||||
result = tracked_union(self.body, self.tool)
|
||||
original_vol = self.body.get_volume()
|
||||
result_vol = result.solid.get_volume()
|
||||
# Union of two overlapping boxes should be less than sum but more than either
|
||||
self.assertGreater(result_vol, original_vol)
|
||||
|
||||
def test_tracked_union_has_section_edges(self):
|
||||
# OCC may suppress SectionEdges under glue mode; disabling glue should expose them.
|
||||
result = tracked_union(self.body, self.tool, glue=False)
|
||||
section_edges = result.delta.section_edges
|
||||
self.assertGreater(len(section_edges), 0)
|
||||
|
||||
for section_ref in section_edges:
|
||||
entries = [
|
||||
entry
|
||||
for entry in result.delta.entries
|
||||
if entry.ref == section_ref
|
||||
]
|
||||
self.assertGreaterEqual(len(entries), 2)
|
||||
self.assertEqual(
|
||||
{entry.origin_role for entry in entries}, {"body", "tool"}
|
||||
)
|
||||
self.assertTrue(all(entry.parent_refs for entry in entries))
|
||||
|
||||
def test_nary_union_tracks_every_input_through_clean_history(self):
|
||||
solids = [
|
||||
scad.make_box_rsolid(
|
||||
1.0,
|
||||
1.0,
|
||||
1.0,
|
||||
bottom_face_center=(float(index), 0.0, 0.0),
|
||||
)
|
||||
for index in range(3)
|
||||
]
|
||||
|
||||
result = scad.union_rsolid(*solids, glue=False)
|
||||
tracks = [face.get_metadata("track") for face in result._iter_faces()]
|
||||
|
||||
self.assertEqual(len(result._iter_faces()), 6)
|
||||
self.assertTrue(all(track["status"] == "proven" for track in tracks))
|
||||
self.assertEqual(
|
||||
{role for track in tracks for role in track["origin_roles"]},
|
||||
{"body", "tool", "tool_2"},
|
||||
)
|
||||
self.assertTrue(result.get_metadata("track")["has_delta"])
|
||||
|
||||
def test_nary_union_keeps_modified_face_lineage_after_clean(self):
|
||||
barrel = scad.make_cylinder_rsolid(
|
||||
16.0,
|
||||
120.0,
|
||||
bottom_face_center=(-60.0, 0.0, 0.0),
|
||||
axis=(1.0, 0.0, 0.0),
|
||||
)
|
||||
flange = scad.make_cylinder_rsolid(
|
||||
22.0,
|
||||
12.0,
|
||||
bottom_face_center=(50.0, 0.0, 0.0),
|
||||
axis=(1.0, 0.0, 0.0),
|
||||
)
|
||||
nose = scad.make_cylinder_rsolid(
|
||||
13.0,
|
||||
10.0,
|
||||
bottom_face_center=(58.0, 0.0, 0.0),
|
||||
axis=(1.0, 0.0, 0.0),
|
||||
)
|
||||
source_face = max(flange._iter_faces(), key=lambda face: face.get_center().x)
|
||||
scad.apply_tag(source_face, "cap.face.end")
|
||||
|
||||
result = scad.union_rsolid(barrel, flange, nose, glue=False)
|
||||
descendants = [
|
||||
face
|
||||
for face in result._iter_faces()
|
||||
if "cap.face.end" in scad.list_tags(face, scope="lineage")
|
||||
]
|
||||
|
||||
self.assertEqual(len(descendants), 1)
|
||||
self.assertAlmostEqual(descendants[0].get_center().x, 62.0, places=6)
|
||||
self.assertAlmostEqual(descendants[0].get_area(), 989.6016859, places=5)
|
||||
self.assertEqual(descendants[0].get_metadata("track")["event"], "modified")
|
||||
self.assertNotIn("cap.face.end", scad.list_tags(descendants[0]))
|
||||
|
||||
def test_nary_union_respects_face_binding_lineage_policy(self):
|
||||
barrel = scad.make_cylinder_rsolid(
|
||||
16.0,
|
||||
120.0,
|
||||
bottom_face_center=(-60.0, 0.0, 0.0),
|
||||
axis=(1.0, 0.0, 0.0),
|
||||
)
|
||||
flange = scad.make_cylinder_rsolid(
|
||||
22.0,
|
||||
12.0,
|
||||
bottom_face_center=(50.0, 0.0, 0.0),
|
||||
axis=(1.0, 0.0, 0.0),
|
||||
)
|
||||
nose = scad.make_cylinder_rsolid(
|
||||
13.0,
|
||||
10.0,
|
||||
bottom_face_center=(58.0, 0.0, 0.0),
|
||||
axis=(1.0, 0.0, 0.0),
|
||||
)
|
||||
source_face = max(flange._iter_faces(), key=lambda face: face.get_center().x)
|
||||
flange = scad.apply_tag_rselection(
|
||||
flange,
|
||||
[source_face],
|
||||
"cap.face.end",
|
||||
lineage_policy=scad.LineagePolicy.NONE,
|
||||
)
|
||||
|
||||
result = scad.union_rsolid(barrel, flange, nose, glue=False)
|
||||
|
||||
self.assertFalse(
|
||||
any("cap.face.end" in scad.list_tags(face) for face in result._iter_faces())
|
||||
)
|
||||
|
||||
def test_nary_union_face_binding_stays_directly_queryable_after_cut(self):
|
||||
flange = scad.extrude_rsolid(
|
||||
scad.make_circle_rface(
|
||||
center=(0.0, 0.0, 0.0),
|
||||
radius=2.0,
|
||||
normal=(1.0, 0.0, 0.0),
|
||||
),
|
||||
direction=(1.0, 0.0, 0.0),
|
||||
distance=2.0,
|
||||
start_face_tag="cap.face.start",
|
||||
end_face_tag="cap.face.end",
|
||||
side_faces_tag="cap.face.side",
|
||||
)
|
||||
source_end = scad.select_faces_by_tag(flange, "cap.face.end")[0]
|
||||
source_explanation = scad.explain_tag(
|
||||
source_end, "cap.face.end", scope="local"
|
||||
)[0]
|
||||
body = scad.make_cylinder_rsolid(
|
||||
1.5,
|
||||
4.0,
|
||||
bottom_face_center=(-1.0, 0.0, 0.0),
|
||||
axis=(1.0, 0.0, 0.0),
|
||||
)
|
||||
bridge = scad.make_box_rsolid(
|
||||
1.0,
|
||||
1.0,
|
||||
1.0,
|
||||
bottom_face_center=(-0.5, -0.5, -0.5),
|
||||
)
|
||||
fused = scad.union_rsolid(body, flange, bridge, glue=False)
|
||||
result = scad.cut_rsolid(
|
||||
fused,
|
||||
scad.make_cylinder_rsolid(
|
||||
0.25,
|
||||
4.0,
|
||||
bottom_face_center=(-1.0, 1.0, 0.0),
|
||||
axis=(1.0, 0.0, 0.0),
|
||||
),
|
||||
)
|
||||
|
||||
end_faces = scad.select_faces_by_tag(result, "cap.face.end")
|
||||
|
||||
self.assertEqual(len(end_faces), 1)
|
||||
projected = scad.explain_tag(
|
||||
end_faces[0], "cap.face.end", scope="local"
|
||||
)[0]["binding"]["evidence"]
|
||||
self.assertEqual(
|
||||
projected["source_binding_id"], source_explanation["binding_id"]
|
||||
)
|
||||
self.assertEqual(projected["source_topo_id"], source_end.topo_id)
|
||||
|
||||
def test_nary_union_tracks_faces_without_cleaning(self):
|
||||
solids = [
|
||||
scad.make_box_rsolid(
|
||||
1.0,
|
||||
1.0,
|
||||
1.0,
|
||||
bottom_face_center=(float(index), 0.0, 0.0),
|
||||
)
|
||||
for index in range(3)
|
||||
]
|
||||
|
||||
result = scad.union_rsolid(*solids, clean=False, glue=False)
|
||||
|
||||
self.assertEqual(len(result._iter_faces()), 14)
|
||||
self.assertTrue(
|
||||
all(
|
||||
face.get_metadata("track")["status"] == "proven"
|
||||
for face in result._iter_faces()
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
class TestTrackedIntersect(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.body = scad.make_box_rsolid(10, 10, 10)
|
||||
self.tool = scad.make_cylinder_rsolid(6.0, 10.0, bottom_face_center=(3, 3, 0))
|
||||
|
||||
def test_tracked_intersect_returns_solid_and_delta(self):
|
||||
result = tracked_intersect(self.body, self.tool)
|
||||
self.assertIsInstance(result, TrackedBooleanResult)
|
||||
self.assertIsNotNone(result.solid)
|
||||
|
||||
def test_tracked_intersect_volume_less_than_both(self):
|
||||
result = tracked_intersect(self.body, self.tool)
|
||||
self.assertLess(result.solid.get_volume(), self.body.get_volume())
|
||||
self.assertLess(result.solid.get_volume(), self.tool.get_volume())
|
||||
|
||||
|
||||
class TestDeltaEntries(unittest.TestCase):
|
||||
"""Test that delta_entries provides origin_role info."""
|
||||
|
||||
def setUp(self):
|
||||
self.body = scad.make_box_rsolid(10, 10, 10)
|
||||
self.tool = scad.make_cylinder_rsolid(
|
||||
3.0, 15.0, bottom_face_center=(3, 3, -2.5)
|
||||
)
|
||||
|
||||
def test_body_faces_labeled(self):
|
||||
result = tracked_cut(self.body, self.tool)
|
||||
body_preserved = [
|
||||
r
|
||||
for r in result.delta.preserved
|
||||
if r.kind == TopoKind.FACE
|
||||
and result.delta_entries.get(r.topo_id, {}).get("origin_role") == "body"
|
||||
]
|
||||
self.assertGreater(len(body_preserved), 0)
|
||||
|
||||
def test_modified_faces_labeled(self):
|
||||
result = tracked_cut(self.body, self.tool)
|
||||
body_modified = [
|
||||
r
|
||||
for r in result.delta.modified
|
||||
if r.kind == TopoKind.FACE
|
||||
and result.delta_entries.get(r.topo_id, {}).get("origin_role") == "body"
|
||||
]
|
||||
# Some faces from body should be modified
|
||||
self.assertGreater(len(body_modified), 0)
|
||||
|
||||
|
||||
class TestSolidMapping(unittest.TestCase):
|
||||
"""Test that the result solid is a valid SimpleCADAPI Solid."""
|
||||
|
||||
def setUp(self):
|
||||
self.body = scad.make_box_rsolid(10, 10, 10)
|
||||
self.tool = scad.make_cylinder_rsolid(
|
||||
2.0, 15.0, bottom_face_center=(3, 3, -2.5)
|
||||
)
|
||||
|
||||
def test_result_is_solid(self):
|
||||
result = tracked_cut(self.body, self.tool)
|
||||
self.assertIsInstance(result.solid, scad.Solid)
|
||||
|
||||
def test_result_has_faces(self):
|
||||
result = tracked_cut(self.body, self.tool)
|
||||
faces = result.solid._iter_faces()
|
||||
self.assertGreater(len(faces), 0)
|
||||
|
||||
def test_result_has_valid_volume(self):
|
||||
result = tracked_cut(self.body, self.tool)
|
||||
self.assertGreater(result.solid.get_volume(), 0)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,144 @@
|
||||
"""Tests for tracking transforms and feature operations."""
|
||||
|
||||
import unittest
|
||||
import numpy as np
|
||||
|
||||
import simplecadapi as scad
|
||||
from simplecadapi.topology import TopoKind, TopoEvent, TopoRef, TopoDelta
|
||||
from simplecadapi.topology.tracking import (
|
||||
tracked_translate,
|
||||
tracked_rotate,
|
||||
tracked_extrude,
|
||||
tracked_fillet,
|
||||
tracked_chamfer,
|
||||
TrackedResult,
|
||||
)
|
||||
|
||||
|
||||
class TestTrackedTranslate(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.box = scad.make_box_rsolid(10, 10, 10)
|
||||
|
||||
def test_translate_returns_tracked_result(self):
|
||||
result = tracked_translate(self.box, (5, 0, 0))
|
||||
self.assertIsInstance(result, TrackedResult)
|
||||
self.assertIsNotNone(result.shape)
|
||||
|
||||
def test_translate_preserves_volume(self):
|
||||
result = tracked_translate(self.box, (5, 0, 0))
|
||||
self.assertAlmostEqual(
|
||||
result.shape.get_volume(), self.box.get_volume(), places=6
|
||||
)
|
||||
|
||||
def test_translate_all_faces_modified(self):
|
||||
result = tracked_translate(self.box, (5, 0, 0))
|
||||
modified = [r for r in result.delta.modified if r.kind == TopoKind.FACE]
|
||||
original_faces = len(self.box._iter_faces())
|
||||
self.assertEqual(len(modified), original_faces)
|
||||
|
||||
def test_translate_no_generated(self):
|
||||
result = tracked_translate(self.box, (5, 0, 0))
|
||||
self.assertEqual(len(result.delta.generated), 0)
|
||||
self.assertEqual(len(result.delta.deleted), 0)
|
||||
|
||||
def test_translate_result_is_solid(self):
|
||||
result = tracked_translate(self.box, (5, 0, 0))
|
||||
self.assertIsInstance(result.shape, scad.Solid)
|
||||
|
||||
|
||||
class TestTrackedRotate(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.box = scad.make_box_rsolid(10, 10, 10)
|
||||
|
||||
def test_rotate_returns_tracked_result(self):
|
||||
result = tracked_rotate(self.box, 45.0, (0, 0, 1))
|
||||
self.assertIsInstance(result, TrackedResult)
|
||||
self.assertIsNotNone(result.shape)
|
||||
|
||||
def test_rotate_preserves_volume(self):
|
||||
result = tracked_rotate(self.box, 45.0, (0, 0, 1))
|
||||
self.assertAlmostEqual(
|
||||
result.shape.get_volume(), self.box.get_volume(), places=4
|
||||
)
|
||||
|
||||
def test_rotate_all_faces_modified(self):
|
||||
result = tracked_rotate(self.box, 45.0, (0, 0, 1))
|
||||
modified = [r for r in result.delta.modified if r.kind == TopoKind.FACE]
|
||||
original_faces = len(self.box._iter_faces())
|
||||
self.assertEqual(len(modified), original_faces)
|
||||
|
||||
def test_rotate_no_generated(self):
|
||||
result = tracked_rotate(self.box, 45.0, (0, 0, 1))
|
||||
self.assertEqual(len(result.delta.generated), 0)
|
||||
|
||||
|
||||
class TestTrackedExtrude(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.profile = scad.make_rectangle_rface(5.0, 3.0)
|
||||
|
||||
def test_extrude_returns_tracked_result(self):
|
||||
result = tracked_extrude(self.profile, (0, 0, 1), 10.0)
|
||||
self.assertIsInstance(result, TrackedResult)
|
||||
self.assertIsNotNone(result.shape)
|
||||
|
||||
def test_extrude_has_correct_volume(self):
|
||||
result = tracked_extrude(self.profile, (0, 0, 1), 10.0)
|
||||
expected_vol = self.profile.get_area() * 10.0
|
||||
self.assertAlmostEqual(result.shape.get_volume(), expected_vol, places=5)
|
||||
|
||||
def test_extrude_generates_new_faces(self):
|
||||
result = tracked_extrude(self.profile, (0, 0, 1), 10.0)
|
||||
self.assertGreater(len(result.delta.generated), 0)
|
||||
|
||||
def test_extrude_has_modified_or_preserved_face(self):
|
||||
result = tracked_extrude(self.profile, (0, 0, 1), 10.0)
|
||||
# The profile face becomes part of the extruded solid (either modified or
|
||||
# generated depending on OCC version)
|
||||
has_changes = (
|
||||
len(result.delta.modified) > 0
|
||||
or len(result.delta.preserved) > 0
|
||||
or len(result.delta.generated) > 0
|
||||
)
|
||||
self.assertTrue(has_changes)
|
||||
|
||||
|
||||
class TestTrackedFillet(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.box = scad.make_box_rsolid(10, 10, 10)
|
||||
# Select some edges for filleting
|
||||
self.edges = [self.box.get_edges(i) for i in range(4)]
|
||||
|
||||
def test_fillet_returns_tracked_result(self):
|
||||
result = tracked_fillet(self.box, self.edges, 0.5)
|
||||
self.assertIsInstance(result, TrackedResult)
|
||||
self.assertIsNotNone(result.shape)
|
||||
|
||||
def test_fillet_volume_decreased(self):
|
||||
result = tracked_fillet(self.box, self.edges, 0.5)
|
||||
self.assertLess(result.shape.get_volume(), self.box.get_volume())
|
||||
|
||||
def test_fillet_has_modified_faces(self):
|
||||
result = tracked_fillet(self.box, self.edges, 0.5)
|
||||
# Fillet modifies edge-adjacent faces; OCC may report new toroidal faces
|
||||
# as Modified rather than Generated
|
||||
total_changes = len(result.delta.modified) + len(result.delta.generated)
|
||||
self.assertGreater(total_changes, 0)
|
||||
|
||||
|
||||
class TestTrackedChamfer(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.box = scad.make_box_rsolid(10, 10, 10)
|
||||
self.edges = [self.box.get_edges(i) for i in range(4)]
|
||||
|
||||
def test_chamfer_returns_tracked_result(self):
|
||||
result = tracked_chamfer(self.box, self.edges, 0.5)
|
||||
self.assertIsInstance(result, TrackedResult)
|
||||
self.assertIsNotNone(result.shape)
|
||||
|
||||
def test_chamfer_volume_decreased(self):
|
||||
result = tracked_chamfer(self.box, self.edges, 0.5)
|
||||
self.assertLess(result.shape.get_volume(), self.box.get_volume())
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,187 @@
|
||||
"""Tests for evidence-gated semantic projections from TopoDelta."""
|
||||
|
||||
import unittest
|
||||
|
||||
import simplecadapi as scad
|
||||
from simplecadapi import ql as Q
|
||||
from simplecadapi.topology import TopoDelta
|
||||
from simplecadapi.topology.tracking import tracked_cut, tracked_union, tracked_extrude
|
||||
from simplecadapi.topology.autotag import apply_tracking_tags_to_delta
|
||||
|
||||
|
||||
def proven_event(op: str, event: str):
|
||||
return Q.and_(
|
||||
Q.operation_event(op, event),
|
||||
Q.meta("track.status", "==", "proven"),
|
||||
)
|
||||
|
||||
|
||||
class TestAutoTagCut(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.body = scad.make_box_rsolid(10, 10, 10)
|
||||
self.tool = scad.make_cylinder_rsolid(
|
||||
2.0, 15.0, bottom_face_center=(3, 3, -2.5)
|
||||
)
|
||||
|
||||
def test_cut_result_faces_get_typed_operation_evidence(self):
|
||||
result = tracked_cut(self.body, self.tool)
|
||||
tagged_solid = apply_tracking_tags_to_delta(
|
||||
result.solid, result.delta, result.delta_entries, op="cut"
|
||||
)
|
||||
faces = tagged_solid._iter_faces()
|
||||
has_change = any(
|
||||
proven_event("cut", "modified")(face)
|
||||
or proven_event("cut", "generated")(face)
|
||||
for face in faces
|
||||
)
|
||||
self.assertTrue(has_change)
|
||||
|
||||
def test_cut_preserved_faces_have_typed_evidence(self):
|
||||
result = tracked_cut(self.body, self.tool)
|
||||
tagged_solid = apply_tracking_tags_to_delta(
|
||||
result.solid, result.delta, result.delta_entries, op="cut"
|
||||
)
|
||||
faces = tagged_solid._iter_faces()
|
||||
preserved = [face for face in faces if proven_event("cut", "preserved")(face)]
|
||||
self.assertGreater(len(preserved), 0)
|
||||
|
||||
def test_cut_all_faces_have_tracking_envelopes_not_flat_tracking_tags(self):
|
||||
result = tracked_cut(self.body, self.tool)
|
||||
tagged_solid = apply_tracking_tags_to_delta(
|
||||
result.solid, result.delta, result.delta_entries, op="cut"
|
||||
)
|
||||
faces = tagged_solid._iter_faces()
|
||||
for face in faces:
|
||||
track = face.get_metadata("track")
|
||||
self.assertEqual(track["schema_version"], "1.0")
|
||||
self.assertEqual(track["kind"], "topology_change")
|
||||
self.assertEqual(track["operation"], "cut")
|
||||
self.assertEqual(track["topo_kind"], "FACE")
|
||||
self.assertIn(track["coverage"], {"complete", "partial"})
|
||||
self.assertIn(track["status"], {"proven", "unknown"})
|
||||
self.assertFalse(
|
||||
any(
|
||||
tag.startswith(("op.", "origin."))
|
||||
for tag in scad.list_tags(face)
|
||||
)
|
||||
)
|
||||
|
||||
def test_cut_origin_roles_are_typed_evidence(self):
|
||||
result = tracked_cut(self.body, self.tool)
|
||||
tagged_solid = apply_tracking_tags_to_delta(
|
||||
result.solid, result.delta, result.delta_entries, op="cut"
|
||||
)
|
||||
faces = tagged_solid._iter_faces()
|
||||
proven = Q.meta("track.status", "==", "proven")
|
||||
has_body = any(Q.origin_role("body")(face) and proven(face) for face in faces)
|
||||
has_tool = any(Q.origin_role("tool")(face) and proven(face) for face in faces)
|
||||
self.assertTrue(has_body)
|
||||
self.assertTrue(has_tool)
|
||||
|
||||
def test_unmatched_faces_remain_partial_and_unknown(self):
|
||||
solid = scad.make_box_rsolid(1.0, 1.0, 1.0)
|
||||
tagged = apply_tracking_tags_to_delta(solid, TopoDelta(), op="cut")
|
||||
|
||||
for face in tagged._iter_faces():
|
||||
track = face.get_metadata("track")
|
||||
self.assertEqual(track["coverage"], "partial")
|
||||
self.assertEqual(track["status"], "unknown")
|
||||
self.assertEqual(track["events"], [])
|
||||
self.assertEqual(track["origin_roles"], [])
|
||||
self.assertEqual(track["witnesses"], [])
|
||||
self.assertFalse(Q.operation_event("cut")(face))
|
||||
|
||||
|
||||
class TestAutoTagUnion(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.body = scad.make_box_rsolid(10, 10, 10)
|
||||
self.tool = scad.make_cylinder_rsolid(4.0, 10.0, bottom_face_center=(3, 3, 0))
|
||||
|
||||
def test_union_faces_have_typed_operation_evidence(self):
|
||||
result = tracked_union(self.body, self.tool, glue=False)
|
||||
tagged_solid = apply_tracking_tags_to_delta(
|
||||
result.solid, result.delta, result.delta_entries, op="union"
|
||||
)
|
||||
faces = tagged_solid._iter_faces()
|
||||
has_union_evidence = any(
|
||||
proven_event("union", "modified")(face)
|
||||
or proven_event("union", "preserved")(face)
|
||||
for face in faces
|
||||
)
|
||||
self.assertTrue(has_union_evidence)
|
||||
|
||||
section_tracks = [
|
||||
edge.get_metadata("track")
|
||||
for edge in tagged_solid._iter_edges()
|
||||
if edge.get_metadata("track").get("section")
|
||||
]
|
||||
self.assertTrue(section_tracks)
|
||||
self.assertTrue(
|
||||
all(
|
||||
{"body", "tool"}.issubset(track["origin_roles"])
|
||||
and len(track["witnesses"]) >= 2
|
||||
for track in section_tracks
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
class TestAutoTagExtrude(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.profile = scad.make_rectangle_rface(5.0, 3.0)
|
||||
|
||||
def test_extrude_roles_are_kernel_proven_without_geometry_guesses(self):
|
||||
result = tracked_extrude(self.profile, (0, 0, 1), 10.0)
|
||||
tagged_solid = apply_tracking_tags_to_delta(
|
||||
result.shape, result.delta, result.delta_entries, op="extrude"
|
||||
)
|
||||
faces = tagged_solid._iter_faces()
|
||||
self.assertTrue(faces)
|
||||
roles = [
|
||||
role
|
||||
for face in faces
|
||||
for role in face.get_metadata("track")["result_roles"]
|
||||
]
|
||||
self.assertEqual(roles.count("extrusion.start"), 1)
|
||||
self.assertEqual(roles.count("extrusion.end"), 1)
|
||||
self.assertEqual(roles.count("extrusion.side"), 4)
|
||||
self.assertTrue(all(Q.output_role(role)(face) for face in faces for role in face.get_metadata("track")["result_roles"]))
|
||||
|
||||
|
||||
class TestAutoTagPreservesExisting(unittest.TestCase):
|
||||
def test_user_semantics_are_available_only_through_proven_lineage(self):
|
||||
body = scad.make_box_rsolid(10, 10, 10)
|
||||
for face in body._iter_faces():
|
||||
scad.apply_tag(face, "role.source_face")
|
||||
tool = scad.make_cylinder_rsolid(2.0, 15.0, bottom_face_center=(3, 3, -2.5))
|
||||
result = tracked_cut(body, tool)
|
||||
tagged_solid = apply_tracking_tags_to_delta(
|
||||
result.solid,
|
||||
result.delta,
|
||||
result.delta_entries,
|
||||
op="cut",
|
||||
source_solid=body,
|
||||
)
|
||||
body_descendants = [
|
||||
face
|
||||
for face in tagged_solid._iter_faces()
|
||||
if Q.origin_role("body")(face)
|
||||
and face.get_metadata("track")["status"] == "proven"
|
||||
]
|
||||
|
||||
self.assertTrue(body_descendants)
|
||||
self.assertTrue(
|
||||
any(
|
||||
"role.source_face" in scad.list_tags(face, scope="lineage")
|
||||
for face in body_descendants
|
||||
)
|
||||
)
|
||||
self.assertTrue(
|
||||
all(
|
||||
"role.source_face" not in scad.list_tags(face, scope="effective")
|
||||
for face in body_descendants
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,534 @@
|
||||
"""Complete coverage for physical units and dimensional expression inference."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import math
|
||||
import unittest
|
||||
|
||||
import simplecadapi as scad
|
||||
from simplecadapi.params.units import _infer, unit_to_payload
|
||||
|
||||
|
||||
class TestDimensionsAndUnits(unittest.TestCase):
|
||||
def test_named_dimensions_and_dimension_algebra(self):
|
||||
self.assertEqual(scad.DIMENSIONLESS.name, "Dimensionless")
|
||||
self.assertEqual(scad.LENGTH.name, "Length")
|
||||
self.assertEqual(scad.AREA.name, "Area")
|
||||
self.assertEqual(scad.VOLUME.name, "Volume")
|
||||
self.assertEqual(scad.ANGLE.name, "Angle")
|
||||
self.assertEqual(scad.LENGTH.multiply(scad.LENGTH), scad.AREA)
|
||||
self.assertEqual(scad.VOLUME.divide(scad.LENGTH), scad.AREA)
|
||||
self.assertEqual(scad.LENGTH.power(3), scad.VOLUME)
|
||||
self.assertEqual(scad.AREA.square_root(), scad.LENGTH)
|
||||
self.assertEqual(scad.Dimension(length=-1, angle=2).symbol, "L^-1 A^2")
|
||||
self.assertTrue(scad.DIMENSIONLESS.is_dimensionless)
|
||||
self.assertTrue(scad.LENGTH.is_design_dimension)
|
||||
self.assertTrue(scad.ANGLE.is_design_dimension)
|
||||
self.assertFalse(scad.AREA.is_design_dimension)
|
||||
|
||||
def test_dimension_serialization_and_validation(self):
|
||||
self.assertEqual(
|
||||
scad.Dimension.from_dict(scad.VOLUME.to_dict()), scad.VOLUME
|
||||
)
|
||||
invalid = [
|
||||
None,
|
||||
{},
|
||||
{"length": 1},
|
||||
{"length": True, "angle": 0},
|
||||
{"length": 1, "angle": 0.5},
|
||||
]
|
||||
for payload in invalid:
|
||||
with self.subTest(payload=payload), self.assertRaises(
|
||||
(TypeError, ValueError)
|
||||
):
|
||||
scad.Dimension.from_dict(payload)
|
||||
with self.assertRaises(TypeError):
|
||||
scad.LENGTH.power(0.5)
|
||||
with self.assertRaises(scad.UnitValidationError):
|
||||
scad.LENGTH.square_root()
|
||||
|
||||
def test_every_registered_unit_converts_to_canonical_units(self):
|
||||
conversions = [
|
||||
(scad.MM, 1.0),
|
||||
(scad.CM, 10.0),
|
||||
(scad.M, 1000.0),
|
||||
(scad.INCH, 25.4),
|
||||
(scad.FOOT, 304.8),
|
||||
(scad.DEGREE, 1.0),
|
||||
(scad.RADIAN, 180.0 / math.pi),
|
||||
(scad.ONE, 1.0),
|
||||
(scad.PERCENT, 0.01),
|
||||
(scad.SQUARE_MM, 1.0),
|
||||
(scad.SQUARE_CM, 100.0),
|
||||
(scad.SQUARE_M, 1_000_000.0),
|
||||
(scad.SQUARE_INCH, 25.4**2),
|
||||
(scad.SQUARE_FOOT, 304.8**2),
|
||||
(scad.CUBIC_MM, 1.0),
|
||||
(scad.CUBIC_CM, 1000.0),
|
||||
(scad.CUBIC_M, 1_000_000_000.0),
|
||||
(scad.CUBIC_INCH, 25.4**3),
|
||||
(scad.CUBIC_FOOT, 304.8**3),
|
||||
]
|
||||
for unit, expected in conversions:
|
||||
with self.subTest(unit=unit.symbol):
|
||||
self.assertAlmostEqual(unit.to_canonical(1.0), expected)
|
||||
self.assertAlmostEqual(unit.from_canonical(expected), 1.0)
|
||||
self.assertIs(scad.get_unit(unit), unit)
|
||||
self.assertEqual(scad.get_unit(unit.symbol), unit)
|
||||
self.assertEqual(
|
||||
scad.canonical_unit_for_dimension(unit.dimension).dimension,
|
||||
unit.dimension,
|
||||
)
|
||||
|
||||
def test_unit_aliases_and_conversion(self):
|
||||
aliases = {
|
||||
"millimeters": scad.MM,
|
||||
"centimeter": scad.CM,
|
||||
"meters": scad.M,
|
||||
"inches": scad.INCH,
|
||||
"feet": scad.FOOT,
|
||||
"degrees": scad.DEGREE,
|
||||
"radians": scad.RADIAN,
|
||||
"percent": scad.PERCENT,
|
||||
"square feet": scad.SQUARE_FOOT,
|
||||
"cubic inches": scad.CUBIC_INCH,
|
||||
"ml": scad.CUBIC_CM,
|
||||
}
|
||||
for alias, unit in aliases.items():
|
||||
with self.subTest(alias=alias):
|
||||
self.assertEqual(scad.get_unit(alias), unit)
|
||||
self.assertAlmostEqual(scad.convert_value(1.0, "in", "mm"), 25.4)
|
||||
self.assertAlmostEqual(scad.convert_value(180.0, "deg", "rad"), math.pi)
|
||||
self.assertAlmostEqual(scad.convert_value(1.0, "ft^2", "in^2"), 144.0)
|
||||
with self.assertRaises(scad.UnitValidationError):
|
||||
scad.convert_value(1.0, "mm", "deg")
|
||||
with self.assertRaisesRegex(ValueError, "Unknown unit"):
|
||||
scad.get_unit("parsec")
|
||||
|
||||
def test_unit_validation_and_custom_unit_roundtrip(self):
|
||||
invalid_calls = [
|
||||
lambda: scad.Unit("", scad.LENGTH, 1.0),
|
||||
lambda: scad.Unit("bad", "Length", 1.0),
|
||||
lambda: scad.Unit("bad", scad.LENGTH, True),
|
||||
lambda: scad.Unit("bad", scad.LENGTH, 0.0),
|
||||
lambda: scad.Unit("bad", scad.LENGTH, math.inf),
|
||||
lambda: scad.MM.to_canonical(math.inf),
|
||||
lambda: scad.MM.to_canonical(True),
|
||||
lambda: scad.M.to_canonical(1e308),
|
||||
lambda: scad.Unit("tiny", scad.LENGTH, 5e-324).to_canonical(0.5),
|
||||
lambda: scad.Unit("tiny", scad.LENGTH, 5e-324).from_canonical(1.0),
|
||||
lambda: scad.Unit("huge", scad.LENGTH, 1e308).from_canonical(5e-324),
|
||||
lambda: scad.MM.to_canonical(10**10000),
|
||||
lambda: scad.get_unit(None),
|
||||
lambda: scad.get_unit(""),
|
||||
lambda: scad.Unit.from_dict(None),
|
||||
lambda: unit_to_payload(None),
|
||||
]
|
||||
for call in invalid_calls:
|
||||
with self.subTest(call=call), self.assertRaises((TypeError, ValueError)):
|
||||
call()
|
||||
|
||||
thou = scad.Unit("thou", scad.LENGTH, 0.0254)
|
||||
width = scad.var(
|
||||
"width", 1000.0, unit=thou, tolerance=2.0, tolerance_unit=thou
|
||||
)
|
||||
graph = scad.ExpressionGraph()
|
||||
graph.register(width)
|
||||
payload = graph.to_dict()
|
||||
self.assertIsInstance(payload["nodes"][0]["unit"], dict)
|
||||
|
||||
rebuilt = scad.ExpressionGraph.from_dict(payload).get(width.expr_id)
|
||||
self.assertIsInstance(rebuilt, scad.Var)
|
||||
self.assertEqual(rebuilt.unit, thou)
|
||||
self.assertEqual(rebuilt.tolerance_unit, thou)
|
||||
self.assertAlmostEqual(rebuilt.evaluate(), 25.4)
|
||||
self.assertAlmostEqual(rebuilt.canonical_tolerance.upper_deviation, 0.0508)
|
||||
|
||||
def test_unknown_compound_dimension_uses_a_canonical_scale_one_unit(self):
|
||||
dimension = scad.Dimension(length=-1, angle=2)
|
||||
unit = scad.canonical_unit_for_dimension(dimension)
|
||||
|
||||
self.assertEqual(unit.symbol, "L^-1 A^2")
|
||||
self.assertEqual(unit.dimension, dimension)
|
||||
self.assertEqual(unit.scale_to_canonical, 1.0)
|
||||
|
||||
def test_malformed_custom_unit_payloads_are_rejected(self):
|
||||
base = {
|
||||
"nodes": [
|
||||
{
|
||||
"expr_id": "var_x",
|
||||
"kind": "var",
|
||||
"name": "x",
|
||||
"default": 1.0,
|
||||
"unit": {
|
||||
"symbol": "custom",
|
||||
"dimension": {"length": 1, "angle": 0},
|
||||
"scale_to_canonical": 2.0,
|
||||
},
|
||||
}
|
||||
]
|
||||
}
|
||||
for field in ("symbol", "dimension", "scale_to_canonical"):
|
||||
payload = json.loads(json.dumps(base))
|
||||
del payload["nodes"][0]["unit"][field]
|
||||
with self.subTest(field=field), self.assertRaises(ValueError):
|
||||
scad.ExpressionGraph.from_dict(payload)
|
||||
|
||||
|
||||
class TestUnitAwareVariables(unittest.TestCase):
|
||||
def test_nominal_and_tolerance_units_are_canonicalized_independently(self):
|
||||
width = scad.var(
|
||||
"width",
|
||||
1.0,
|
||||
unit="in",
|
||||
tolerance=(-0.1, 0.2),
|
||||
tolerance_unit="mm",
|
||||
)
|
||||
inherited = scad.var("inherited", 1.0, unit="in", tolerance=0.01)
|
||||
|
||||
self.assertEqual(width.default, 1.0)
|
||||
self.assertEqual(width.tolerance, scad.DimensionTolerance(-0.1, 0.2))
|
||||
self.assertEqual(width.unit, scad.INCH)
|
||||
self.assertEqual(width.tolerance_unit, scad.MM)
|
||||
self.assertAlmostEqual(width.canonical_default, 25.4)
|
||||
self.assertEqual(
|
||||
width.canonical_tolerance, scad.DimensionTolerance(-0.1, 0.2)
|
||||
)
|
||||
self.assertEqual(inherited.tolerance_unit, scad.INCH)
|
||||
self.assertAlmostEqual(
|
||||
inherited.canonical_tolerance.upper_deviation, 0.254
|
||||
)
|
||||
|
||||
def test_bindings_use_the_variable_declaration_unit(self):
|
||||
width = scad.var("width", 1.0, unit="in")
|
||||
self.assertAlmostEqual(width.evaluate({"width": 2.0}), 50.8)
|
||||
self.assertAlmostEqual((width + 1.0).evaluate({"width": 2.0}), 51.8)
|
||||
|
||||
def test_invalid_variable_unit_combinations_are_rejected(self):
|
||||
invalid_calls = [
|
||||
lambda: scad.var("x", 1.0, tolerance=0.1, tolerance_unit="mm"),
|
||||
lambda: scad.var("x", 1.0, unit="mm", tolerance_unit="mm"),
|
||||
lambda: scad.var(
|
||||
"x", 1.0, unit="mm", tolerance=0.1, tolerance_unit="deg"
|
||||
),
|
||||
lambda: scad.var("x", 1.0, unit="unknown"),
|
||||
lambda: scad.var("x", 1e308, unit="m"),
|
||||
lambda: scad.var("x", 1.0, unit="mm", tolerance=1e308, tolerance_unit="m"),
|
||||
]
|
||||
for call in invalid_calls:
|
||||
with self.subTest(call=call), self.assertRaises((TypeError, ValueError)):
|
||||
call()
|
||||
|
||||
def test_expression_graph_roundtrip_preserves_registered_units(self):
|
||||
angle = scad.var(
|
||||
"angle", math.pi / 2.0, unit="rad", tolerance=0.5, tolerance_unit="deg"
|
||||
)
|
||||
expression = scad.sin(angle)
|
||||
graph = scad.ExpressionGraph()
|
||||
graph.register(expression)
|
||||
|
||||
payload = graph.to_dict()
|
||||
rebuilt = scad.ExpressionGraph.from_dict(payload)
|
||||
rebuilt_angle = rebuilt.get(angle.expr_id)
|
||||
|
||||
self.assertEqual(rebuilt_angle.unit, scad.RADIAN)
|
||||
self.assertEqual(rebuilt_angle.tolerance_unit, scad.DEGREE)
|
||||
self.assertAlmostEqual(rebuilt.get(expression.expr_id).evaluate(), 1.0)
|
||||
|
||||
def test_geometry_parameters_use_canonical_cad_values(self):
|
||||
width = scad.var("width", 1.0, unit="in")
|
||||
with scad.GraphSession() as session:
|
||||
scad.make_box_rsolid(width, 2.0, 3.0)
|
||||
|
||||
node = session.graph.topological_order()[0]
|
||||
self.assertAlmostEqual(node.params["width"], 25.4)
|
||||
self.assertEqual(node.param_exprs["width"]["expr_id"], width.expr_id)
|
||||
|
||||
|
||||
class TestDimensionInference(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.length = scad.var("length", 3.0, unit="mm")
|
||||
self.other_length = scad.var("other_length", 4.0, unit="cm")
|
||||
self.angle = scad.var("angle", 90.0, unit="deg")
|
||||
self.scalar = scad.var("scalar", 50.0, unit="%")
|
||||
|
||||
def test_addition_subtraction_and_contextual_constants(self):
|
||||
self.assertEqual(scad.infer_dimension(self.length + self.other_length), scad.LENGTH)
|
||||
self.assertEqual(scad.infer_dimension(self.length - 1.0), scad.LENGTH)
|
||||
self.assertEqual(scad.infer_dimension(1.0 + self.angle), scad.ANGLE)
|
||||
self.assertAlmostEqual((self.length + self.other_length).evaluate(), 43.0)
|
||||
|
||||
def test_multiplication_division_and_powers(self):
|
||||
area = self.length * self.other_length
|
||||
volume = area * self.length
|
||||
ratio = self.length / self.other_length
|
||||
inverse = 1.0 / self.length
|
||||
|
||||
self.assertEqual(scad.infer_dimension(area), scad.AREA)
|
||||
self.assertEqual(scad.infer_dimension(volume), scad.VOLUME)
|
||||
self.assertEqual(scad.infer_dimension(ratio), scad.DIMENSIONLESS)
|
||||
self.assertEqual(scad.infer_dimension(inverse), scad.Dimension(length=-1))
|
||||
self.assertEqual(scad.infer_dimension(self.length**3), scad.VOLUME)
|
||||
self.assertEqual(scad.infer_dimension(self.length**0), scad.DIMENSIONLESS)
|
||||
self.assertEqual(
|
||||
scad.infer_dimension(self.scalar ** scad.var("power", 2.0, unit="1")),
|
||||
scad.DIMENSIONLESS,
|
||||
)
|
||||
|
||||
def test_square_root_requires_even_dimension_exponents(self):
|
||||
diagonal = scad.sqrt(self.length**2 + self.other_length**2)
|
||||
self.assertEqual(scad.infer_dimension(diagonal), scad.LENGTH)
|
||||
self.assertAlmostEqual(diagonal.evaluate(), math.sqrt(1609.0))
|
||||
self.assertEqual(scad.infer_dimension(scad.sqrt(self.scalar)), scad.DIMENSIONLESS)
|
||||
with self.assertRaises(scad.UnitValidationError):
|
||||
scad.infer_dimension(scad.sqrt(self.length))
|
||||
with self.assertRaises(scad.UnitValidationError):
|
||||
scad.infer_dimension(self.length**0.5)
|
||||
|
||||
def test_unary_and_trigonometric_dimensions(self):
|
||||
self.assertEqual(scad.infer_dimension(-self.length), scad.LENGTH)
|
||||
self.assertEqual(scad.infer_dimension(abs(self.length)), scad.LENGTH)
|
||||
for expression in (
|
||||
scad.sin(self.angle),
|
||||
scad.cos(self.angle),
|
||||
scad.tan(self.angle),
|
||||
):
|
||||
self.assertEqual(scad.infer_dimension(expression), scad.DIMENSIONLESS)
|
||||
for expression in (
|
||||
scad.asin(self.scalar),
|
||||
scad.acos(self.scalar),
|
||||
scad.atan(self.scalar),
|
||||
scad.atan2(self.length, self.other_length),
|
||||
):
|
||||
self.assertEqual(scad.infer_dimension(expression), scad.ANGLE)
|
||||
|
||||
def test_invalid_physical_expressions_are_rejected(self):
|
||||
legacy = scad.var("legacy", 1.0)
|
||||
invalid = [
|
||||
self.length + self.angle,
|
||||
self.length + self.scalar,
|
||||
self.length + legacy,
|
||||
self.length * legacy,
|
||||
self.length ** self.scalar,
|
||||
self.length ** self.angle,
|
||||
self.length ** legacy,
|
||||
self.length**0.25,
|
||||
scad.sin(self.length),
|
||||
scad.asin(self.length),
|
||||
scad.atan2(self.length, self.angle),
|
||||
]
|
||||
for expression in invalid:
|
||||
with self.subTest(op=expression.op), self.assertRaises(
|
||||
scad.UnitValidationError
|
||||
):
|
||||
scad.infer_dimension(expression)
|
||||
|
||||
with self.assertRaises(scad.UnitValidationError):
|
||||
(self.length + self.angle).evaluate()
|
||||
|
||||
def test_inference_cache_does_not_hide_conflicting_duplicate_ids(self):
|
||||
length = scad.Var("length", 1.0, expr_id="same", unit=scad.MM)
|
||||
angle = scad.Var("angle", 1.0, expr_id="same", unit=scad.DEGREE)
|
||||
expression = scad.Expr("add", (length, angle))
|
||||
|
||||
with self.assertRaises(scad.UnitValidationError):
|
||||
scad.infer_dimension(expression)
|
||||
with self.assertRaisesRegex(ValueError, "different node"):
|
||||
scad.ExpressionGraph().register(expression)
|
||||
|
||||
def test_inference_rejects_mutated_cycles_ops_and_node_types(self):
|
||||
cycle = scad.Expr("neg", (scad.const(1.0),), expr_id="cycle")
|
||||
object.__setattr__(cycle, "args", (cycle,))
|
||||
with self.assertRaisesRegex(scad.UnitValidationError, "cycle"):
|
||||
scad.infer_dimension(cycle)
|
||||
|
||||
unsupported = scad.Expr("neg", (scad.const(1.0),))
|
||||
object.__setattr__(unsupported, "op", "unsupported")
|
||||
with self.assertRaisesRegex(scad.UnitValidationError, "Unsupported"):
|
||||
scad.infer_dimension(unsupported)
|
||||
|
||||
with self.assertRaisesRegex(TypeError, "Unsupported expression node"):
|
||||
_infer(object(), {}, set())
|
||||
|
||||
def test_legacy_expressions_keep_radian_math_and_unknown_dimension(self):
|
||||
value = scad.var("legacy", 0.5)
|
||||
expression = value ** scad.var("legacy_power", 2.0)
|
||||
|
||||
self.assertIsNone(scad.infer_dimension(expression))
|
||||
self.assertFalse(scad.expression_uses_units(expression))
|
||||
self.assertAlmostEqual(scad.sin(value).evaluate(), math.sin(0.5))
|
||||
self.assertAlmostEqual(scad.asin(value).evaluate(), math.asin(0.5))
|
||||
self.assertIsNone(scad.infer_dimension(scad.sin(value)))
|
||||
self.assertIsNone(scad.infer_dimension(value + value))
|
||||
self.assertIsNone(scad.infer_dimension(scad.atan2(value, value)))
|
||||
|
||||
|
||||
class TestUnitAwareMathAndTolerance(unittest.TestCase):
|
||||
def test_trigonometric_evaluation_uses_degrees_canonically(self):
|
||||
degrees = scad.var("degrees", 90.0, unit="deg")
|
||||
radians = scad.var("radians", math.pi / 2.0, unit="rad")
|
||||
ratio = scad.var("ratio", 50.0, unit="%")
|
||||
y = scad.var("y", 1.0, unit="in")
|
||||
x = scad.var("x", 25.4, unit="mm")
|
||||
|
||||
self.assertAlmostEqual(scad.sin(degrees).evaluate(), 1.0)
|
||||
self.assertAlmostEqual(scad.sin(radians).evaluate(), 1.0)
|
||||
self.assertAlmostEqual(scad.asin(ratio).evaluate(), 30.0)
|
||||
self.assertAlmostEqual(scad.atan2(y, x).evaluate(), 45.0)
|
||||
|
||||
def test_diagonal_tolerance_chain_reports_length_in_mm(self):
|
||||
width = scad.var(
|
||||
"width", 3.0, unit="cm", tolerance=0.1, tolerance_unit="mm"
|
||||
)
|
||||
height = scad.var("height", 40.0, unit="mm", tolerance=0.2)
|
||||
diagonal = scad.sqrt(width**2 + height**2)
|
||||
|
||||
worst_case = scad.analyze_tolerance(diagonal)
|
||||
rss = scad.analyze_tolerance(diagonal, method="rss")
|
||||
|
||||
self.assertEqual(worst_case.dimension, scad.LENGTH)
|
||||
self.assertEqual(worst_case.unit, scad.MM)
|
||||
self.assertAlmostEqual(worst_case.nominal, 50.0)
|
||||
self.assertLess(worst_case.lower_deviation, 0.0)
|
||||
self.assertGreater(worst_case.upper_deviation, 0.0)
|
||||
expected_rss = math.hypot(0.6 * 0.1, 0.8 * 0.2)
|
||||
self.assertAlmostEqual(rss.upper_deviation, expected_rss, places=12)
|
||||
self.assertTrue(all(item.source_unit == scad.MM for item in rss.contributions))
|
||||
|
||||
def test_angle_tolerance_propagation_converts_derivatives(self):
|
||||
angle = scad.var("angle", 30.0, unit="deg", tolerance=1.0)
|
||||
result = scad.analyze_tolerance(scad.sin(angle), method="rss")
|
||||
expected = math.cos(math.radians(30.0)) * math.pi / 180.0
|
||||
|
||||
self.assertEqual(result.dimension, scad.DIMENSIONLESS)
|
||||
self.assertEqual(result.unit, scad.ONE)
|
||||
self.assertAlmostEqual(result.nominal, 0.5)
|
||||
self.assertAlmostEqual(result.upper_deviation, expected, places=12)
|
||||
|
||||
def test_inverse_trig_and_atan2_tolerances_report_degrees(self):
|
||||
ratio = scad.var("ratio", 50.0, unit="%", tolerance=1.0)
|
||||
y = scad.var("y", 10.0, unit="mm", tolerance=0.1)
|
||||
x = scad.var("x", 10.0, unit="mm", tolerance=0.1)
|
||||
|
||||
asin_result = scad.analyze_tolerance(scad.asin(ratio), method="rss")
|
||||
atan2_result = scad.analyze_tolerance(scad.atan2(y, x), method="rss")
|
||||
|
||||
self.assertEqual(asin_result.unit, scad.DEGREE)
|
||||
self.assertAlmostEqual(asin_result.nominal, 30.0)
|
||||
self.assertEqual(atan2_result.unit, scad.DEGREE)
|
||||
self.assertAlmostEqual(atan2_result.nominal, 45.0)
|
||||
|
||||
def test_area_and_volume_analysis_are_inferred_but_not_requirements(self):
|
||||
width = scad.var("width", 2.0, unit="mm", tolerance=0.1)
|
||||
area = width**2
|
||||
volume = width**3
|
||||
|
||||
self.assertEqual(scad.analyze_tolerance(area).dimension, scad.AREA)
|
||||
self.assertEqual(scad.analyze_tolerance(volume).dimension, scad.VOLUME)
|
||||
with self.assertRaisesRegex(ValueError, "Length or Angle"):
|
||||
scad.check_tolerance(area, 0.5, tolerance_unit="mm^2")
|
||||
|
||||
|
||||
class TestUnitAwareRequirementsAndPersistence(unittest.TestCase):
|
||||
def test_requirement_tolerance_units_are_converted_before_comparison(self):
|
||||
width = scad.var(
|
||||
"width", 1.0, unit="in", tolerance=0.1, tolerance_unit="mm"
|
||||
)
|
||||
passing = scad.check_tolerance(width, 0.004, tolerance_unit="in")
|
||||
failing = scad.check_tolerance(width, 0.003, tolerance_unit="in")
|
||||
|
||||
self.assertTrue(passing.passed)
|
||||
self.assertFalse(failing.passed)
|
||||
self.assertEqual(passing.requirement.tolerance_unit, scad.INCH)
|
||||
self.assertAlmostEqual(
|
||||
passing.requirement.canonical_tolerance.upper_deviation, 0.1016
|
||||
)
|
||||
|
||||
def test_requirement_unit_validation(self):
|
||||
length = scad.var("length", 10.0, unit="mm", tolerance=0.1)
|
||||
legacy = scad.var("legacy", 10.0, tolerance=0.1)
|
||||
scalar = scad.var("scalar", 1.0, unit="1", tolerance=0.1)
|
||||
|
||||
with self.assertRaisesRegex(ValueError, "incompatible"):
|
||||
scad.check_tolerance(length, 1.0, tolerance_unit="deg")
|
||||
with self.assertRaisesRegex(ValueError, "unit-aware"):
|
||||
scad.check_tolerance(legacy, 1.0, tolerance_unit="mm")
|
||||
with self.assertRaisesRegex(ValueError, "Length or Angle"):
|
||||
scad.check_tolerance(scalar, 0.1)
|
||||
|
||||
def test_session_model_and_tolerance_graph_roundtrip_units(self):
|
||||
width = scad.var(
|
||||
"width", 1.0, unit="in", tolerance=0.1, tolerance_unit="mm"
|
||||
)
|
||||
with scad.GraphSession() as session:
|
||||
scad.make_box_rsolid(width, 2.0, 3.0)
|
||||
requirement = session.require_tolerance(
|
||||
width, 0.004, tolerance_unit="in", name="width"
|
||||
)
|
||||
|
||||
raw = json.loads(scad.export_model_json(session))
|
||||
self.assertEqual(raw["expression_graph"]["nodes"][0]["unit"], "in")
|
||||
self.assertEqual(
|
||||
raw["expression_graph"]["nodes"][0]["tolerance_unit"], "mm"
|
||||
)
|
||||
self.assertEqual(
|
||||
raw["tolerance_graph"]["requirements"][0]["tolerance_unit"], "in"
|
||||
)
|
||||
self.assertEqual(
|
||||
raw["tolerance_graph"]["requirements"][0]["target_dimension"],
|
||||
scad.LENGTH.to_dict(),
|
||||
)
|
||||
|
||||
imported = scad.import_model_json(json.dumps(raw))
|
||||
rebuilt = imported["tolerance_graph"].requirements[0]
|
||||
self.assertEqual(rebuilt, requirement)
|
||||
self.assertTrue(imported["tolerance_graph"].validate().passed)
|
||||
self.assertEqual(len(scad.replay_model_json(json.dumps(raw))), 1)
|
||||
|
||||
def test_import_rejects_tampered_requirement_units_and_dimensions(self):
|
||||
width = scad.var("width", 10.0, unit="mm", tolerance=0.1)
|
||||
expressions = scad.ExpressionGraph()
|
||||
tolerances = scad.ToleranceGraph(expressions)
|
||||
tolerances.require(width, 0.1, tolerance_unit="mm", requirement_id="req")
|
||||
expression_payload = expressions.to_dict()
|
||||
|
||||
wrong_unit = tolerances.to_dict()
|
||||
wrong_unit["requirements"][0]["tolerance_unit"] = "deg"
|
||||
with self.assertRaisesRegex(ValueError, "incompatible"):
|
||||
scad.ToleranceGraph.from_dict(
|
||||
wrong_unit, scad.ExpressionGraph.from_dict(expression_payload)
|
||||
)
|
||||
|
||||
wrong_dimension = tolerances.to_dict()
|
||||
wrong_dimension["requirements"][0]["target_dimension"] = scad.ANGLE.to_dict()
|
||||
with self.assertRaisesRegex(ValueError, "does not match"):
|
||||
scad.ToleranceGraph.from_dict(
|
||||
wrong_dimension, scad.ExpressionGraph.from_dict(expression_payload)
|
||||
)
|
||||
|
||||
missing_dimension = tolerances.to_dict()
|
||||
missing_dimension["requirements"][0]["target_dimension"] = None
|
||||
with self.assertRaisesRegex(ValueError, "does not match"):
|
||||
scad.ToleranceGraph.from_dict(
|
||||
missing_dimension, scad.ExpressionGraph.from_dict(expression_payload)
|
||||
)
|
||||
|
||||
def test_legacy_payloads_and_requirements_remain_compatible(self):
|
||||
width = scad.var("width", 10.0, tolerance=0.1)
|
||||
graph = scad.ExpressionGraph()
|
||||
tolerance_graph = scad.ToleranceGraph(graph)
|
||||
tolerance_graph.require(width, 0.1, requirement_id="legacy")
|
||||
payload = tolerance_graph.to_dict()
|
||||
payload["requirements"][0].pop("tolerance_unit")
|
||||
payload["requirements"][0].pop("target_dimension")
|
||||
|
||||
rebuilt = scad.ToleranceGraph.from_dict(payload, graph)
|
||||
requirement = rebuilt.requirements[0]
|
||||
self.assertIsNone(requirement.tolerance_unit)
|
||||
self.assertIsNone(requirement.target_dimension)
|
||||
self.assertTrue(rebuilt.validate().passed)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user