Files
make-cad/test/test_freecad_translator.py
NiJingzhe 3dd8c77b8d refactor!: replace the part cache with the marimo notebook runtime
A SimpleCAD model is now a marimo notebook: a PEP 723 header with a
[tool.simplecadapi] table (id, revision, tolerance_profile, inputs), one
FTC block per cell, and the product is the top-level value whose id is the
notebook id. The notebook file is the only source of truth; .scadpkg is
only for exchange and publishing.

Runtime (simplecadapi.runtime):
- run_notebook(path, *, id=None, overrides=None, cache=True) and
  sca run <notebook.py> [--id] [--set NAME=VALUE] [--no-cache] [--out]
- use(path, id=..., **overrides) composes child notebooks; notebook_id()
  lets one notebook serve a part family under per-use ids
- each cell records into its own session; cells are the unit of caching,
  keyed by the notebook dependency digest (deps.json)
- marimo cell executor entry point, so marimo edit runs the same way
- shapes and read-only definition mappings pickle for the cell cache

Removed: the content-addressed part cache (simplecadapi.cache,
CachePolicy, CacheReport, sca cache ...), the incremental assembly solver
and its dependency/state modules, and part-interface diffs with latest-
state persistence. Part and assembly builds and the notebook projection
now share one definition writer (build/definition.py).

Co-Authored-By: Claude Code <noreply@anthropic.com>
2026-10-02 17:16:16 +08:00

5482 lines
224 KiB
Python

"""Tests for FreeCAD script translation layer."""
from __future__ import annotations
import hashlib
import json
import importlib
import math
import os
import shutil
import subprocess
import tempfile
import zipfile
from pathlib import Path
from unittest import mock
import unittest
import xml.etree.ElementTree as ET
import simplecadapi as scad
from simplecadapi import ql
from simplecadapi.errors import raise_harness_error
from simplecadapi.recording.graph import GraphSession
from simplecadapi.kernel.ocp_properties import bounding_box
from simplecadapi.topology import OperationGraph
from simplecadapi.translator import freecad_translator
from simplecadapi.recording.serializer import import_model_json
from simplecadapi.translator.freecad_translator.exporter import (
discover_freecad_executable,
export_freecad_script_to_fcstd,
)
from simplecadapi.translator.freecad_translator.translator import _FreeCADCompiler
from simplecadapi.translator.freecad_translator.semantic import (
build_freecad_semantic_plan,
)
def _build_freecad_nested_package():
@scad.part(id="linked")
def build_part() -> scad.Part:
body = scad.make_box_rsolid(width=1.0, height=2.0, depth=3.0)
named_face = scad.apply_tag(body.get_faces(0), "interface.mount_face")
part = scad.make_part_rpart("linked", body, name="Part linked")
connector = scad.make_face_connector_rconnector("mount", named_face)
return scad.add_connector_rpart(part, connector)
part = build_part()
@scad.assemble(id="child", definitions=(part,))
def build_child() -> scad.Assembly:
assembly = scad.make_assembly_rassembly("child", name="Child assembly")
for component_id in ("inner_a", "inner_b"):
assembly = scad.add_component_rassembly(
assembly,
part.value,
component_id=component_id,
placement=scad.identity_placement_rplacement(),
name=f"Inner linked part {component_id[-1].upper()}",
)
assembly = scad.ground_component_rassembly(assembly, "inner_a")
assembly = scad.add_revolute_constraint_rassembly(
assembly,
"joint",
scad.make_connector_ref_rconnectorref("inner_a", "mount"),
scad.make_connector_ref_rconnectorref("inner_b", "mount"),
drive_angle_degrees=15.0,
)
assembly = scad.solve_assembly_constraints_rassembly(assembly)
return scad.set_public_connector_rassembly(
assembly,
public_connector_id="public_mount",
source_component_id="inner_b",
source_connector_id="mount",
)
child = build_child()
@scad.assemble(id="root", definitions=(child, part))
def build_root() -> scad.Assembly:
assembly = scad.make_assembly_rassembly("root", name="Root assembly")
assembly = scad.add_component_rassembly(
assembly,
child.value,
component_id="nested",
placement=scad.make_placement_rplacement(origin=(10.0, 0.0, 0.0)),
name="Nested child assembly",
)
return scad.add_component_rassembly(
assembly,
part.value,
component_id="direct",
placement=scad.make_placement_rplacement(origin=(0.0, 5.0, 0.0)),
name="Direct linked part",
)
return scad.build_product_package(build_root())
def _build_freecad_feature_history_package():
@scad.part(id="feature_history")
def build_part() -> scad.Part:
base = scad.make_box_rsolid(width=10.0, height=8.0, depth=4.0)
tool = scad.make_cylinder_rsolid(
radius=1.0,
height=6.0,
bottom_face_center=(0.0, 0.0, -1.0),
)
body = scad.cut_rsolid(base, tool)
return scad.make_part_rpart("feature_history", body, name="Feature history")
return scad.build_product_package(build_part())
def _build_freecad_material_package():
blue = scad.make_material_rmaterial(
"blue_aluminum",
name="Blue aluminum",
density=2.7e-6,
density_unit="kg/mm^3",
color=(0.2, 0.4, 0.6),
)
uncolored = scad.make_material_rmaterial(
"uncolored_steel",
name="Uncolored steel",
)
def build_part_result(part_id: str, x: float, material: scad.Material):
@scad.part(id=part_id, project_root=Path(__file__).parent)
def build_part() -> scad.Part:
body = scad.make_box_rsolid(
1.0,
1.0,
1.0,
bottom_face_center=(x, 0.0, 0.0),
)
return scad.assign_material_rpart(
scad.make_part_rpart(part_id, body),
material,
)
return build_part()
parts = (
build_part_result("blue_a", 0.0, blue),
build_part_result("blue_b", 2.0, blue),
build_part_result("plain", 4.0, uncolored),
)
@scad.assemble(
id="material_fixture",
definitions=parts,
project_root=Path(__file__).parent,
)
def build_assembly() -> scad.Assembly:
assembly = scad.make_assembly_rassembly("material_fixture")
for part in parts:
assembly = scad.add_component_rassembly(
assembly,
part.value,
component_id=f"{part.value.part_id}_1",
placement=scad.identity_placement_rplacement(),
)
return assembly
return scad.build_product_package(build_assembly())
def _compile_model_json(payload: str) -> str:
return _FreeCADCompiler().translate_model_payload_to_script(
import_model_json(payload)
)
def _compile_model_json_to_fcstd(
payload: str,
output_path: str,
*,
freecad_cmd: str | None = None,
) -> str:
executable = freecad_cmd or discover_freecad_executable()
if not executable:
raise_harness_error(
operation="_compile_model_json_to_fcstd",
what_happened="FreeCAD executable not found.",
possible_causes=["FreeCAD is not installed or is not discoverable."],
how_to_fix=["Install FreeCAD or pass freecad_cmd."],
)
return export_freecad_script_to_fcstd(
_compile_model_json(payload),
output_path,
freecad_executable=executable,
)
class TestFreeCADTranslator(unittest.TestCase):
def test_freecad_translator_is_only_exported_from_translator_namespace(self):
self.assertTrue(hasattr(scad, "translator"))
self.assertEqual(
freecad_translator.__all__,
[
"CAPABILITIES",
"FreeCADTranslator",
"translate_product_package_to_fcstd",
"translate_product_package_to_freecad_script",
],
)
self.assertFalse(hasattr(scad, "translate_model_json_to_fcstd"))
self.assertFalse(hasattr(scad, "translate_model_json_to_freecad_script"))
self.assertFalse(hasattr(freecad_translator, "translate_model_json_to_fcstd"))
self.assertFalse(
hasattr(freecad_translator, "translate_model_json_to_freecad_script")
)
with self.assertRaises(ModuleNotFoundError):
importlib.import_module("simplecadapi.freecad_translator")
def _expr_alias(self, expr_id: str) -> str:
alias = "".join(ch if str(ch).isalnum() else "_" for ch in str(expr_id)).strip(
"_"
)
if not alias:
alias = "expr"
if alias[0].isdigit():
alias = f"expr_{alias}"
return alias[:64]
def _sheet_alias(self, node: dict, row: int) -> str:
expr_id = str(node.get("expr_id", f"expr_{row}"))
kind = str(node.get("kind", "expr"))
if kind == "var":
name = str(node.get("name", "")).strip()
if name:
return self._sanitize_alias(f"var_{name}", prefix="var")
if kind == "const":
return self._sanitize_alias(
f"const_{self._const_value_alias_token(node.get('value'))}_{self._expr_short_suffix(expr_id)}",
prefix="const",
)
op = str(node.get("op", "expr")).strip() or "expr"
return self._sanitize_alias(
f"expr_{op}_{self._expr_short_suffix(expr_id)}", prefix="expr"
)
def _expr_short_suffix(self, expr_id: str) -> str:
raw = str(expr_id).rsplit("_", 1)[-1]
alias = "".join(ch if str(ch).isalnum() else "_" for ch in str(raw)).strip("_")
return alias[:8] if alias else "id"
def _const_value_alias_token(self, value: object) -> str:
try:
number = float(value)
except Exception:
return "value"
alias = f"{number:.6g}".replace("-", "neg_").replace(".", "_")
alias = "".join(ch if str(ch).isalnum() else "_" for ch in str(alias)).strip(
"_"
)
return alias or "value"
def _sanitize_alias(self, raw: str, prefix: str = "expr") -> str:
alias = "".join(ch if str(ch).isalnum() else "_" for ch in str(raw)).strip("_")
if not alias:
alias = prefix
if alias[0].isdigit():
alias = f"{prefix}_{alias}"
return alias[:64]
def _discover_freecadcmd(self) -> str | None:
return (
shutil.which("FreeCADCmd")
or shutil.which("freecadcmd")
or (
"/Applications/FreeCAD.app/Contents/Resources/bin/freecadcmd"
if os.path.exists(
"/Applications/FreeCAD.app/Contents/Resources/bin/freecadcmd"
)
else None
)
)
def _inspect_fcstd_json(self, payload: str, probe_source: str) -> dict:
freecad_cmd = self._discover_freecadcmd()
if not freecad_cmd:
self.skipTest("freecadcmd not available")
with tempfile.TemporaryDirectory() as tmp_dir:
fcstd_path = os.path.join(tmp_dir, "model.FCStd")
probe_path = os.path.join(tmp_dir, "probe.py")
out_path = os.path.join(tmp_dir, "probe.json")
_compile_model_json_to_fcstd(payload, fcstd_path, freecad_cmd=freecad_cmd)
with open(probe_path, "w", encoding="utf-8") as fh:
fh.write(f"FCSTD_PATH = {json.dumps(fcstd_path)}\n")
fh.write(f"OUT_PATH = {json.dumps(out_path)}\n")
fh.write(probe_source)
completed = subprocess.run(
[freecad_cmd, probe_path],
check=True,
text=True,
capture_output=True,
)
if not os.path.isfile(out_path) or os.path.getsize(out_path) <= 0:
self.fail(
"FreeCAD probe did not write JSON. "
f"stdout={completed.stdout!r} stderr={completed.stderr!r}"
)
with open(out_path, "r", encoding="utf-8") as fh:
return json.load(fh)
def _inspect_product_package_fcstd_json(
self,
package: object,
probe_source: str,
) -> dict:
freecad_cmd = self._discover_freecadcmd()
if not freecad_cmd:
self.skipTest("freecadcmd not available")
with tempfile.TemporaryDirectory() as tmp_dir:
fcstd_path = os.path.join(tmp_dir, "product.FCStd")
probe_path = os.path.join(tmp_dir, "probe.py")
out_path = os.path.join(tmp_dir, "probe.json")
freecad_translator.translate_product_package_to_fcstd(
package,
fcstd_path,
freecad_cmd=freecad_cmd,
)
with open(probe_path, "w", encoding="utf-8") as fh:
fh.write(f"FCSTD_PATH = {json.dumps(fcstd_path)}\n")
fh.write(f"OUT_PATH = {json.dumps(out_path)}\n")
fh.write(probe_source)
completed = subprocess.run(
[freecad_cmd, probe_path],
check=True,
text=True,
capture_output=True,
)
if not os.path.isfile(out_path) or os.path.getsize(out_path) <= 0:
self.fail(
"FreeCAD product probe did not write JSON. "
f"stdout={completed.stdout!r} stderr={completed.stderr!r}"
)
with open(out_path, "r", encoding="utf-8") as fh:
return json.load(fh)
def _inspect_fcstd_gui_visibility(self, payload: str) -> dict:
freecad_cmd = self._discover_freecadcmd()
if not freecad_cmd:
self.skipTest("freecadcmd not available")
with tempfile.TemporaryDirectory() as tmp_dir:
fcstd_path = os.path.join(tmp_dir, "model.FCStd")
_compile_model_json_to_fcstd(payload, fcstd_path, freecad_cmd=freecad_cmd)
with zipfile.ZipFile(fcstd_path, "r") as archive:
names = set(archive.namelist())
gui_xml = archive.read("GuiDocument.xml")
root = ET.fromstring(gui_xml)
visibility = {}
show_in_tree = {}
expanded = {}
shape_colors = {}
override_material = {}
view_proxy_classes = {}
view_provider_data = root.find("ViewProviderData")
if view_provider_data is None:
return {
"entries": names,
"visibility": visibility,
"show_in_tree": show_in_tree,
"expanded": expanded,
"shape_colors": shape_colors,
"override_material": override_material,
"view_proxy_classes": view_proxy_classes,
}
for view_provider in view_provider_data.findall("ViewProvider"):
name = str(view_provider.attrib.get("name", ""))
expanded[name] = view_provider.attrib.get("expanded") == "1"
properties = view_provider.find("Properties")
if properties is None:
continue
for prop in properties.findall("Property"):
prop_name = prop.attrib.get("name")
if prop_name == "Visibility":
bool_value = prop.find("Bool")
visibility[name] = (
bool_value is not None
and bool_value.attrib.get("value", "").lower() == "true"
)
elif prop_name == "ShowInTree":
bool_value = prop.find("Bool")
show_in_tree[name] = (
bool_value is not None
and bool_value.attrib.get("value", "").lower() == "true"
)
elif prop_name == "OverrideMaterial":
bool_value = prop.find("Bool")
override_material[name] = (
bool_value is not None
and bool_value.attrib.get("value", "").lower() == "true"
)
elif prop_name == "ShapeColor":
color_value = prop.find("PropertyColor")
if color_value is not None:
shape_colors[name] = int(color_value.attrib["value"])
elif prop_name == "ShapeMaterial":
material_value = prop.find("PropertyMaterial")
if material_value is not None:
shape_colors[name] = int(material_value.attrib["diffuseColor"])
elif prop_name == "Proxy":
python_value = prop.find("Python")
if python_value is not None:
view_proxy_classes[name] = (
str(python_value.attrib.get("module", ""))
+ "."
+ str(python_value.attrib.get("class", ""))
)
return {
"entries": names,
"visibility": visibility,
"show_in_tree": show_in_tree,
"expanded": expanded,
"shape_colors": shape_colors,
"override_material": override_material,
"view_proxy_classes": view_proxy_classes,
}
def _expression_payload(self, payload: str) -> dict:
payload_obj = json.loads(payload)
payload_obj["expression_graph"] = {"nodes": []}
return payload_obj
def test_translate_model_json_emits_freecad_api_script_for_steps(self):
with GraphSession() as session:
box = scad.make_box_rsolid(2.0, 3.0, 4.0)
scad.translate_shape(box, (1.0, 2.0, 3.0))
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("import FreeCAD as App", script)
self.assertIn("Part::Box", script)
self.assertIn("_register_graph_folded_alias", script)
self.assertNotIn("doc.addObject('App::Link'", script)
self.assertIn("SimpleCADNodeId", script)
self.assertIn("EXPRESSION_GRAPH_META", script)
self.assertIn("# Step", script)
def test_translate_model_json_emits_tag_metadata_without_freecad_feature(self):
with GraphSession() as session:
box = scad.make_box_rsolid(width=2.0, height=3.0, depth=4.0)
scad.apply_tag_rselection(
scope=box,
targets=[box],
tag="role.semantic_view",
)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("# Step", script)
self.assertIn("apply_tag_rselection", script)
self.assertIn("_register_tag_metadata_node", script)
self.assertIn("SimpleCADTagBindings", script)
self.assertNotIn("_register_tag_selection_node", script)
def test_translate_tagged_cylinder_preserves_topology_identity_bindings(self):
with GraphSession() as session:
scad.make_cylinder_rsolid(
radius=2.0,
height=5.0,
tag_prefix="shaft",
)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("Part::Cylinder", script)
self.assertIn("_register_tag_metadata_node", script)
self.assertIn("shaft.face.start", script)
self.assertIn("topology_name", script)
def test_translate_tagged_box_preserves_topology_identity_bindings(self):
with GraphSession() as session:
scad.make_box_rsolid(
width=2.0,
height=3.0,
depth=4.0,
tag_prefix="housing",
top_face_tag="role.lid_mount",
)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("Part::Box", script)
self.assertIn("_register_tag_metadata_node", script)
self.assertIn("housing.face.top", script)
self.assertIn("role.lid_mount", script)
self.assertIn("topology_name", script)
self.assertIn("operation_output_role", script)
def test_translate_tagged_cone_preserves_topology_identity_bindings(self):
with GraphSession() as session:
scad.make_cone_rsolid(
bottom_radius=2.0,
height=4.0,
top_radius=1.0,
tag_prefix="adapter",
end_face_tag="role.outlet",
)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("Part::Cone", script)
self.assertIn("_register_tag_metadata_node", script)
self.assertIn("adapter.face.end", script)
self.assertIn("adapter.edge.seam", script)
self.assertIn("role.outlet", script)
self.assertIn("topology_name", script)
self.assertIn("operation_output_role", script)
def test_translate_constrained_sketch_preserves_topology_tag_contract(self):
with GraphSession() as session:
sketch = scad.make_sketch_rsketch(name="rect")
for point_id, x, y in (
("p0", 0.0, 0.0),
("p1", 2.0, 0.0),
("p2", 2.0, 1.0),
("p3", 0.0, 1.0),
):
sketch = scad.add_point_rsketch(sketch, point_id, x, y)
for entity_id, start, end in (
("bottom", "p0", "p1"),
("right", "p1", "p2"),
("top", "p2", "p3"),
("left", "p3", "p0"),
):
sketch = scad.add_line_rsketch(sketch, entity_id, start, end)
scad.make_face_from_sketch_rface(sketch)
model_json = scad.export_model_json(session)
script = _compile_model_json(model_json)
self.assertIn("SimpleCADSketchPromotion", script)
self.assertIn("sketch_entity.bottom", script)
self.assertIn("topology_name", script)
self.assertIn("profile_id", script)
def test_translate_model_json_tag_results_keep_distinct_metadata_without_links(
self,
):
with GraphSession() as session:
box = scad.make_box_rsolid(width=2.0, height=3.0, depth=4.0)
left = scad.apply_tag_rselection(
scope=box,
targets=[box],
tag="role.left_branch",
)
right = scad.apply_tag_rselection(
scope=box,
targets=[box],
tag="role.right_branch",
)
session.capture_result(value=(left, right))
model_json = scad.export_model_json(session)
payload = json.loads(model_json)
expected_by_tag = {
binding["tag"]: binding for binding in payload["semantic_bindings"]
}
expected_node_ids = {
node["params"]["tag_binding"]["tag"]: node["node_id"]
for node in payload["graph"]["nodes"]
if node["op"] == "apply_tag_rselection"
}
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
tag_objects = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'apply_tag_rselection']
results = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADSemanticRole', '') == 'result']
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'tag_object_count': len(tag_objects),
'results': [
{
'bindings': json.loads(obj.SimpleCADTagBindings),
'node_ids': list(obj.SimpleCADTagNodeIds),
'tags': list(obj.SimpleCADAppliedTags),
'volume': round(float(obj.Shape.Volume), 6),
}
for obj in results
],
}, fh)
"""
result = self._inspect_fcstd_json(model_json, probe)
self.assertEqual(result["tag_object_count"], 0)
self.assertEqual(len(result["results"]), 2)
actual = {record["tags"][0]: record for record in result["results"]}
self.assertEqual(set(actual), set(expected_by_tag))
for tag, record in actual.items():
self.assertEqual(record["bindings"], [expected_by_tag[tag]])
self.assertEqual(record["node_ids"], [expected_node_ids[tag]])
self.assertEqual(record["volume"], 24.0)
def test_translate_product_package_emits_dependency_first_definition_registry(self):
package = _build_freecad_nested_package()
script = freecad_translator.translate_product_package_to_freecad_script(
package
)
compile(script, "simplecad_product_package.py", "exec")
linked_index = script.index('DEFINITION_REGISTRY["linked"]')
child_index = script.index('DEFINITION_REGISTRY["child"]')
root_index = script.index('DEFINITION_REGISTRY["root"]')
self.assertLess(linked_index, child_index)
self.assertLess(child_index, root_index)
self.assertEqual(script.count('DEFINITION_REGISTRY["linked"]'), 1)
self.assertEqual(script.count('DEFINITION_REGISTRY["child"]'), 1)
self.assertEqual(script.count('DEFINITION_REGISTRY["root"]'), 1)
self.assertEqual(script.count("Translated definition identity differs"), 3)
def test_translate_product_package_fcstd_preserves_nested_occurrences(self):
package = _build_freecad_nested_package()
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
objects = list(doc.Objects)
def xyz(obj):
base = obj.Placement.Base
return [round(float(base.x), 3), round(float(base.y), 3), round(float(base.z), 3)]
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'assemblies': sorted(
[obj.SimpleCADAssemblyId, obj.TypeId]
for obj in objects
if getattr(obj, 'SimpleCADAssemblyId', '')
),
'components': {
obj.SimpleCADComponentId: {'type': obj.TypeId, 'xyz': xyz(obj)}
for obj in objects
if getattr(obj, 'SimpleCADComponentId', '')
},
'part_definition_count': sum(
1 for obj in objects
if obj.TypeId == 'App::Part'
and getattr(obj, 'SimpleCADPartId', '') == 'linked'
),
'connector_ids': sorted(
obj.SimpleCADConnectorId
for obj in objects
if getattr(obj, 'SimpleCADConnectorId', '')
),
}, fh)
"""
result = self._inspect_product_package_fcstd_json(package, probe)
self.assertEqual(
result["assemblies"],
[
["child", "Assembly::AssemblyObject"],
["root", "Assembly::AssemblyObject"],
],
)
self.assertEqual(result["part_definition_count"], 1)
self.assertEqual(result["components"]["inner_a"]["type"], "App::Link")
self.assertEqual(result["components"]["inner_a"]["xyz"], [0.0, 0.0, 0.0])
self.assertEqual(result["components"]["inner_b"]["type"], "App::Link")
self.assertEqual(result["components"]["inner_b"]["xyz"], [0.0, -0.388, 0.051])
self.assertEqual(
result["components"]["nested"]["type"], "Assembly::AssemblyLink"
)
self.assertEqual(result["components"]["direct"]["type"], "App::Link")
self.assertEqual(result["components"]["direct"]["xyz"], [0.0, 5.0, 0.0])
self.assertEqual(
result["connector_ids"], ["mount", "public_mount", "public_mount"]
)
def test_translate_model_json_preserves_part_assembly_semantics_in_script(self):
with GraphSession() as session:
body = scad.make_box_rsolid(2.0, 3.0, 1.0)
material = scad.make_material_rmaterial(
"steel_8_8", density=7.85e-6, density_unit="kg/mm^3"
)
part = scad.assign_material_rpart(
scad.make_part_rpart("plate", body), material
)
assembly = scad.make_assembly_rassembly("fixture")
assembly = scad.add_component_rassembly(
assembly,
part,
component_id="plate_1",
placement=scad.identity_placement_rplacement(),
)
scad.make_compound_from_assembly_rcompound(assembly)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("PRODUCT_VALUES = {}", script)
self.assertIn("import Assembly", script)
self.assertIn("Assembly::AssemblyObject", script)
self.assertIn("SimpleCADPartId", script)
self.assertIn("SimpleCADMaterial", script)
self.assertIn("SimpleCADAssemblyId", script)
self.assertIn("SimpleCADComponentId", script)
self.assertIn("Part.makeCompound", script)
def test_translate_model_json_assigns_external_material_params_in_script(self):
material = scad.make_material_rmaterial(
"external_aluminum_6061",
name="External 6061 aluminum",
density=2.7e-6,
density_unit="kg/mm^3",
color=(0.2, 0.4, 0.6),
)
with GraphSession() as session:
for part_id in ("external_material_plate_a", "external_material_plate_b"):
body = scad.make_box_rsolid(2.0, 3.0, 1.0)
part = scad.make_part_rpart(part_id, body)
scad.assign_material_rpart(part, material)
payload = json.loads(scad.export_model_json(session))
assign_nodes = [
node
for node in payload["graph"]["nodes"]
if node["op"] == "make_assign_material_rpart"
]
self.assertEqual(len(assign_nodes), 2)
self.assertTrue(all(len(node["inputs"]) == 1 for node in assign_nodes))
expected_material = {
"material_id": "external_aluminum_6061",
"name": "External 6061 aluminum",
"density": 2.7e-6,
"density_unit": "kg/mm^3",
"color": [0.2, 0.4, 0.6],
}
self.assertEqual(
[node["params"]["material"] for node in assign_nodes],
[expected_material, expected_material],
)
replayed = scad.replay_model_json(json.dumps(payload))
self.assertEqual(len(replayed), 2)
self.assertTrue(
all(part.material.to_dict() == material.to_dict() for part in replayed)
)
script = _compile_model_json(json.dumps(payload))
self.assertIn("SimpleCADMaterial", script)
self.assertIn("_material = _material_from_assignment_params(", script)
self.assertIn("App::MaterialObjectPython", script)
self.assertIn("SimpleCADMaterialObject", script)
self.assertIn("GUI_SHAPE_COLOR_BY_NAME", script)
def test_translate_model_json_emits_public_connector_datums_in_script(self):
with GraphSession() as session:
body = scad.make_box_rsolid(1.0, 1.0, 1.0)
part = scad.make_part_rpart("translator_connector_part", body)
axis = scad.make_placement_connector_rconnector(
"axis",
scad.make_placement_rplacement(origin=(2.0, 0.0, 0.0)),
)
part = scad.add_connector_rpart(part, axis)
child = scad.make_assembly_rassembly("translator_connector_child")
child = scad.add_component_rassembly(
child,
part,
component_id="inner",
placement=scad.make_placement_rplacement(origin=(5.0, 0.0, 0.0)),
)
scad.set_public_connector_rassembly(
child,
public_connector_id="public_axis",
source_component_id="inner",
source_connector_id="axis",
)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("make_placement_connector_rconnector", script)
self.assertIn("make_set_public_connector_rassembly", script)
self.assertIn("_materialize_product_connector_datums", script)
self.assertIn("PartDesign::CoordinateSystem", script)
self.assertIn("public_axis", script)
def test_translate_model_json_rejects_removed_public_connector_offset(self):
with GraphSession() as session:
body = scad.make_box_rsolid(1.0, 1.0, 1.0)
part = scad.make_part_rpart("translator_connector_part", body)
axis = scad.make_placement_connector_rconnector(
"axis", scad.identity_placement_rplacement()
)
part = scad.add_connector_rpart(part, axis)
child = scad.make_assembly_rassembly("translator_connector_child")
child = scad.add_component_rassembly(
child,
part,
component_id="inner",
placement=scad.identity_placement_rplacement(),
)
scad.set_public_connector_rassembly(
child,
public_connector_id="public_axis",
source_component_id="inner",
source_connector_id="axis",
)
payload = json.loads(scad.export_model_json(session))
public_node = next(
node
for node in payload["graph"]["nodes"]
if node["op"] == "make_set_public_connector_rassembly"
)
public_node["params"]["offset"] = scad.identity_placement_rplacement().to_dict()
with self.assertRaisesRegex(ValueError, r"unsupported parameter\(s\): offset"):
_compile_model_json(json.dumps(payload))
def test_translate_model_json_emits_native_constraint_joints_in_script(self):
with GraphSession() as session:
body = scad.make_box_rsolid(1.0, 1.0, 1.0)
top_face = ql.faces().resolve(body)[-1]
connector = scad.make_face_connector_rconnector("axis", top_face)
part = scad.add_connector_rpart(
scad.make_part_rpart("block", body), connector
)
assembly = scad.make_assembly_rassembly("fixture")
assembly = scad.add_component_rassembly(
assembly,
part,
component_id="base",
placement=scad.identity_placement_rplacement(),
)
assembly = scad.add_component_rassembly(
assembly,
part,
component_id="slider",
placement=scad.identity_placement_rplacement(),
)
assembly = scad.ground_component_rassembly(assembly, "base")
assembly = scad.add_prismatic_constraint_rassembly(
assembly,
"slide",
scad.make_connector_ref_rconnectorref("base", "axis"),
scad.make_connector_ref_rconnectorref("slider", "axis"),
drive_distance=3.0,
)
scad.solve_assembly_constraints_rassembly(assembly)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("import JointObject", script)
self.assertIn("JointObject.Joint", script)
self.assertIn("SimpleCADConstraint", script)
self.assertIn("SimpleCADConstraintTranslationStatus", script)
self.assertIn('"prismatic": "Slider"', script)
def test_translate_model_json_emits_native_coupling_joints_in_script(self):
with GraphSession() as session:
body = scad.make_box_rsolid(1.0, 1.0, 1.0)
top_face = ql.faces().resolve(body)[-1]
x_edge = ql.edges().resolve(body)[8]
axis_connector = scad.make_face_connector_rconnector("axis_z", top_face)
slide_connector = scad.make_edge_connector_rconnector(
"slide_x", x_edge, flip=True
)
part = scad.make_part_rpart("coupler_block", body)
part = scad.add_connector_rpart(part, axis_connector)
part = scad.add_connector_rpart(part, slide_connector)
assembly = scad.make_assembly_rassembly("coupler_fixture")
placements = {
"ground_gear_a": (0.0, 0.0, 0.0),
"gear_a": (0.0, 0.0, 0.0),
"ground_gear_b": (3.0, 0.0, 0.0),
"gear_b": (3.0, 0.0, 0.0),
"ground_pulley_a": (0.0, 10.0, 0.0),
"pulley_a": (0.0, 10.0, 0.0),
"ground_pulley_b": (7.0, 10.0, 0.0),
"pulley_b": (7.0, 10.0, 0.0),
"ground_rack": (0.0, 20.0, 0.0),
"rack": (0.0, 20.0, 0.0),
"ground_pinion": (0.0, 25.0, 0.0),
"pinion": (0.0, 25.0, 0.0),
}
for component_id, origin in placements.items():
assembly = scad.add_component_rassembly(
assembly,
part,
component_id=component_id,
placement=scad.make_placement_rplacement(origin=origin),
)
for component_id in placements:
if component_id.startswith("ground_"):
assembly = scad.ground_component_rassembly(assembly, component_id)
ground_gear_a_ref = scad.make_connector_ref_rconnectorref(
"ground_gear_a", "axis_z"
)
ground_gear_b_ref = scad.make_connector_ref_rconnectorref(
"ground_gear_b", "axis_z"
)
ground_pulley_a_ref = scad.make_connector_ref_rconnectorref(
"ground_pulley_a", "axis_z"
)
ground_pulley_b_ref = scad.make_connector_ref_rconnectorref(
"ground_pulley_b", "axis_z"
)
ground_rack_ref = scad.make_connector_ref_rconnectorref(
"ground_rack", "slide_x"
)
ground_pinion_ref = scad.make_connector_ref_rconnectorref(
"ground_pinion", "axis_z"
)
gear_a_ref = scad.make_connector_ref_rconnectorref("gear_a", "axis_z")
gear_b_ref = scad.make_connector_ref_rconnectorref("gear_b", "axis_z")
pulley_a_ref = scad.make_connector_ref_rconnectorref("pulley_a", "axis_z")
pulley_b_ref = scad.make_connector_ref_rconnectorref("pulley_b", "axis_z")
rack_ref = scad.make_connector_ref_rconnectorref("rack", "slide_x")
pinion_ref = scad.make_connector_ref_rconnectorref("pinion", "axis_z")
assembly = scad.add_revolute_constraint_rassembly(
assembly,
"gear_a_axis",
ground_gear_a_ref,
gear_a_ref,
drive_angle_degrees=90.0,
)
assembly = scad.add_revolute_constraint_rassembly(
assembly,
"gear_b_axis",
ground_gear_b_ref,
gear_b_ref,
)
assembly = scad.add_revolute_constraint_rassembly(
assembly,
"pulley_a_axis",
ground_pulley_a_ref,
pulley_a_ref,
drive_angle_degrees=90.0,
)
assembly = scad.add_revolute_constraint_rassembly(
assembly,
"pulley_b_axis",
ground_pulley_b_ref,
pulley_b_ref,
)
assembly = scad.add_prismatic_constraint_rassembly(
assembly,
"rack_slide",
ground_rack_ref,
rack_ref,
)
assembly = scad.add_revolute_constraint_rassembly(
assembly,
"pinion_axis",
ground_pinion_ref,
pinion_ref,
)
assembly = scad.add_gear_constraint_rassembly(
assembly,
"gear_mesh",
gear_a_ref,
gear_b_ref,
pitch_radius_a=1.0,
pitch_radius_b=2.0,
)
assembly = scad.add_belt_constraint_rassembly(
assembly,
"belt_loop",
pulley_a_ref,
pulley_b_ref,
pulley_radius_a=3.0,
pulley_radius_b=4.0,
)
assembly = scad.add_rack_pinion_constraint_rassembly(
assembly,
"rack_mesh",
rack_ref,
pinion_ref,
pitch_radius=5.0,
)
scad.make_compound_from_assembly_rcompound(assembly)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn('"gear": "Gears"', script)
self.assertIn('"belt": "Belt"', script)
self.assertIn('"rack_pinion": "RackPinion"', script)
self.assertIn("'constraint_kind': 'gear'", script)
self.assertIn("'constraint_kind': 'belt'", script)
self.assertIn(
'joint.Distance2 = float(constraint_payload.get("pitch_radius_b"))', script
)
self.assertIn(
'joint.Distance2 = float(constraint_payload.get("pulley_radius_b"))', script
)
self.assertIn(
'joint.Distance = float(constraint_payload.get("pitch_radius"))', script
)
def test_translate_model_json_coupling_fcstd_contains_native_joint_properties(self):
with GraphSession() as session:
body = scad.make_box_rsolid(1.0, 1.0, 1.0)
top_face = ql.faces().resolve(body)[-1]
x_edge = ql.edges().resolve(body)[8]
axis_connector = scad.make_face_connector_rconnector("axis_z", top_face)
slide_connector = scad.make_edge_connector_rconnector(
"slide_x", x_edge, flip=True
)
part = scad.make_part_rpart("coupler_block", body)
part = scad.add_connector_rpart(part, axis_connector)
part = scad.add_connector_rpart(part, slide_connector)
assembly = scad.make_assembly_rassembly("coupler_fixture")
placements = {
"ground_gear_a": (0.0, 0.0, 0.0),
"gear_a": (0.0, 0.0, 0.0),
"ground_gear_b": (3.0, 0.0, 0.0),
"gear_b": (3.0, 0.0, 0.0),
"ground_pulley_a": (0.0, 10.0, 0.0),
"pulley_a": (0.0, 10.0, 0.0),
"ground_pulley_b": (7.0, 10.0, 0.0),
"pulley_b": (7.0, 10.0, 0.0),
"ground_rack": (0.0, 20.0, 0.0),
"rack": (0.0, 20.0, 0.0),
"ground_pinion": (0.0, 25.0, 0.0),
"pinion": (0.0, 25.0, 0.0),
}
for component_id, origin in placements.items():
assembly = scad.add_component_rassembly(
assembly,
part,
component_id=component_id,
placement=scad.make_placement_rplacement(origin=origin),
)
for component_id in placements:
if component_id.startswith("ground_"):
assembly = scad.ground_component_rassembly(assembly, component_id)
ground_gear_a_ref = scad.make_connector_ref_rconnectorref(
"ground_gear_a", "axis_z"
)
ground_gear_b_ref = scad.make_connector_ref_rconnectorref(
"ground_gear_b", "axis_z"
)
ground_pulley_a_ref = scad.make_connector_ref_rconnectorref(
"ground_pulley_a", "axis_z"
)
ground_pulley_b_ref = scad.make_connector_ref_rconnectorref(
"ground_pulley_b", "axis_z"
)
ground_rack_ref = scad.make_connector_ref_rconnectorref(
"ground_rack", "slide_x"
)
ground_pinion_ref = scad.make_connector_ref_rconnectorref(
"ground_pinion", "axis_z"
)
gear_a_ref = scad.make_connector_ref_rconnectorref("gear_a", "axis_z")
gear_b_ref = scad.make_connector_ref_rconnectorref("gear_b", "axis_z")
pulley_a_ref = scad.make_connector_ref_rconnectorref("pulley_a", "axis_z")
pulley_b_ref = scad.make_connector_ref_rconnectorref("pulley_b", "axis_z")
rack_ref = scad.make_connector_ref_rconnectorref("rack", "slide_x")
pinion_ref = scad.make_connector_ref_rconnectorref("pinion", "axis_z")
assembly = scad.add_revolute_constraint_rassembly(
assembly,
"gear_a_axis",
ground_gear_a_ref,
gear_a_ref,
drive_angle_degrees=90.0,
)
assembly = scad.add_revolute_constraint_rassembly(
assembly,
"gear_b_axis",
ground_gear_b_ref,
gear_b_ref,
)
assembly = scad.add_revolute_constraint_rassembly(
assembly,
"pulley_a_axis",
ground_pulley_a_ref,
pulley_a_ref,
drive_angle_degrees=90.0,
)
assembly = scad.add_revolute_constraint_rassembly(
assembly,
"pulley_b_axis",
ground_pulley_b_ref,
pulley_b_ref,
)
assembly = scad.add_prismatic_constraint_rassembly(
assembly,
"rack_slide",
ground_rack_ref,
rack_ref,
)
assembly = scad.add_revolute_constraint_rassembly(
assembly,
"pinion_axis",
ground_pinion_ref,
pinion_ref,
)
assembly = scad.add_gear_constraint_rassembly(
assembly,
"gear_mesh",
gear_a_ref,
gear_b_ref,
pitch_radius_a=1.0,
pitch_radius_b=2.0,
)
assembly = scad.add_belt_constraint_rassembly(
assembly,
"belt_loop",
pulley_a_ref,
pulley_b_ref,
pulley_radius_a=3.0,
pulley_radius_b=4.0,
)
assembly = scad.add_rack_pinion_constraint_rassembly(
assembly,
"rack_mesh",
rack_ref,
pinion_ref,
pitch_radius=5.0,
)
scad.make_compound_from_assembly_rcompound(assembly)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
payload = {}
for obj in doc.Objects:
if not hasattr(obj, 'SimpleCADConstraint'):
continue
constraint = json.loads(obj.SimpleCADConstraint)
kind = constraint.get('constraint_kind')
if kind not in {'gear', 'belt', 'rack_pinion'}:
continue
payload[kind] = {
'joint_type': str(getattr(obj, 'JointType', '')),
'distance': round(float(getattr(obj, 'Distance', 0.0)), 6),
'distance2': round(float(getattr(obj, 'Distance2', 0.0)), 6),
'status': obj.SimpleCADConstraintTranslationStatus,
}
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump(payload, fh)
"""
result = self._inspect_fcstd_json(scad.export_model_json(session), probe)
self.assertEqual(result["gear"]["joint_type"], "Gears")
self.assertEqual(result["gear"]["distance"], 1.0)
self.assertEqual(result["gear"]["distance2"], 2.0)
self.assertEqual(result["belt"]["joint_type"], "Belt")
self.assertEqual(result["belt"]["distance"], 3.0)
self.assertEqual(result["belt"]["distance2"], 4.0)
self.assertEqual(result["rack_pinion"]["joint_type"], "RackPinion")
self.assertEqual(result["rack_pinion"]["distance"], 5.0)
self.assertEqual(
{entry["status"] for entry in result.values()},
{"native_equivalent"},
)
def test_translate_model_json_constraint_fcstd_contains_native_joint_metadata(self):
with GraphSession() as session:
body = scad.make_box_rsolid(1.0, 1.0, 1.0)
top_face = ql.faces().resolve(body)[-1]
connector = scad.make_face_connector_rconnector("axis", top_face)
part = scad.add_connector_rpart(
scad.make_part_rpart("block", body), connector
)
assembly = scad.make_assembly_rassembly("fixture")
assembly = scad.add_component_rassembly(
assembly,
part,
component_id="base",
placement=scad.identity_placement_rplacement(),
)
assembly = scad.add_component_rassembly(
assembly,
part,
component_id="slider",
placement=scad.identity_placement_rplacement(),
)
assembly = scad.ground_component_rassembly(assembly, "base")
assembly = scad.add_prismatic_constraint_rassembly(
assembly,
"slide",
scad.make_connector_ref_rconnectorref("base", "axis"),
scad.make_connector_ref_rconnectorref("slider", "axis"),
drive_distance=3.0,
)
scad.solve_assembly_constraints_rassembly(assembly)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
joints = [obj for obj in doc.Objects if hasattr(obj, 'SimpleCADConstraint')]
links = [obj for obj in doc.Objects if hasattr(obj, 'SimpleCADComponentId')]
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'joint_count': len(joints),
'joint_types': [str(getattr(obj, 'JointType', '')) for obj in joints],
'statuses': [obj.SimpleCADConstraintTranslationStatus for obj in joints],
'constraint_kinds': [json.loads(obj.SimpleCADConstraint)['constraint_kind'] for obj in joints],
'slider_z': {obj.SimpleCADComponentId: round(float(obj.Placement.Base.z), 3) for obj in links},
}, fh)
"""
result = self._inspect_fcstd_json(scad.export_model_json(session), probe)
self.assertEqual(result["joint_count"], 1)
self.assertEqual(result["joint_types"], ["Slider"])
self.assertEqual(result["statuses"], ["native_equivalent"])
self.assertEqual(result["constraint_kinds"], ["prismatic"])
self.assertEqual(result["slider_z"]["slider"], 3.0)
def test_translate_model_json_public_connector_joint_references_components(self):
with GraphSession() as session:
shaft_body = scad.make_cylinder_rsolid(
radius=1.0,
height=4.0,
bottom_face_center=(0.0, 0.0, -2.0),
axis=(0.0, 0.0, 1.0),
)
shaft = scad.make_part_rpart("shaft", shaft_body)
shaft_axis = scad.make_placement_connector_rconnector(
"axis",
scad.make_placement_rplacement(origin=(0.0, 0.0, 0.0)),
)
shaft = scad.add_connector_rpart(shaft, shaft_axis)
inner_body = scad.make_box_rsolid(1.0, 1.0, 1.0)
inner = scad.make_part_rpart("bearing_inner", inner_body)
inner_axis = scad.make_placement_connector_rconnector(
"axis",
scad.make_placement_rplacement(origin=(0.0, 0.0, 0.0)),
)
inner = scad.add_connector_rpart(inner, inner_axis)
bearing = scad.make_assembly_rassembly("bearing_unit")
bearing = scad.add_component_rassembly(
bearing,
inner,
component_id="inner_ring",
placement=scad.identity_placement_rplacement(),
)
bearing = scad.set_public_connector_rassembly(
bearing,
public_connector_id="inner_axis",
source_component_id="inner_ring",
source_connector_id="axis",
)
assembly = scad.make_assembly_rassembly("fixture")
assembly = scad.add_component_rassembly(
assembly,
shaft,
component_id="shaft",
placement=scad.identity_placement_rplacement(),
)
assembly = scad.add_component_rassembly(
assembly,
bearing,
component_id="bearing",
placement=scad.identity_placement_rplacement(),
)
assembly = scad.ground_component_rassembly(assembly, "shaft")
assembly = scad.add_revolute_constraint_rassembly(
assembly,
"shaft_to_bearing_inner",
scad.make_connector_ref_rconnectorref("shaft", "axis"),
scad.make_connector_ref_rconnectorref("bearing", "inner_axis"),
)
scad.solve_assembly_constraints_rassembly(assembly)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
joints = [obj for obj in doc.Objects if hasattr(obj, 'SimpleCADConstraint')]
def ref_payload(ref):
if not ref:
return {'component_id': '', 'type_id': '', 'subs': []}
obj = ref[0]
return {
'component_id': str(getattr(obj, 'SimpleCADComponentId', '')),
'type_id': str(getattr(obj, 'TypeId', '')),
'subs': [str(sub) for sub in list(ref[1])],
}
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
joint = joints[0]
json.dump({
'joint_count': len(joints),
'status': joint.SimpleCADConstraintTranslationStatus,
'kind': json.loads(joint.SimpleCADConstraint)['constraint_kind'],
'ref1': ref_payload(getattr(joint, 'Reference1', None)),
'ref2': ref_payload(getattr(joint, 'Reference2', None)),
'placement1_base': [
round(float(joint.Placement1.Base.x), 6),
round(float(joint.Placement1.Base.y), 6),
round(float(joint.Placement1.Base.z), 6),
],
'placement2_base': [
round(float(joint.Placement2.Base.x), 6),
round(float(joint.Placement2.Base.y), 6),
round(float(joint.Placement2.Base.z), 6),
],
}, fh)
"""
result = self._inspect_fcstd_json(scad.export_model_json(session), probe)
self.assertEqual(result["joint_count"], 1)
self.assertEqual(result["status"], "native_equivalent")
self.assertEqual(result["kind"], "revolute")
self.assertEqual(result["ref1"]["component_id"], "shaft")
self.assertEqual(result["ref2"]["component_id"], "bearing")
self.assertTrue(result["ref1"]["subs"][0].startswith("connector_axis"))
self.assertTrue(result["ref2"]["subs"][0].startswith("connector_inner_axis"))
def test_translate_model_json_fcstd_resolves_complex_face_connector(self):
with GraphSession() as session:
gear = scad.std.gear.make_herringbone_gear_rsolid(
n_teeth=18,
module=1.5,
helix_angle=25.0,
gear_height=8.0,
)
top_face = max(
ql.select(gear._iter_faces()).all(), key=lambda face: face.get_center().z
)
connector = scad.make_face_connector_rconnector("axis", top_face)
part = scad.add_connector_rpart(
scad.make_part_rpart("gear", gear), connector
)
assembly = scad.make_assembly_rassembly("gear_fixture")
assembly = scad.add_component_rassembly(
assembly,
part,
component_id="base",
placement=scad.identity_placement_rplacement(),
)
assembly = scad.add_component_rassembly(
assembly,
part,
component_id="follower",
placement=scad.make_placement_rplacement(origin=(5.0, 0.0, 0.0)),
)
assembly = scad.ground_component_rassembly(assembly, "base")
assembly = scad.add_fixed_constraint_rassembly(
assembly,
"gear_face_fixed",
scad.make_connector_ref_rconnectorref("base", "axis"),
scad.make_connector_ref_rconnectorref("follower", "axis"),
)
assembly = scad.solve_assembly_constraints_rassembly(assembly)
scad.make_compound_from_assembly_rcompound(assembly)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
joints = [obj for obj in doc.Objects if hasattr(obj, 'SimpleCADConstraint')]
links = [obj for obj in doc.Objects if hasattr(obj, 'SimpleCADComponentId')]
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'joint_count': len(joints),
'statuses': [obj.SimpleCADConstraintTranslationStatus for obj in joints],
'refs': [str(getattr(obj, 'Reference1', '')) + str(getattr(obj, 'Reference2', '')) for obj in joints],
'link_x': {obj.SimpleCADComponentId: round(float(obj.Placement.Base.x), 3) for obj in links},
}, fh)
"""
result = self._inspect_fcstd_json(scad.export_model_json(session), probe)
self.assertEqual(result["joint_count"], 1)
self.assertEqual(result["statuses"], ["native_equivalent"])
self.assertIn("connector_axis", result["refs"][0])
self.assertEqual(result["link_x"], {"base": 0.0, "follower": 0.0})
def test_translate_model_json_part_assembly_fcstd_valid(self):
with GraphSession() as session:
body = scad.make_box_rsolid(2.0, 3.0, 1.0)
material = scad.make_material_rmaterial(
"steel_8_8", density=7.85e-6, density_unit="kg/mm^3"
)
part = scad.assign_material_rpart(
scad.make_part_rpart("plate", body), material
)
assembly = scad.make_assembly_rassembly("fixture")
assembly = scad.add_component_rassembly(
assembly,
part,
component_id="plate_1",
placement=scad.make_placement_rplacement(origin=(5.0, 0.0, 0.0)),
)
scad.make_compound_from_assembly_rcompound(assembly)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
parts = [obj for obj in doc.Objects if obj.TypeId == 'App::Part' and hasattr(obj, 'SimpleCADPartId')]
assemblies = [obj for obj in doc.Objects if obj.TypeId == 'Assembly::AssemblyObject' and hasattr(obj, 'SimpleCADAssemblyId')]
components = [obj for obj in doc.Objects if obj.TypeId == 'App::Link' and hasattr(obj, 'SimpleCADComponentId')]
compound_objs = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_compound_from_assembly_rcompound']
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'part_ids': [obj.SimpleCADPartId for obj in parts],
'assembly_ids': [obj.SimpleCADAssemblyId for obj in assemblies],
'assembly_type_ids': [obj.TypeId for obj in assemblies],
'component_ids': [obj.SimpleCADComponentId for obj in components],
'component_type_ids': [obj.TypeId for obj in components],
'component_linked_type_ids': [obj.LinkedObject.TypeId for obj in components],
'component_x': [round(obj.Placement.Base.x, 3) for obj in components],
'assembly_visible': [bool(obj.Visibility) for obj in assemblies],
'compound_visible': [bool(obj.Visibility) for obj in compound_objs],
'compound_count': len(compound_objs),
'compound_volume': 0.0 if not compound_objs else float(compound_objs[-1].Shape.Volume),
}, fh)
"""
payload = scad.export_model_json(session)
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["part_ids"], ["plate"])
self.assertEqual(result["assembly_ids"], ["fixture"])
self.assertEqual(result["assembly_type_ids"], ["Assembly::AssemblyObject"])
self.assertEqual(result["component_ids"], ["plate_1"])
self.assertEqual(result["component_type_ids"], ["App::Link"])
self.assertEqual(result["component_linked_type_ids"], ["App::Part"])
self.assertEqual(result["component_x"], [5.0])
self.assertEqual(result["assembly_visible"], [True])
self.assertEqual(result["compound_visible"], [False])
self.assertEqual(result["compound_count"], 1)
self.assertGreater(result["compound_volume"], 0.0)
def test_translate_product_package_fcstd_preserves_editable_materials(self):
package = _build_freecad_material_package()
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
materials = [obj for obj in doc.Objects if obj.TypeId == 'App::MaterialObjectPython' and hasattr(obj, 'SimpleCADMaterialId')]
parts = [obj for obj in doc.Objects if obj.TypeId == 'App::Part' and hasattr(obj, 'SimpleCADPartId')]
bodies = [obj for obj in doc.Objects if hasattr(obj, 'SimpleCADSourceBodyNodeId')]
components = [obj for obj in doc.Objects if obj.TypeId == 'App::Link' and hasattr(obj, 'SimpleCADComponentId')]
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'materials': {
obj.SimpleCADMaterialId: {
'name': obj.SimpleCADMaterialName,
'density': float(obj.SimpleCADDensity) if hasattr(obj, 'SimpleCADDensity') else None,
'density_unit': obj.SimpleCADDensityUnit if hasattr(obj, 'SimpleCADDensityUnit') else None,
'color': list(obj.SimpleCADColor)[:3] if hasattr(obj, 'SimpleCADColor') else None,
'native_map': dict(obj.Material),
}
for obj in materials
},
'part_materials': {obj.SimpleCADPartId: obj.SimpleCADMaterialObject.SimpleCADMaterialId for obj in parts},
'body_materials': {obj.Name: obj.SimpleCADMaterialObject.SimpleCADMaterialId for obj in bodies},
'component_materials': {obj.SimpleCADComponentId: obj.SimpleCADMaterialObject.SimpleCADMaterialId for obj in components},
}, fh)
"""
result = self._inspect_product_package_fcstd_json(package, probe)
self.assertEqual(set(result["materials"]), {"blue_aluminum", "uncolored_steel"})
self.assertEqual(result["materials"]["blue_aluminum"]["name"], "Blue aluminum")
self.assertAlmostEqual(result["materials"]["blue_aluminum"]["density"], 2.7e-6)
self.assertEqual(
result["materials"]["blue_aluminum"]["density_unit"], "kg/mm^3"
)
self.assertIsNone(result["materials"]["uncolored_steel"]["density"])
self.assertEqual(
[
round(value, 3)
for value in result["materials"]["blue_aluminum"]["color"]
],
[0.2, 0.4, 0.6],
)
self.assertEqual(
result["materials"]["blue_aluminum"]["native_map"]["SimpleCAD.MaterialId"],
"blue_aluminum",
)
self.assertEqual(
result["part_materials"],
{
"blue_a": "blue_aluminum",
"blue_b": "blue_aluminum",
"plain": "uncolored_steel",
},
)
self.assertEqual(result["body_materials"], {})
self.assertEqual(
result["component_materials"],
{
"blue_a_1": "blue_aluminum",
"blue_b_1": "blue_aluminum",
"plain_1": "uncolored_steel",
},
)
def test_translate_model_json_nested_assembly_uses_native_assembly_link(self):
with GraphSession() as session:
body = scad.make_box_rsolid(1.0, 1.0, 1.0)
part = scad.make_part_rpart("cube", body)
child = scad.make_assembly_rassembly("child")
child = scad.add_component_rassembly(
child,
part,
component_id="cube_1",
placement=scad.identity_placement_rplacement(),
)
root = scad.make_assembly_rassembly("root")
root = scad.add_component_rassembly(
root,
child,
component_id="child_1",
placement=scad.make_placement_rplacement(origin=(4.0, 0.0, 0.0)),
)
scad.make_compound_from_assembly_rcompound(root)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
assembly_objs = [obj for obj in doc.Objects if obj.TypeId == 'Assembly::AssemblyObject' and hasattr(obj, 'SimpleCADAssemblyId')]
subassembly_links = [obj for obj in doc.Objects if obj.TypeId == 'Assembly::AssemblyLink' and hasattr(obj, 'SimpleCADComponentId')]
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'assembly_ids': sorted(obj.SimpleCADAssemblyId for obj in assembly_objs),
'assembly_visibility': {
obj.SimpleCADAssemblyId: bool(obj.Visibility)
for obj in assembly_objs
},
'subassembly_component_ids': [obj.SimpleCADComponentId for obj in subassembly_links],
'subassembly_linked_type_ids': [obj.LinkedObject.TypeId for obj in subassembly_links],
'subassembly_x': [round(obj.Placement.Base.x, 3) for obj in subassembly_links],
'subassembly_rigid': [bool(obj.Rigid) for obj in subassembly_links],
}, fh)
"""
payload = scad.export_model_json(session)
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["assembly_ids"], ["child", "root"])
self.assertEqual(
result["assembly_visibility"],
{"child": False, "root": True},
)
self.assertEqual(result["subassembly_component_ids"], ["child_1"])
self.assertEqual(
result["subassembly_linked_type_ids"], ["Assembly::AssemblyObject"]
)
self.assertEqual(result["subassembly_x"], [4.0])
self.assertEqual(result["subassembly_rigid"], [True])
def test_translate_model_json_articulated_subassembly_link_is_flexible(self):
with GraphSession() as session:
body = scad.make_box_rsolid(1.0, 1.0, 1.0)
part = scad.make_part_rpart("cube", body)
connector = scad.make_placement_connector_rconnector(
"axis", scad.identity_placement_rplacement()
)
part = scad.add_connector_rpart(part, connector)
child = scad.make_assembly_rassembly("child")
for component_id in ("base", "arm"):
child = scad.add_component_rassembly(
child,
part,
component_id=component_id,
placement=scad.identity_placement_rplacement(),
)
child = scad.ground_component_rassembly(child, "base")
child = scad.add_revolute_constraint_rassembly(
child,
"pivot",
scad.make_connector_ref_rconnectorref("base", "axis"),
scad.make_connector_ref_rconnectorref("arm", "axis"),
)
child = scad.solve_assembly_constraints_rassembly(child)
child = scad.set_public_connector_rassembly(
child,
public_connector_id="output_axis",
source_component_id="arm",
source_connector_id="axis",
)
root = scad.make_assembly_rassembly("root")
root = scad.add_component_rassembly(
root,
child,
component_id="child_1",
placement=scad.identity_placement_rplacement(),
)
root = scad.add_component_rassembly(
root,
part,
component_id="fixture",
placement=scad.identity_placement_rplacement(),
)
root = scad.ground_component_rassembly(root, "fixture")
root = scad.add_fixed_constraint_rassembly(
root,
"mount_output",
scad.make_connector_ref_rconnectorref("fixture", "axis"),
scad.make_connector_ref_rconnectorref("child_1", "output_axis"),
)
root = scad.solve_assembly_constraints_rassembly(root)
scad.make_compound_from_assembly_rcompound(root)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
links = [
obj for obj in doc.Objects
if obj.TypeId == 'Assembly::AssemblyLink'
and getattr(obj, 'SimpleCADComponentId', '') == 'child_1'
]
all_joints = [obj for obj in doc.Objects if hasattr(obj, 'SimpleCADConstraint')]
grounds = [obj for obj in doc.Objects if hasattr(obj, 'SimpleCADGroundedComponent')]
assembly_by_id = {
str(obj.SimpleCADAssemblyId): obj
for obj in doc.Objects
if obj.TypeId == 'Assembly::AssemblyObject'
and hasattr(obj, 'SimpleCADAssemblyId')
}
def constraint_payload(obj):
return json.loads(obj.SimpleCADConstraint)
def reference_name(reference):
if not reference:
return ''
target = reference[0]
return str(getattr(target, 'SimpleCADComponentId', '') or getattr(target, 'Name', ''))
child_assembly = assembly_by_id['child']
child_joint_group = next(
obj for obj in list(getattr(child_assembly, 'OutList', []) or [])
if getattr(obj, 'TypeId', '') == 'Assembly::JointGroup'
)
child_joints = [
obj for obj in list(getattr(child_joint_group, 'Group', []) or [])
if hasattr(obj, 'SimpleCADConstraint')
]
pivot = next(obj for obj in child_joints if constraint_payload(obj).get('constraint_id') == 'pivot')
mount = next(obj for obj in all_joints if constraint_payload(obj).get('constraint_id') == 'mount_output')
child_joint_ids = {constraint_payload(obj).get('constraint_id') for obj in child_joints}
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'count': len(links),
'rigid': [bool(obj.Rigid) for obj in links],
'output_reference_type': str(mount.Reference2[0].TypeId),
'child_joint_ids': [constraint_payload(obj).get('constraint_id') for obj in child_joints],
'child_joint_statuses': [str(getattr(obj, 'SimpleCADConstraintTranslationStatus', '')) for obj in child_joints],
'pivot_reference_names': [reference_name(pivot.Reference1), reference_name(pivot.Reference2)],
'pivot_status': str(getattr(pivot, 'SimpleCADConstraintTranslationStatus', '')),
'root_joint_ids': [
constraint_payload(obj).get('constraint_id')
for obj in all_joints
if constraint_payload(obj).get('constraint_id') not in child_joint_ids
],
'joint_visibility': [bool(obj.Visibility) for obj in all_joints],
'ground_visibility': [bool(obj.Visibility) for obj in grounds],
'joint_names': [str(obj.Name) for obj in all_joints],
'ground_names': [str(obj.Name) for obj in grounds],
}, fh)
"""
result = self._inspect_fcstd_json(scad.export_model_json(session), probe)
gui = self._inspect_fcstd_gui_visibility(scad.export_model_json(session))
self.assertEqual(result["count"], 1)
self.assertEqual(result["rigid"], [False])
self.assertEqual(result["output_reference_type"], "App::Link")
self.assertEqual(result["child_joint_ids"], ["pivot"])
self.assertEqual(result["child_joint_statuses"], ["native_equivalent"])
self.assertEqual(result["pivot_reference_names"], ["base", "arm"])
self.assertEqual(result["pivot_status"], "native_equivalent")
self.assertEqual(result["root_joint_ids"], ["mount_output"])
self.assertTrue(result["joint_visibility"])
self.assertTrue(all(visible is False for visible in result["joint_visibility"]))
self.assertTrue(result["ground_visibility"])
self.assertTrue(
all(visible is False for visible in result["ground_visibility"])
)
self.assertGreaterEqual(len(result["joint_names"]), 3)
self.assertTrue(
all(
gui["view_proxy_classes"].get(name) == "JointObject.ViewProviderJoint"
for name in result["joint_names"]
)
)
self.assertTrue(
all(
gui["view_proxy_classes"].get(name)
== "JointObject.ViewProviderGroundedJoint"
for name in result["ground_names"]
)
)
def test_translate_model_json_places_articulated_subassembly_children_once(self):
with GraphSession() as session:
body = scad.make_box_rsolid(1.0, 1.0, 1.0)
part = scad.make_part_rpart("cube", body)
connector = scad.make_placement_connector_rconnector(
"axis", scad.identity_placement_rplacement()
)
part = scad.add_connector_rpart(part, connector)
child = scad.make_assembly_rassembly("child")
for component_id in ("base", "arm"):
child = scad.add_component_rassembly(
child,
part,
component_id=component_id,
placement=scad.identity_placement_rplacement(),
)
child = scad.ground_component_rassembly(child, "base")
child = scad.add_revolute_constraint_rassembly(
child,
"pivot",
scad.make_connector_ref_rconnectorref("base", "axis"),
scad.make_connector_ref_rconnectorref("arm", "axis"),
)
child = scad.solve_assembly_constraints_rassembly(child)
root = scad.make_assembly_rassembly("root")
root = scad.add_component_rassembly(
root,
child,
component_id="child_1",
placement=scad.make_placement_rplacement(origin=(1.0, 2.0, 3.0)),
)
root = scad.place_component_rassembly(
root,
component_id="child_1",
placement=scad.make_placement_rplacement(origin=(4.0, 5.0, 6.0)),
)
scad.make_compound_from_assembly_rcompound(root)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
links = [
obj for obj in doc.Objects
if obj.TypeId == 'Assembly::AssemblyLink'
and getattr(obj, 'SimpleCADComponentId', '') == 'child_1'
]
children = [
child for child in list(links[0].Group or [])
if getattr(child, 'LinkedObject', None) is not None
and getattr(child.LinkedObject, 'SimpleCADComponentId', '') in {'base', 'arm'}
]
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'outer': [round(float(value), 3) for value in (links[0].Placement.Base.x, links[0].Placement.Base.y, links[0].Placement.Base.z)],
'children': {
child.LinkedObject.SimpleCADComponentId: [
round(float(value), 3)
for value in (child.Placement.Base.x, child.Placement.Base.y, child.Placement.Base.z)
]
for child in children
},
}, fh)
"""
result = self._inspect_fcstd_json(scad.export_model_json(session), probe)
self.assertEqual(result["outer"], [0.0, 0.0, 0.0])
self.assertEqual(
result["children"],
{"base": [4.0, 5.0, 6.0], "arm": [4.0, 5.0, 6.0]},
)
def test_translate_model_json_x_axis_cylinder_fcstd_valid(self):
with GraphSession() as session:
scad.make_cylinder_rsolid(
radius=2.0,
height=10.0,
bottom_face_center=(0.0, 0.0, 0.0),
axis=(1.0, 0.0, 0.0),
)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
cylinders = [obj for obj in doc.Objects if obj.TypeId == 'Part::Cylinder']
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'cylinder_count': len(cylinders),
'valid': [bool(obj.Shape.isValid()) for obj in cylinders],
'volumes': [round(float(obj.Shape.Volume), 3) for obj in cylinders],
}, fh)
"""
payload = scad.export_model_json(session)
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["cylinder_count"], 1)
self.assertEqual(result["valid"], [True])
self.assertGreater(result["volumes"][0], 0.0)
def test_translate_model_json_fcstd_multifuse_bridged_union_and_hides_connectors(
self,
):
with GraphSession() as session:
lower = scad.make_box_rsolid(
width=10.0,
height=10.0,
depth=4.0,
bottom_face_center=(0.0, 0.0, 0.0),
)
upper = scad.make_box_rsolid(
width=10.0,
height=10.0,
depth=4.0,
bottom_face_center=(0.0, 0.0, 20.0),
)
bridge = scad.make_box_rsolid(
width=4.0,
height=4.0,
depth=24.0,
bottom_face_center=(0.0, 0.0, 0.0),
)
body = scad.union_rsolid(lower, upper, bridge, glue=False)
connector = scad.make_placement_connector_rconnector(
connector_id="axis",
placement=scad.make_placement_rplacement(origin=(0.0, 0.0, 0.0)),
)
part = scad.make_part_rpart("bridged_part", body)
part = scad.add_connector_rpart(part, connector)
assembly = scad.make_assembly_rassembly("bridged_assembly")
assembly = scad.add_component_rassembly(
assembly,
part,
component_id="bridged_1",
placement=scad.identity_placement_rplacement(),
)
scad.make_compound_from_assembly_rcompound(assembly)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
parts = [obj for obj in doc.Objects if obj.TypeId == 'App::Part' and getattr(obj, 'SimpleCADPartId', '') == 'bridged_part']
part = parts[0]
children = [child for child in getattr(part, 'Group', []) if child.TypeId != 'App::Origin']
body = next(child for child in children if getattr(child, 'SimpleCADOp', '') == 'make_union_rsolid')
connector_children = [child for child in children if hasattr(child, 'SimpleCADConnectorId')]
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'child_labels': [str(child.Label) for child in children],
'child_visible': [bool(child.Visibility) for child in children],
'body_solids': len(body.Shape.Solids),
'body_volume': round(float(body.Shape.Volume), 3),
'connector_visible': [bool(child.Visibility) for child in connector_children],
}, fh)
"""
result = self._inspect_fcstd_json(scad.export_model_json(session), probe)
self.assertIn("body union", result["child_labels"])
self.assertEqual(result["body_solids"], 1)
self.assertGreater(result["body_volume"], 0.0)
visible_by_label = dict(zip(result["child_labels"], result["child_visible"]))
self.assertTrue(visible_by_label["body union"])
self.assertEqual(result["connector_visible"], [False])
def test_translate_model_json_folds_single_use_translate_into_extrusion_fcstd(self):
tx = scad.var("fold_tx", 1.0)
ty = scad.var("fold_ty", 2.0)
tz = scad.var("fold_tz", 3.0)
with GraphSession() as session:
profile = scad.make_circle_rface((0.0, 0.0, 0.0), 1.0)
solid = scad.extrude_rsolid(profile, (0.0, 0.0, 1.0), 2.0)
scad.translate_shape(solid, (tx, ty, tz))
payload = scad.export_model_json(session)
script = _compile_model_json(payload)
self.assertIn("_register_graph_folded_alias", script)
self.assertNotIn("doc.addObject('App::Link'", script)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
extrusions = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_extrude_rsolid']
links = [obj for obj in doc.Objects if getattr(obj, 'TypeId', '') == 'App::Link']
extrusion = extrusions[-1]
folded = json.loads(getattr(extrusion, 'SimpleCADFoldedOps', '[]') or '[]')
exprs = list(getattr(extrusion, 'ExpressionEngine', []))
shape = extrusion.Shape
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'extrusion_count': len(extrusions),
'link_count': len(links),
'placement': [float(extrusion.Placement.Base.x), float(extrusion.Placement.Base.y), float(extrusion.Placement.Base.z)],
'folded_ops': [item.get('op') for item in folded],
'folded_count': len(folded),
'exprs': exprs,
'solid_count': 0 if shape.isNull() else len(shape.Solids),
'volume': 0.0 if shape.isNull() else float(shape.Volume),
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["extrusion_count"], 1)
self.assertEqual(result["link_count"], 0)
self.assertEqual(result["placement"], [1.0, 2.0, 3.0])
self.assertEqual(result["folded_ops"], ["make_translate_rshape"])
self.assertEqual(result["folded_count"], 1)
self.assertEqual(result["solid_count"], 1)
self.assertAlmostEqual(result["volume"], 2.0 * 3.141592653589793, places=5)
expr_map = {prop: expr for prop, expr in result["exprs"]}
normalized_expr_map = {prop.lstrip("."): expr for prop, expr in result["exprs"]}
self.assertIn("Placement.Base.x", normalized_expr_map)
self.assertIn("Placement.Base.y", normalized_expr_map)
self.assertIn("Placement.Base.z", normalized_expr_map)
self.assertIn("var_fold_tx", normalized_expr_map["Placement.Base.x"])
self.assertIn("var_fold_ty", normalized_expr_map["Placement.Base.y"])
self.assertIn("var_fold_tz", normalized_expr_map["Placement.Base.z"])
def test_translate_model_json_extrudes_tag_wrapped_face_profile(self):
with GraphSession(graph_id="tagged_extrude_profile") as session:
profile = scad.make_rectangle_rface(width=4.0, height=3.0)
profile = scad.apply_tag(profile, "role.profile.primary")
profile = scad.apply_tag(profile, "group.profile.extrude")
body = scad.extrude_rsolid(profile, (0.0, 0.0, 1.0), 2.0)
payload = scad.export_model_json(session)
script = _compile_model_json(payload)
self.assertIn("Part::Extrusion", script)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
extrusions = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_extrude_rsolid']
tag_objects = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'apply_tag_rselection']
tag_hosts = [
obj
for obj in doc.Objects
if 'SimpleCADTagNodeIds' in list(getattr(obj, 'PropertiesList', []) or [])
and getattr(obj, 'SimpleCADSemanticRole', '') != 'result'
]
extrusion = extrusions[0]
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'tag_object_count': len(tag_objects),
'tag_host_tags': [list(obj.SimpleCADAppliedTags) for obj in tag_hosts],
'extrusion_count': len(extrusions),
'base_op': getattr(extrusion.Base, 'SimpleCADOp', ''),
'solid_count': len(extrusion.Shape.Solids),
'volume': float(extrusion.Shape.Volume),
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["tag_object_count"], 0)
self.assertIn(
["role.profile.primary", "group.profile.extrude"],
result["tag_host_tags"],
)
self.assertEqual(result["extrusion_count"], 1)
self.assertEqual(result["base_op"], "make_wire_from_edges_rwire")
self.assertEqual(result["solid_count"], 1)
self.assertAlmostEqual(result["volume"], body.get_volume(), places=6)
def test_translate_model_json_extrudes_tag_wrapped_sketch_profile(self):
with GraphSession(graph_id="tagged_sketch_extrude") as session:
sketch = scad.make_sketch_rsketch("tagged_rect")
sketch = scad.add_point_rsketch(sketch, "p0", 0.0, 0.0)
sketch = scad.add_point_rsketch(sketch, "p1", 2.0, 0.0)
sketch = scad.add_point_rsketch(sketch, "p2", 2.0, 1.0)
sketch = scad.add_point_rsketch(sketch, "p3", 0.0, 1.0)
sketch = scad.add_line_rsketch(sketch, "bottom", "p0", "p1")
sketch = scad.add_line_rsketch(sketch, "right", "p1", "p2")
sketch = scad.add_line_rsketch(sketch, "top", "p2", "p3")
sketch = scad.add_line_rsketch(sketch, "left", "p3", "p0")
profile = scad.make_face_from_sketch_rface(sketch)
profile = scad.apply_tag(profile, "role.sketch.profile")
body = scad.extrude_rsolid(profile, (0.0, 0.0, 1.0), 3.0)
payload = scad.export_model_json(session)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
extrusion = next(obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_extrude_rsolid')
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'base_op': getattr(extrusion.Base, 'SimpleCADOp', ''),
'base_type': extrusion.Base.TypeId,
'solid_count': len(extrusion.Shape.Solids),
'volume': float(extrusion.Shape.Volume),
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["base_op"], "make_face_from_sketch_rface")
self.assertEqual(result["base_type"], "Sketcher::SketchObject")
self.assertEqual(result["solid_count"], 1)
self.assertAlmostEqual(result["volume"], body.get_volume(), places=6)
def test_expression_circle_normal_uses_extrusion_profile_fcstd(self):
normal_y = scad.var("circle_normal_y", 1.0)
with GraphSession() as session:
profile = scad.make_circle_rface(
(0.0, 0.0, 0.0),
1.0,
normal=(0.0, normal_y, 0.0),
)
scad.extrude_rsolid(profile, (0.0, 1.0, 0.0), 2.0)
payload = scad.export_model_json(session)
script = _compile_model_json(payload)
self.assertNotIn("doc.addObject('Part::Cylinder'", script)
self.assertIn("doc.addObject('Sketcher::SketchObject'", script)
self.assertIn("doc.addObject('Part::Extrusion'", script)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
extrusions = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_extrude_rsolid']
cylinders = [obj for obj in doc.Objects if obj.TypeId == 'Part::Cylinder']
extrusion = extrusions[0]
shape = extrusion.Shape
sketches = [obj for obj in doc.Objects if obj.TypeId == 'Sketcher::SketchObject']
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'extrusion_count': len(extrusions),
'cylinder_count': len(cylinders),
'solid_count': 0 if shape.isNull() else len(shape.Solids),
'volume': 0.0 if shape.isNull() else float(shape.Volume),
'expr_support': [getattr(obj, 'SimpleCADExprSupport', '') for obj in sketches],
'expr_limitations': [getattr(obj, 'SimpleCADExprLimitation', '') for obj in sketches],
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["extrusion_count"], 1)
self.assertEqual(result["cylinder_count"], 0)
self.assertEqual(result["solid_count"], 1)
self.assertAlmostEqual(result["volume"], 2.0 * 3.141592653589793, places=5)
self.assertIn("limited", result["expr_support"])
self.assertTrue(
any("orientation" in value.lower() for value in result["expr_limitations"])
)
def test_oblique_circle_extrusion_preserves_source_geometry_fcstd(self):
with GraphSession() as session:
profile = scad.make_circle_rface((0.0, 0.0, 0.0), 1.0)
source = scad.extrude_rsolid(profile, (1.0, 0.0, 1.0), 2.0)
payload = scad.export_model_json(session)
script = _compile_model_json(payload)
self.assertNotIn("doc.addObject('Part::Cylinder'", script)
self.assertIn("doc.addObject('Part::Extrusion'", script)
source_box = bounding_box(source.wrapped)
source_bounds = [
source_box.xmin,
source_box.ymin,
source_box.zmin,
source_box.xmax,
source_box.ymax,
source_box.zmax,
]
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
extrusion = next(obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_extrude_rsolid')
shape = extrusion.Shape
box = shape.BoundBox
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'type_id': extrusion.TypeId,
'volume': float(shape.Volume),
'bbox': [
float(box.XMin), float(box.YMin), float(box.ZMin),
float(box.XMax), float(box.YMax), float(box.ZMax),
],
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["type_id"], "Part::Extrusion")
self.assertAlmostEqual(result["volume"], source.get_volume(), places=5)
for actual, expected in zip(result["bbox"], source_bounds):
self.assertAlmostEqual(actual, expected, places=5)
def test_transform_links_compose_non_identity_source_placement_fcstd(self):
with GraphSession() as session:
source = scad.make_box_rsolid(
1.0,
1.0,
1.0,
bottom_face_center=(2.0, 0.0, 0.0),
)
scad.translate_shape(source, (3.0, 0.0, 0.0))
scad.translate_shape(source, (0.0, 3.0, 0.0))
payload = scad.export_model_json(session)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
links = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_translate_rshape']
def bbox(shape):
box = shape.BoundBox
return [
float(box.XMin), float(box.YMin), float(box.ZMin),
float(box.XMax), float(box.YMax), float(box.ZMax),
]
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'link_transforms': [bool(link.LinkTransform) for link in links],
'bounds': [bbox(link.Shape) for link in links],
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["link_transforms"], [True, True])
self.assertEqual(
result["bounds"],
[
[4.5, -0.5, 0.0, 5.5, 0.5, 1.0],
[1.5, 2.5, 0.0, 2.5, 3.5, 1.0],
],
)
def test_translate_model_json_keeps_link_when_translate_input_is_shared(self):
with GraphSession() as session:
profile = scad.make_circle_rface((0.0, 0.0, 0.0), 1.0)
solid = scad.extrude_rsolid(profile, (0.0, 0.0, 1.0), 2.0)
scad.translate_shape(solid, (1.0, 0.0, 0.0))
scad.translate_shape(solid, (0.0, 1.0, 0.0))
payload = scad.export_model_json(session)
script = _compile_model_json(payload)
self.assertIn("doc.addObject('App::Link'", script)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
links = [obj for obj in doc.Objects if getattr(obj, 'TypeId', '') == 'App::Link']
extrusions = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_extrude_rsolid']
folded_counts = [len(json.loads(getattr(obj, 'SimpleCADFoldedOps', '[]') or '[]')) for obj in extrusions]
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'link_count': len(links),
'link_ops': [getattr(obj, 'SimpleCADOp', '') for obj in links],
'linked_ops': [getattr(getattr(obj, 'LinkedObject', None), 'SimpleCADOp', '') for obj in links],
'folded_counts': folded_counts,
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["link_count"], 2)
self.assertEqual(
result["link_ops"], ["make_translate_rshape", "make_translate_rshape"]
)
self.assertEqual(
result["linked_ops"], ["make_extrude_rsolid", "make_extrude_rsolid"]
)
self.assertEqual(result["folded_counts"], [0, 0])
def test_translate_model_json_uses_single_low_level_graph(self):
with GraphSession() as session:
scad.make_box_rsolid(2.0, 3.0, 4.0)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("Part::Box", script)
self.assertIn("RESULT_NODE_IDS", script)
self.assertNotIn("evaluated_graph", script)
def test_semantic_plan_treats_apply_tag_as_result_metadata(self):
with GraphSession(graph_id="semantic_tag_metadata") as session:
body = scad.make_box_rsolid(2.0, 3.0, 4.0)
tagged = scad.apply_tag(body, "role.finished")
result_node_id = tagged.get_metadata("graph")["node_id"]
plan = build_freecad_semantic_plan(
session.graph,
[result_node_id],
document_name="Tagged Result",
)
root = plan["roots"][0]
self.assertNotIn("history", root)
self.assertNotIn("references", root)
self.assertEqual(plan["node_labels"][result_node_id], "tagged")
self.assertIn(result_node_id, root["managed_node_ids"])
def test_semantic_plan_collapses_tagged_assembly_preview_into_product_root(self):
with GraphSession(graph_id="semantic_assembly_preview") as session:
body = scad.make_box_rsolid(2.0, 3.0, 4.0)
part = scad.make_part_rpart("part", body)
assembly = scad.make_assembly_rassembly("assembly")
assembly = scad.add_component_rassembly(
assembly,
part,
component_id="part_1",
placement=scad.identity_placement_rplacement(),
)
preview = scad.make_compound_from_assembly_rcompound(assembly)
preview = scad.apply_tag(preview, "scene.preview")
assembly_node_id = assembly.get_metadata("graph")["node_id"]
preview_node_id = preview.get_metadata("graph")["node_id"]
plan = build_freecad_semantic_plan(
session.graph,
[assembly_node_id, preview_node_id],
document_name="Assembly Preview",
)
self.assertEqual(plan["display_product_node_ids"], [assembly_node_id])
self.assertTrue(all(root["kind"] == "part" for root in plan["roots"]))
self.assertNotIn(
preview_node_id,
[root["result_node_id"] for root in plan["roots"]],
)
def test_semantic_plan_uses_variable_names_for_native_occurrences(self):
with GraphSession(graph_id="semantic_plan") as session:
base_profile = scad.make_rectangle_rface(width=10.0, height=8.0)
base = scad.extrude_rsolid(base_profile, (0.0, 0.0, 1.0), 3.0)
hole = scad.make_cylinder_rsolid(
radius=1.0,
height=5.0,
bottom_face_center=(0.0, 0.0, -1.0),
)
finished = scad.cut_rsolid(base, hole)
result_node_id = finished.get_metadata("graph")["node_id"]
plan = build_freecad_semantic_plan(
session.graph,
[result_node_id],
document_name="Semantic Model",
)
self.assertEqual(len(plan["roots"]), 1)
root = plan["roots"][0]
self.assertEqual(root["kind"], "geometry")
self.assertEqual(root["label"], "finished Model")
self.assertNotIn("history", root)
self.assertNotIn("references", root)
labels = plan["node_labels"]
self.assertEqual(
labels[base_profile.get_metadata("graph")["node_id"]], "base_profile"
)
self.assertEqual(labels[base.get_metadata("graph")["node_id"]], "base")
self.assertEqual(labels[hole.get_metadata("graph")["node_id"]], "hole")
self.assertEqual(labels[result_node_id], "finished")
self.assertEqual(set(root["managed_node_ids"]), set(labels))
def test_semantic_plan_keeps_explicit_product_name_over_state_variable(self):
with GraphSession(graph_id="semantic_product_name") as session:
body = scad.make_box_rsolid(2.0, 3.0, 1.0)
part_state = scad.make_part_rpart("bracket", body, name="Bracket")
material = scad.make_material_rmaterial("aluminum", name="Aluminum")
finished_part = scad.assign_material_rpart(part_state, material)
plan = build_freecad_semantic_plan(
session.graph,
[finished_part.get_metadata("graph")["node_id"]],
document_name="Semantic Part",
)
self.assertEqual(
plan["node_labels"][part_state.get_metadata("graph")["node_id"]], "Bracket"
)
self.assertEqual(plan["roots"][0]["label"], "Bracket")
self.assertEqual(plan["roots"][0]["result_label"], "body")
def test_translate_model_json_fcstd_builds_native_occurrence_tree(self):
with GraphSession(graph_id="native_occurrence_fcstd") as session:
base_profile = scad.make_rectangle_rface(width=10.0, height=8.0)
base = scad.extrude_rsolid(base_profile, (0.0, 0.0, 1.0), 3.0)
hole = scad.make_cylinder_rsolid(
radius=1.0,
height=5.0,
bottom_face_center=(0.0, 0.0, -1.0),
)
finished = scad.cut_rsolid(base, hole)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
root = next(obj for obj in doc.Objects if obj.TypeId == 'App::Part')
cut = next(obj for obj in doc.Objects if obj.TypeId == 'Part::Cut')
extrusions = [obj for obj in doc.Objects if obj.TypeId == 'Part::Extrusion']
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'root_label': str(root.Label),
'root_group_types': [str(obj.TypeId) for obj in root.Group],
'root_group_labels': [str(obj.Label) for obj in root.Group],
'cut_base_type': str(cut.Base.TypeId),
'cut_tool_type': str(cut.Tool.TypeId),
'cut_base_label': str(cut.Base.Label),
'cut_tool_label': str(cut.Tool.Label),
'extrusion_count': len(extrusions),
'result_volume': round(float(cut.Shape.Volume), 3),
'legacy_groups': [
obj.Name for obj in doc.Objects
if obj.Name in {'SimpleCADConstruction'}
or str(getattr(obj, 'Label', '')) in {'Design History', 'References', 'Result'}
],
}, fh)
"""
result = self._inspect_fcstd_json(scad.export_model_json(session), probe)
self.assertEqual(result["root_label"], "finished Model")
self.assertCountEqual(
result["root_group_types"],
[
"Part::Feature",
"Part::Feature",
"Part::Extrusion",
"Part::Cylinder",
"Part::Cut",
],
)
self.assertCountEqual(
result["root_group_labels"],
[
"base profile wire from edges",
"base profile face from wire",
"base extrude",
"hole cylinder",
"finished cut",
],
)
self.assertEqual(result["cut_base_type"], "Part::Extrusion")
self.assertEqual(result["cut_tool_type"], "Part::Cylinder")
self.assertEqual(result["extrusion_count"], 1)
self.assertGreater(result["result_volume"], 0.0)
self.assertEqual(result["legacy_groups"], [])
def test_translate_model_json_expands_shared_profile_per_consumer(self):
with GraphSession(graph_id="shared_profile_occurrences") as session:
profile = scad.make_rectangle_rface(width=4.0, height=2.0)
outer = scad.extrude_rsolid(profile, (0.0, 0.0, 1.0), 3.0)
inner_raw = scad.extrude_rsolid(profile, (0.0, 0.0, 1.0), 5.0)
inner = scad.translate_shape(inner_raw, (1.0, 0.5, -1.0))
finished = scad.cut_rsolid(outer, inner)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
root = next(obj for obj in doc.Objects if obj.TypeId == 'App::Part')
cut = next(obj for obj in doc.Objects if obj.TypeId == 'Part::Cut')
profiles = [obj for obj in doc.Objects if hasattr(obj, 'Shape') and obj.Shape.ShapeType == 'Wire']
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'base_profile': cut.Base.Base.Name,
'tool_profile': cut.Tool.Base.Name,
'profile_count': len(profiles),
'profile_labels': sorted(str(obj.Label) for obj in profiles),
'root_children': [str(obj.Label) for obj in root.Group],
}, fh)
"""
result = self._inspect_fcstd_json(scad.export_model_json(session), probe)
self.assertNotEqual(result["base_profile"], result["tool_profile"])
self.assertEqual(result["profile_count"], 2)
self.assertEqual(result["root_children"].count("finished cut"), 1)
def test_semantic_plan_skips_product_state_result_but_keeps_part_root(self):
with GraphSession(graph_id="semantic_part_result") as session:
body = scad.make_box_rsolid(2.0, 3.0, 1.0)
part = scad.make_part_rpart("bracket", body, name="Bracket")
plan = build_freecad_semantic_plan(
session.graph,
[part.get_metadata("graph")["node_id"]],
document_name="Part Result",
)
root = plan["roots"][0]
self.assertEqual(root["kind"], "part")
self.assertEqual(root["label"], "Bracket")
self.assertNotIn("history", root)
self.assertNotIn("references", root)
def test_semantic_plan_filters_non_geometry_result_nodes(self):
graph = OperationGraph(graph_id="semantic_result_filters")
body = graph.add_node("make_box_rsolid", node_id="body")
part = graph.add_node(
"make_part_rpart",
params={"part_id": "part"},
inputs=[body],
node_id="part",
)
assembly = graph.add_node(
"make_assembly_rassembly",
params={"assembly_id": "assembly"},
node_id="assembly",
)
compound = graph.add_node(
"make_compound_from_assembly_rcompound",
inputs=[assembly],
node_id="compound",
)
plan = build_freecad_semantic_plan(
graph,
["missing", assembly.node_id, compound.node_id, body.node_id, part.node_id],
document_name="Filtered",
)
self.assertEqual(len(plan["roots"]), 1)
self.assertEqual(plan["roots"][0]["kind"], "part")
self.assertEqual(plan["roots"][0]["label"], "part")
self.assertEqual(plan["roots"][0]["result_node_id"], body.node_id)
def test_translate_model_json_requires_graph(self):
payload = {
"schema_version": "2.0",
"canonical_contract": {"contract_version": "2.0"},
"expression_graph": {"nodes": []},
"frame_graph": {"nodes": []},
"geometry_registry": [],
"semantic_entity_registry": [],
"sketch_profile_registry": [],
"semantic_delta_log": [],
"topology_delta_log": [],
}
with self.assertRaises(ValueError):
_compile_model_json(json.dumps(payload))
def test_translate_model_json_emits_expression_formulas_for_ir(self):
r = scad.var("r", 5.0)
with GraphSession() as session:
face = scad.make_circle_rface((0.0, 0.0, 0.0), r)
scad.extrude_rsolid(face, (0.0, 0.0, 1.0), r * 2)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("SimpleCADExpressions", script)
self.assertIn("setAlias", script)
self.assertIn("<<SimpleCADExpressions>>", script)
self.assertIn("LengthFwd", script)
self.assertIn("OP_EXPRESSION_BINDINGS", script)
self.assertIn("_apply_op_expression_bindings", script)
self.assertIn("'make_extrude_rsolid'", script)
self.assertIn("var_r", script)
self.assertIn(
"=<<SimpleCADExpressions>>.var_r * <<SimpleCADExpressions>>.const_", script
)
def test_translate_model_json_preserves_dimension_tolerances(self):
width = scad.var("width", 10.0, tolerance=(-0.1, 0.2))
with GraphSession() as session:
scad.make_box_rsolid(width, 2.0, 1.0)
session.require_tolerance(width * 2.0, (-0.2, 0.4), name="overall")
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("TOLERANCE_GRAPH =", script)
self.assertIn("simplecad_tolerance_graph", script)
self.assertIn("overall", script)
self.assertIn("expr_sheet.set('E1', \"-0.1\")", script)
self.assertIn("expr_sheet.set('F1', \"0.2\")", script)
def test_translate_model_json_preserves_units_and_uses_canonical_values(self):
width = scad.var("width", 1.0, unit="in", tolerance=0.1, tolerance_unit="mm")
angle = scad.var("angle", math.pi / 2.0, unit="rad", tolerance=0.5)
with GraphSession() as session:
scad.make_box_rsolid(width, 2.0, 1.0)
scad.rotate_shape(
scad.make_box_rsolid(1.0, 1.0, 1.0),
angle,
axis=(0.0, 0.0, 1.0),
origin=(0.0, 0.0, 0.0),
)
session.require_tolerance(width, 0.004, tolerance_unit="in")
script = _compile_model_json(scad.export_model_json(session))
self.assertIn('expr_sheet.set("B1", "25.4")', script)
self.assertIn("expr_sheet.set('G1', \"in\")", script)
self.assertIn("expr_sheet.set('H1', \"mm\")", script)
self.assertIn("expr_sheet.set('I1', \"Length\")", script)
self.assertIn("expr_sheet.set('G2', \"rad\")", script)
self.assertIn("expr_sheet.set('H2', \"rad\")", script)
self.assertIn("expr_sheet.set('I2', \"Angle\")", script)
self.assertIn("'tolerance_unit': 'in'", script)
self.assertIn("'target_dimension': {'angle': 0, 'length': 1}", script)
def test_translate_model_json_disambiguates_same_name_variable_aliases(self):
first = scad.var("width", 10.0)
second = scad.var("width", 20.0)
expression = first + second
with GraphSession() as session:
scad.make_box_rsolid(expression, 2.0, 1.0)
script = _compile_model_json(scad.export_model_json(session))
suffix = hashlib.sha256(second.expr_id.encode("utf-8")).hexdigest()[:8]
second_alias = f"var_width_{suffix}"
self.assertIn('setAlias("B1", "var_width")', script)
self.assertIn(f'setAlias("B2", "{second_alias}")', script)
self.assertIn(f"<<SimpleCADExpressions>>.{second_alias}", script)
def test_translate_model_json_uses_ascii_bounded_unique_aliases(self):
variables = [
scad.var("宽度" + "x" * 80, float(index + 1)) for index in range(3)
]
with GraphSession() as session:
scad.make_box_rsolid(variables[0] + variables[1] + variables[2], 2.0, 1.0)
script = _compile_model_json(scad.export_model_json(session))
aliases = []
for line in script.splitlines():
marker = "expr_sheet.setAlias("
if marker not in line:
continue
arguments = line.split("(", 1)[1].rsplit(")", 1)[0]
aliases.append(json.loads("[" + arguments + "]")[1])
self.assertEqual(len(aliases), len(set(aliases)))
self.assertTrue(all(alias.isascii() for alias in aliases))
self.assertTrue(all(len(alias) <= 64 for alias in aliases))
def test_translate_model_json_uses_semantic_spreadsheet_aliases_and_formulas(self):
x = scad.var("hub_radius", 6.5, comment="Hub outer radius")
expr = x + 2.0
with GraphSession() as session:
face = scad.make_circle_rface((0.0, 0.0, 0.0), x)
scad.extrude_rsolid(face, (0.0, 0.0, 1.0), expr)
payload = json.loads(scad.export_model_json(session))
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
ss = doc.getObject('SimpleCADExpressions')
data = {}
for cell in ss.getNonEmptyCells():
data[cell] = {
'alias': ss.getAlias(cell),
'contents': ss.getContents(cell),
'value': ss.get(cell),
}
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump(data, fh)
"""
result = self._inspect_fcstd_json(json.dumps(payload), probe)
self.assertEqual(result["A1"]["contents"].lstrip("'"), "var_hub_radius")
self.assertEqual(result["B1"]["alias"], "var_hub_radius")
self.assertEqual(result["B1"]["contents"], "6.5")
self.assertTrue(result["C1"]["contents"].lstrip("'").startswith("var_"))
self.assertEqual(result["D1"]["contents"].lstrip("'"), "Hub outer radius")
expr_row = next(
row
for row, entry in result.items()
if row.startswith("B") and entry["alias"].startswith("expr_")
)
self.assertIn("var_hub_radius", result[expr_row]["contents"])
self.assertIn("const_", result[expr_row]["contents"])
def test_translate_model_json_resolves_detail_feature_expressions(self):
radius = scad.var("fillet_r", 0.25)
with GraphSession() as session:
box = scad.make_box_rsolid(4.0, 4.0, 4.0)
scad.fillet_rsolid(box, [box.get_edges(i) for i in range(2)], radius)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("Part::Fillet", script)
self.assertIn("_resolve_param_value", script)
def test_translate_model_json_resolves_pattern_expressions(self):
graph = OperationGraph(graph_id="graph_pattern")
seed = graph.add_node(
op="make_line_redge",
params={"start": [0.0, 0.0, 0.0], "end": [1.0, 0.0, 0.0]},
)
graph.add_node(
op="make_translate_rshape",
params={
"vector": [2.0, 0.0, 0.0],
},
param_exprs={"vector": [{"expr_id": "var_spacing"}, None, None]},
inputs=[seed],
)
payload = {
"schema_version": "2.0",
"canonical_contract": {"contract_version": "2.0"},
"graph": graph.to_dict(),
"leaf_ids": [leaf.node_id for leaf in graph.leaf_nodes()],
"expression_graph": {
"nodes": [
{
"expr_id": "var_spacing",
"kind": "var",
"name": "spacing",
"default": 2.0,
}
]
},
"frame_graph": {"nodes": []},
"geometry_registry": [],
"semantic_entity_registry": [],
"sketch_profile_registry": [],
"semantic_delta_log": [],
"topology_delta_log": [],
}
script = _compile_model_json(json.dumps(payload))
self.assertIn("_resolve_nested_param_value", script)
self.assertIn("_resolve_param_value", script)
def test_translate_model_json_resolves_helix_and_arc_expressions(self):
pitch = scad.var("pitch", 1.0)
radius = scad.var("radius", 2.0)
angle = scad.var("angle", 1.57)
with GraphSession() as session:
scad.make_helix_rwire(pitch, 3.0, radius)
scad.make_angle_arc_rwire((0.0, 0.0, 0.0), radius, 0.0, angle)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("Part::Helix", script)
self.assertIn("make_angle_arc_redge", script)
self.assertIn("_apply_op_expression_bindings", script)
self.assertIn("'Pitch'", script)
self.assertIn("'Radius'", script)
def test_translate_model_json_converts_trig_expressions_to_freecad_semantics(self):
theta = scad.var("theta", 0.5)
expr = scad.sin(theta) + scad.acos(theta)
with GraphSession() as session:
face = scad.make_circle_rface((0.0, 0.0, 0.0), 1.0)
scad.extrude_rsolid(face, (0.0, 0.0, 1.0), expr)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("sin((<<SimpleCADExpressions>>.", script)
self.assertIn("* 180 / pi)", script)
self.assertIn("=acos(<<SimpleCADExpressions>>.", script)
self.assertIn("* pi / 180", script)
def test_translate_model_json_preserves_helix_center_and_direction(self):
with GraphSession() as session:
scad.make_helix_rwire(
1.0,
3.0,
2.0,
center=(1.0, 2.0, 3.0),
dir=(0.0, 1.0, 0.0),
)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("Part::Helix", script)
self.assertIn("Placement = App.Placement", script)
def test_translate_model_json_uses_freecad_revolve_signature(self):
with GraphSession() as session:
profile = scad.make_circle_rface((2.0, 0.0, 0.0), 0.5)
scad.revolve_rsolid(
profile,
axis=(0.0, 1.0, 0.0),
angle=180.0,
origin=(1.0, 0.0, 0.0),
)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("Part::Revolution", script)
self.assertIn(".Axis = _vec(", script)
self.assertIn(".Angle = float(", script)
self.assertIn("'Angle'", script)
def test_wire_revolve_keeps_native_source_dependency_fcstd(self):
with GraphSession() as session:
profile = scad.make_rectangle_rwire(
1.0,
1.0,
center=(1.5, 0.0, 0.0),
normal=(0.0, 1.0, 0.0),
)
scad.revolve_rsolid(profile)
payload = scad.export_model_json(session)
script = _compile_model_json(payload)
self.assertNotIn("make_revolve_rsolid_profile", script)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
revolution = next(obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_revolve_rsolid')
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'source_op': getattr(revolution.Source, 'SimpleCADOp', ''),
'solid_count': len(revolution.Shape.Solids),
'volume': float(revolution.Shape.Volume),
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["source_op"], "make_wire_from_edges_rwire")
self.assertEqual(result["solid_count"], 1)
self.assertGreater(result["volume"], 0.0)
def test_translate_model_json_uses_single_graph_sweep_helper(self):
with GraphSession() as session:
profile = scad.make_circle_rface((0.0, 0.0, 0.0), 0.5)
path = scad.make_helix_rwire(1.0, 3.0, 2.0)
scad.sweep_rsolid(profile, path, is_frenet=True)
payload_obj = self._expression_payload(scad.export_model_json(session))
payload_obj["expression_graph"]["nodes"] = [
{"expr_id": "var_frenet", "kind": "var", "name": "frenet", "default": 1.0}
]
for node in payload_obj["graph"]["nodes"]:
if node["op"] == "make_sweep_rsolid":
node["param_exprs"] = {"is_frenet": {"expr_id": "var_frenet"}}
script = _compile_model_json(json.dumps(payload_obj))
self.assertIn("Part::Sweep", script)
self.assertIn(".Spine = _spine_object", script)
self.assertIn(".Frenet = bool(", script)
self.assertIn("'Frenet'", script)
def test_translate_model_json_emulates_twisted_sweep_with_solid_loft(self):
with GraphSession() as session:
profile = scad.make_rectangle_rface(
width=2.0,
height=1.0,
center=(0.0, 0.0, 0.0),
)
scad.twisted_sweep_rsolid(
profile=profile,
distance=4.0,
twist_angle=45.0,
)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("_twisted_sweep_loft_shape", script)
self.assertIn("Part.makeLoft(sections, True, False, False, 5)", script)
self.assertIn("SimpleCADTranslationSupport", script)
self.assertRegex(script, r"['\"]emulated['\"]")
self.assertIn("approximates the continuous SimpleCAD sweep", script)
def test_translate_model_json_twisted_sweep_emulation_fcstd_valid(self):
with GraphSession() as session:
profile = scad.make_rectangle_rface(
width=2.0,
height=1.0,
center=(0.0, 0.0, 0.0),
)
scad.twisted_sweep_rsolid(
profile=profile,
distance=4.0,
twist_angle=45.0,
)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
objects = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_twisted_sweep_rsolid']
obj = objects[-1]
shape = obj.Shape
note = doc.getObject('simplecad_translation_limitations')
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'count': len(objects),
'support': getattr(obj, 'SimpleCADTranslationSupport', ''),
'limitation': getattr(obj, 'SimpleCADTranslationLimitation', ''),
'valid': shape.isValid(),
'solid_count': len(shape.Solids),
'volume': float(shape.Volume),
'note_payload': getattr(note, 'Payload', '') if note is not None else '',
}, fh)
"""
result = self._inspect_fcstd_json(scad.export_model_json(session), probe)
self.assertEqual(result["count"], 1)
self.assertEqual(result["support"], "emulated")
self.assertIn("smooth solid loft", result["limitation"])
self.assertTrue(result["valid"])
self.assertEqual(result["solid_count"], 1)
self.assertGreater(result["volume"], 0.0)
self.assertIn("make_twisted_sweep_rsolid", result["note_payload"])
def test_translate_model_json_materializes_ql_selected_face_profile_for_sweep(self):
with GraphSession() as session:
base = scad.make_circle_rface((0.0, 0.0, 0.0), 0.25)
body = scad.extrude_rsolid(base, (0.0, 0.0, 1.0), 1.0)
profile = (
scad.ql.faces()
.where(scad.ql.tag("face.extrusion.end"))
.exactly(1)
.resolve(body)[0]
)
path = scad.make_segment_rwire((0.0, 0.0, 1.0), (0.0, 0.0, 2.0))
scad.sweep_rsolid(profile, path)
payload = scad.export_model_json(session)
payload_obj = json.loads(payload)
select_node = next(
node
for node in payload_obj["graph"]["nodes"]
if node["op"] == "make_select_rface"
)
sweep_node = next(
node
for node in payload_obj["graph"]["nodes"]
if node["op"] == "make_sweep_rsolid"
)
script = _compile_model_json(payload)
self.assertEqual(sweep_node["inputs"][0], select_node["node_id"])
self.assertIn("GRAPH_SELECTIONS = {}", script)
self.assertIn("GRAPH_SELECTIONS[node_id] = payload", script)
self.assertIn("GRAPH_SPINE_OBJECTS = {}", script)
self.assertRegex(
script,
r"doc\.addObject\(['\"]Part::Feature['\"], f['\"]\{str\(op\)\}_\{str\(node_id\)\}['\"]\)",
)
self.assertIn("obj.Shape = selected_shape", script)
self.assertIn(
f"_register_geo_selection_node(node_id={json.dumps(select_node['node_id'])}, op=\"make_select_rface\"",
script,
)
self.assertIn(
f".Sections = [GRAPH_NODES[{json.dumps(select_node['node_id'])}]]",
script,
)
self.assertIn(".Spine = _spine_object", script)
def test_translate_model_json_ql_selected_face_profile_sweep_fcstd_valid(self):
with GraphSession() as session:
base = scad.make_circle_rface((0.0, 0.0, 0.0), 0.25)
body = scad.extrude_rsolid(base, (0.0, 0.0, 1.0), 1.0)
profile = (
scad.ql.faces()
.where(scad.ql.tag("face.extrusion.end"))
.exactly(1)
.resolve(body)[0]
)
path = scad.make_segment_rwire((0.0, 0.0, 1.0), (0.0, 0.0, 2.0))
scad.sweep_rsolid(profile, path)
payload = scad.export_model_json(session)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
select_objs = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_select_rface']
sweep_objs = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_sweep_rsolid']
selected = select_objs[-1]
sweep = sweep_objs[-1]
sweep_shape = sweep.Shape
sweep_null = sweep_shape.isNull()
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'selected_count': len(select_objs),
'sweep_count': len(sweep_objs),
'selected_shape_type': selected.Shape.ShapeType,
'selected_valid': selected.Shape.isValid(),
'sweep_null': sweep_null,
'sweep_valid': False if sweep_null else sweep_shape.isValid(),
'sweep_solid_count': 0 if sweep_null else len(sweep_shape.Solids),
'sweep_volume': 0.0 if sweep_null else float(sweep_shape.Volume),
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["selected_count"], 1)
self.assertEqual(result["sweep_count"], 1)
self.assertEqual(result["selected_shape_type"], "Face")
self.assertTrue(result["selected_valid"])
self.assertFalse(result["sweep_null"])
self.assertTrue(result["sweep_valid"])
self.assertEqual(result["sweep_solid_count"], 1)
self.assertGreater(result["sweep_volume"], 0.0)
def test_translate_model_json_bezier_surface_extrudes_with_history(self):
with GraphSession() as session:
profile = scad.make_bezier_surface_rface(
control_points=[
[(0.0, 0.0, 0.0), (0.0, 1.0, 0.0)],
[(1.0, 0.0, 0.0), (1.0, 1.0, 0.0)],
]
)
scad.extrude_rsolid(profile, (0.0, 0.0, 1.0), 2.0)
payload = scad.export_model_json(session)
script = _compile_model_json(payload)
self.assertIn("Part::Extrusion", script)
self.assertNotIn("Unsupported graph operation: make_extrude_rsolid", script)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
profile = next(
obj for obj in doc.Objects
if getattr(obj, 'SimpleCADOp', '') == 'make_bezier_surface_rface'
)
extrusion = next(
obj for obj in doc.Objects
if getattr(obj, 'SimpleCADOp', '') == 'make_extrude_rsolid'
)
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'profile_type': profile.Shape.ShapeType,
'extrusion_type_id': extrusion.TypeId,
'base_name': extrusion.Base.Name,
'solid_count': len(extrusion.Shape.Solids),
'valid': extrusion.Shape.isValid(),
'volume': float(extrusion.Shape.Volume),
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["profile_type"], "Face")
self.assertEqual(result["extrusion_type_id"], "Part::Extrusion")
self.assertTrue(result["base_name"])
self.assertEqual(result["solid_count"], 1)
self.assertTrue(result["valid"])
self.assertAlmostEqual(result["volume"], 2.0, places=6)
def test_translate_model_json_uses_single_result_union_helper(self):
graph = OperationGraph(graph_id="graph_union_single")
a = graph.add_node(
op="make_line_redge",
node_id="edge_a",
params={"start": [0.0, 0.0, 0.0], "end": [1.0, 0.0, 0.0]},
)
b = graph.add_node(
op="make_line_redge",
node_id="edge_b",
params={"start": [0.0, 1.0, 0.0], "end": [1.0, 1.0, 0.0]},
)
graph.add_node(
op="make_union_rsolid",
node_id="union_out",
params={"input_count": 2},
inputs=[a, b],
)
payload = {
"schema_version": "2.0",
"canonical_contract": {"contract_version": "2.0"},
"graph": graph.to_dict(),
"leaf_ids": ["union_out"],
"expression_graph": {"nodes": []},
"frame_graph": {"nodes": []},
"geometry_registry": [],
"semantic_entity_registry": [],
"sketch_profile_registry": [],
"semantic_delta_log": [],
"topology_delta_log": [],
}
script = _compile_model_json(json.dumps(payload))
self.assertIn("Part::Fuse", script)
def test_translate_model_json_chains_multi_tool_cut(self):
graph = OperationGraph(graph_id="graph_cut_multi")
base = graph.add_node(
op="make_line_redge",
node_id="base_obj",
params={"start": [0.0, 0.0, 0.0], "end": [1.0, 0.0, 0.0]},
)
tool_a = graph.add_node(
op="make_line_redge",
node_id="tool_a",
params={"start": [0.0, 1.0, 0.0], "end": [1.0, 1.0, 0.0]},
)
tool_b = graph.add_node(
op="make_line_redge",
node_id="tool_b",
params={"start": [0.0, 2.0, 0.0], "end": [1.0, 2.0, 0.0]},
)
tool_c = graph.add_node(
op="make_line_redge",
node_id="tool_c",
params={"start": [0.0, 3.0, 0.0], "end": [1.0, 3.0, 0.0]},
)
graph.add_node(
op="make_cut_rsolid",
node_id="cut_out",
params={"tool_count": 3},
inputs=[base, tool_a, tool_b, tool_c],
)
payload = {
"schema_version": "2.0",
"canonical_contract": {"contract_version": "2.0"},
"graph": graph.to_dict(),
"leaf_ids": ["cut_out"],
"expression_graph": {"nodes": []},
"frame_graph": {"nodes": []},
"geometry_registry": [],
"semantic_entity_registry": [],
"sketch_profile_registry": [],
"semantic_delta_log": [],
"topology_delta_log": [],
}
script = _compile_model_json(json.dumps(payload))
self.assertNotIn("Part::MultiFuse", script)
self.assertIn("cut_out_step_1 = doc.addObject('Part::Cut'", script)
self.assertIn("cut_out_step_2 = doc.addObject('Part::Cut'", script)
self.assertIn("cut_out = doc.addObject('Part::Cut'", script)
self.assertIn("cut_out.Base = cut_out_step_2", script)
def test_translate_model_json_mixed_curve_sketch_closes_in_fcstd(self):
with GraphSession() as session:
edges = [
scad.make_line_redge((0.0, 0.0, 0.0), (1.0, 0.0, 0.0)),
scad.make_three_point_arc_redge(
(1.0, 0.0, 0.0),
(1.5, 0.5, 0.0),
(1.0, 1.0, 0.0),
),
scad.make_spline_redge(
control_points=[
(1.0, 1.0, 0.0),
(0.6, 1.25, 0.0),
(0.2, 1.15, 0.0),
(0.0, 1.0, 0.0),
]
),
scad.make_line_redge((0.0, 1.0, 0.0), (0.0, 0.0, 0.0)),
]
wire = scad.make_wire_from_edges_rwire(edges)
face = scad.make_face_from_wire_rface(wire)
scad.extrude_rsolid(face, (0.0, 0.0, 1.0), 2.0)
payload = scad.export_model_json(session)
probe = """
import json
import FreeCAD as App
import Part
doc = App.openDocument(FCSTD_PATH)
target = next(
obj for obj in doc.Objects
if getattr(obj, 'SimpleCADOp', '') == 'make_wire_from_edges_rwire'
)
shape = target.Shape
wire = shape.Wires[0]
face = Part.Face(wire)
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'shape_type': shape.ShapeType,
'wire_count': len(shape.Wires),
'edge_count': len(shape.Edges),
'wire_closed': wire.isClosed(),
'wire_valid': wire.isValid(),
'face_valid': face.isValid(),
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["shape_type"], "Wire")
self.assertEqual(result["wire_count"], 1)
self.assertEqual(result["edge_count"], 4)
self.assertTrue(result["wire_closed"])
self.assertTrue(result["wire_valid"])
self.assertTrue(result["face_valid"])
def test_translate_model_json_2d_cut_face_extrudes_hole_fcstd_valid(self):
with GraphSession() as session:
outer = scad.make_circle_rface(center=(0.0, 0.0, 0.0), radius=5.0)
inner = scad.make_circle_rface(center=(0.0, 0.0, 0.0), radius=2.0)
ring_face = scad.make_2d_cut_rface(outer, inner)
scad.extrude_rsolid(ring_face, (0.0, 0.0, 1.0), 3.0)
payload = scad.export_model_json(session)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
cut_faces = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_2d_cut_rface']
extrusions = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_extrude_rsolid']
cut_shape = cut_faces[-1].Shape
solid_shape = extrusions[-1].Shape
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'cut_count': len(cut_faces),
'cut_shape_type': cut_shape.ShapeType,
'cut_face_count': len(cut_shape.Faces),
'cut_wire_count': len(cut_shape.Wires),
'solid_count': len(solid_shape.Solids),
'volume': float(solid_shape.Volume),
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["cut_count"], 1)
self.assertEqual(result["cut_shape_type"], "Face")
self.assertEqual(result["cut_face_count"], 1)
self.assertEqual(result["cut_wire_count"], 2)
self.assertEqual(result["solid_count"], 1)
self.assertAlmostEqual(result["volume"], math.pi * (25.0 - 4.0) * 3.0, places=2)
def test_translate_model_json_multi_loop_face_extrudes_hole_fcstd_valid(self):
with GraphSession() as session:
outer = scad.make_circle_rwire(center=(0.0, 0.0, 0.0), radius=5.0)
inner = scad.make_circle_rwire(center=(0.0, 0.0, 0.0), radius=2.0)
ring_face = scad.make_face_from_wires_rface(outer, [inner])
scad.extrude_rsolid(ring_face, (0.0, 0.0, 1.0), 3.0)
payload = scad.export_model_json(session)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
faces = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_face_from_wires_rface']
extrusions = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_extrude_rsolid']
face_shape = faces[-1].Shape
solid_shape = extrusions[-1].Shape
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'face_count': len(faces),
'face_shape_type': face_shape.ShapeType,
'face_wire_count': len(face_shape.Wires),
'solid_count': len(solid_shape.Solids),
'volume': float(solid_shape.Volume),
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["face_count"], 1)
self.assertEqual(result["face_shape_type"], "Face")
self.assertEqual(result["face_wire_count"], 2)
self.assertEqual(result["solid_count"], 1)
self.assertAlmostEqual(result["volume"], math.pi * (25.0 - 4.0) * 3.0, places=2)
def test_sketch_bspline_boolean_remains_native_part_cut(self):
plane = {
"origin": (0.0, 0.0, -1.0),
"x_axis": (1.0, 0.0, 0.0),
"y_axis": (0.0, 1.0, 0.0),
}
with GraphSession(graph_id="freecad_native_sketch_bspline_cut") as session:
base = scad.make_box_rsolid(12.0, 10.0, 4.0)
sketch = scad.make_sketch_rsketch("bspline_cut_tool", plane=plane)
for point_id, x_value, y_value in (
("p0", -3.0, -1.0),
("p1", 3.0, -1.0),
("p2", 3.0, 1.0),
("p3", -3.0, 1.0),
):
sketch = scad.add_point_rsketch(sketch, point_id, x_value, y_value)
sketch = scad.add_bspline_rsketch(
sketch,
"lower",
"p0",
"p1",
control_points=[
(-3.0, -1.0),
(-1.0, -1.5),
(1.0, -1.5),
(3.0, -1.0),
],
degree=3,
knots=(0.0, 1.0),
multiplicities=(4, 4),
)
sketch = scad.add_line_rsketch(sketch, "right", "p1", "p2")
sketch = scad.add_line_rsketch(sketch, "top", "p2", "p3")
sketch = scad.add_line_rsketch(sketch, "left", "p3", "p0")
face = scad.make_face_from_sketch_rface(sketch, profile="lower")
tool = scad.extrude_rsolid(face, (0.0, 0.0, 1.0), 6.0)
result_solid = scad.cut_rsolid(base, tool, skip_non_intersecting=False)
payload = scad.export_model_json(session)
result_node_id = result_solid.get_metadata("graph")["node_id"]
script = _compile_model_json(payload)
self.assertIn(" = doc.addObject('Part::Cut'", script)
self.assertNotIn(" = _make_baked_exact_boolean(", script)
probe = f"""
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
result = next(
obj for obj in doc.Objects
if getattr(obj, 'SimpleCADNodeId', '') == {result_node_id!r}
)
shape = result.Shape
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({{
'type_id': str(result.TypeId),
'valid': shape.isValid(),
'solid_count': len(shape.Solids),
'face_count': len(shape.Faces),
'volume': float(shape.Volume),
'base_type': str(result.Base.TypeId),
'tool_type': str(result.Tool.TypeId),
}}, fh)
"""
inspected = self._inspect_fcstd_json(payload, probe)
self.assertEqual(inspected["type_id"], "Part::Cut")
self.assertTrue(inspected["valid"])
self.assertEqual(inspected["solid_count"], 1)
self.assertEqual(inspected["face_count"], len(result_solid._iter_faces()))
self.assertAlmostEqual(inspected["volume"], result_solid.get_volume(), places=7)
self.assertEqual(inspected["base_type"], "Part::Box")
self.assertEqual(inspected["tool_type"], "Part::Extrusion")
def test_surface_dependent_boolean_uses_native_part_cut_in_fcstd(self):
with GraphSession(graph_id="freecad_native_surface_cut") as session:
base = scad.make_box_rsolid(12.0, 10.0, 4.0)
lower = scad.make_interpolated_spline_redge(
points=[
(-3.0, -1.0, -1.0),
(0.0, -1.5, -1.0),
(3.0, -1.0, -1.0),
],
tolerance=1.0e-6,
)
upper = scad.make_interpolated_spline_redge(
points=[
(3.0, 1.0, -1.0),
(0.0, 1.5, -1.0),
(-3.0, 1.0, -1.0),
],
tolerance=1.0e-6,
)
wire = scad.make_wire_from_edges_rwire(
edges=[
lower,
scad.make_line_redge((3.0, -1.0, -1.0), (3.0, 1.0, -1.0)),
upper,
scad.make_line_redge((-3.0, 1.0, -1.0), (-3.0, -1.0, -1.0)),
]
)
face = scad.make_face_from_wire_rface(wire)
tool = scad.extrude_rsolid(face, (0.0, 0.0, 1.0), 6.0)
result_solid = scad.cut_rsolid(base, tool, skip_non_intersecting=False)
payload = scad.export_model_json(session)
result_node_id = result_solid.get_metadata("graph")["node_id"]
script = _compile_model_json(payload)
self.assertIn(" = doc.addObject('Part::Cut'", script)
self.assertNotIn("_make_baked_exact_boolean", script)
compile(script, "<native-surface-cut-freecad-script>", "exec")
probe = f"""
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
result = next(
obj for obj in doc.Objects
if getattr(obj, 'SimpleCADNodeId', '') == {result_node_id!r}
)
shape = result.Shape
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({{
'type_id': str(result.TypeId),
'valid': shape.isValid(),
'solid_count': len(shape.Solids),
'face_count': len(shape.Faces),
'volume': float(shape.Volume),
'base_type': str(result.Base.TypeId),
'tool_type': str(result.Tool.TypeId),
}}, fh)
"""
inspected = self._inspect_fcstd_json(payload, probe)
self.assertEqual(inspected["type_id"], "Part::Cut")
self.assertTrue(inspected["valid"])
self.assertEqual(inspected["solid_count"], 1)
self.assertEqual(inspected["face_count"], len(result_solid._iter_faces()))
self.assertAlmostEqual(
inspected["volume"], result_solid.get_volume(), delta=1.0e-3
)
self.assertEqual(inspected["base_type"], "Part::Box")
self.assertEqual(inspected["tool_type"], "Part::Extrusion")
def test_surface_face_emitters_build_valid_fcstd(self):
with GraphSession(graph_id="freecad_surface_faces") as session:
bezier = scad.make_bezier_surface_rface(
[[(0, 0, 0), (0, 2, 0)], [(2, 0, 0), (2, 2, 0.5)]]
)
fitted = scad.fit_point_grid_rface(
[[(4, 0, 0), (4, 2, 0)], [(6, 0, 0), (6, 2, 0.5)]],
degree_min=1,
degree_max=3,
)
ruled = scad.make_ruled_surface_rface(
scad.make_line_redge((8, 0, 0), (10, 0, 0)),
scad.make_line_redge((8, 2, 1), (10, 2, 1)),
)
gordon = scad.make_gordon_surface_rface(
[
scad.make_line_redge((12, 0, 0), (14, 0, 0)),
scad.make_line_redge((12, 2, 1), (14, 2, 1)),
],
[
scad.make_line_redge((12, 0, 0), (12, 2, 1)),
scad.make_line_redge((14, 0, 0), (14, 2, 1)),
],
)
patch_points = [(16, 0, 0), (18, 0, 0), (18, 2, 0), (16, 2, 0)]
patch_edges = [
scad.make_line_redge(patch_points[index], patch_points[(index + 1) % 4])
for index in range(4)
]
patch = scad.make_surface_patch_rface(
[scad.SurfaceBoundary(edge) for edge in patch_edges]
)
session.capture_result(value=[bezier, fitted, ruled, gordon, patch])
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
ops = [
'make_bezier_surface_rface',
'fit_point_grid_rface',
'make_ruled_surface_rface',
'make_gordon_surface_rface',
'make_surface_patch_rface',
]
rows = {}
for op in ops:
obj = next(obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == op)
rows[op] = {
'shape_type': obj.Shape.ShapeType,
'valid': obj.Shape.isValid(),
'face_count': len(obj.Shape.Faces),
'area': float(obj.Shape.Area),
'support': str(getattr(obj, 'SimpleCADTranslationSupport', '')),
}
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump(rows, fh)
"""
inspected = self._inspect_fcstd_json(scad.export_model_json(session), probe)
self.assertEqual(
set(inspected),
{
"make_bezier_surface_rface",
"fit_point_grid_rface",
"make_ruled_surface_rface",
"make_gordon_surface_rface",
"make_surface_patch_rface",
},
)
for row in inspected.values():
self.assertEqual(row["shape_type"], "Face")
self.assertTrue(row["valid"])
self.assertEqual(row["face_count"], 1)
self.assertGreater(row["area"], 0.0)
self.assertEqual(inspected["make_bezier_surface_rface"]["support"], "")
self.assertEqual(inspected["make_ruled_surface_rface"]["support"], "")
for op in (
"fit_point_grid_rface",
"make_gordon_surface_rface",
"make_surface_patch_rface",
):
self.assertEqual(inspected[op]["support"], "emulated")
self.assertAlmostEqual(
inspected["make_surface_patch_rface"]["area"], 4.0, places=7
)
def test_loft_free_boundaries_preserve_output_slots_fcstd(self):
with GraphSession(graph_id="freecad_open_shell_boundaries") as session:
lower = scad.make_circle_rwire(center=(0, 0, 0), radius=2.0)
upper = scad.make_circle_rwire(center=(0, 0, 3), radius=1.0)
shell = scad.loft_rshell([lower, upper])
boundaries = scad.free_boundaries_rwirelist(shell)
session.capture_result(value=[shell, *boundaries])
boundary_node_id = next(
node.node_id
for node in session.graph.nodes
if node.op == "free_boundaries_rwirelist"
)
probe = f"""
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
shell = next(obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_loft_rshell')
boundaries = [
obj for obj in doc.Objects
if getattr(obj, 'SimpleCADNodeId', '') == {boundary_node_id!r}
]
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({{
'shell_type': shell.Shape.ShapeType,
'shell_valid': shell.Shape.isValid(),
'shell_closed': shell.Shape.isClosed(),
'boundary_count': len(boundaries),
'slots': sorted(str(obj.SimpleCADOutputSlot) for obj in boundaries),
'types': [obj.Shape.ShapeType for obj in boundaries],
'valid': [obj.Shape.isValid() for obj in boundaries],
'closed': [obj.Shape.isClosed() for obj in boundaries],
'support': [str(obj.SimpleCADTranslationSupport) for obj in boundaries],
}}, fh)
"""
inspected = self._inspect_fcstd_json(scad.export_model_json(session), probe)
self.assertEqual(inspected["shell_type"], "Shell")
self.assertTrue(inspected["shell_valid"])
self.assertFalse(inspected["shell_closed"])
self.assertEqual(inspected["boundary_count"], 2)
self.assertEqual(inspected["slots"], ["0", "1"])
self.assertEqual(inspected["types"], ["Wire", "Wire"])
self.assertEqual(inspected["valid"], [True, True])
self.assertEqual(inspected["closed"], [True, True])
self.assertEqual(inspected["support"], ["emulated", "emulated"])
def test_fill_holes_and_zero_boundaries_preserve_limitation_fcstd(self):
with GraphSession(graph_id="freecad_closed_shell_boundaries") as session:
lower = scad.make_circle_rwire(center=(0, 0, 0), radius=1.0)
upper = scad.make_circle_rwire(center=(0, 0, 2), radius=1.0)
open_shell = scad.loft_rshell([lower, upper])
filled = scad.fill_holes_rshell(open_shell)
boundaries = scad.free_boundaries_rwirelist(filled)
session.capture_result(value=[filled, *boundaries])
boundary_node_id = next(
node.node_id
for node in session.graph.nodes
if node.op == "free_boundaries_rwirelist"
)
probe = f"""
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
filled = next(obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'fill_holes_rshell')
free_objects = [
obj for obj in doc.Objects
if getattr(obj, 'SimpleCADNodeId', '') == {boundary_node_id!r}
]
note = doc.getObject('simplecad_translation_limitations')
limitations = json.loads(note.Payload)
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({{
'shape_type': filled.Shape.ShapeType,
'valid': filled.Shape.isValid(),
'closed': filled.Shape.isClosed(),
'face_count': len(filled.Shape.Faces),
'support': str(filled.SimpleCADTranslationSupport),
'free_object_count': len(free_objects),
'free_limitation': limitations.get({boundary_node_id!r}),
}}, fh)
"""
inspected = self._inspect_fcstd_json(scad.export_model_json(session), probe)
self.assertEqual(inspected["shape_type"], "Shell")
self.assertTrue(inspected["valid"])
self.assertTrue(inspected["closed"])
self.assertEqual(inspected["face_count"], 3)
self.assertEqual(inspected["support"], "emulated")
self.assertEqual(inspected["free_object_count"], 0)
self.assertEqual(inspected["free_limitation"]["support"], "emulated")
self.assertEqual(
inspected["free_limitation"]["op"], "free_boundaries_rwirelist"
)
def test_translate_model_json_multi_tool_cut_affects_fcstd_result(self):
with GraphSession() as session:
body = scad.make_cylinder_rsolid(10.0, 4.0)
hole = scad.make_cylinder_rsolid(12.0, 0.75)
hole = scad.translate_shape(hole, (2.0, 0.0, -1.0))
hole_b = scad.rotate_shape(hole, 120.0, axis=(0.0, 0.0, 1.0))
hole_c = scad.rotate_shape(hole, 240.0, axis=(0.0, 0.0, 1.0))
scad.cut_rsolid(body, hole, hole_b, hole_c)
payload = scad.export_model_json(session)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
cut_objs = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_cut_rsolid']
final_cut = cut_objs[-1]
shape = final_cut.Shape
tools = doc.getObject('make_cut_rsolid_node_' + final_cut.Name.split('_node_')[-1] + '_tools')
part_cut_objs = [obj for obj in doc.Objects if obj.TypeId == 'Part::Cut']
bad_states = [
obj.Name
for obj in doc.Objects
if any(str(value) in {'Invalid', 'Error'} for value in list(getattr(obj, 'State', []) or []))
]
construction = doc.getObject('SimpleCADConstruction')
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'cut_count': len(cut_objs),
'part_cut_count': len(part_cut_objs),
'final_valid': shape.isValid(),
'solid_count': len(shape.Solids),
'volume': float(shape.Volume),
'has_tools_fuse': tools is not None,
'tool_shape_count': len(getattr(tools, 'Shapes', [])) if tools is not None else 0,
'bad_states': bad_states,
'construction_child_count': len(list(getattr(construction, 'Group', []) or [])) if construction is not None else 0,
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertGreaterEqual(result["cut_count"], 1)
self.assertGreaterEqual(result["part_cut_count"], 3)
self.assertTrue(result["final_valid"])
self.assertEqual(result["solid_count"], 1)
self.assertFalse(result["has_tools_fuse"])
self.assertEqual(result["tool_shape_count"], 0)
self.assertEqual(result["bad_states"], [])
self.assertEqual(result["construction_child_count"], 0)
def test_translate_model_json_applies_rotated_link_operands_in_boolean_fcstd(self):
with GraphSession() as session:
hub = scad.make_cylinder_rsolid(
radius=1.0,
height=1.0,
bottom_face_center=(0.0, 0.0, 0.0),
axis=(0.0, 0.0, 1.0),
)
arm = scad.make_box_rsolid(
width=4.0,
height=0.4,
depth=1.0,
bottom_face_center=(2.0, 0.0, 0.0),
)
arm_b = scad.rotate_shape(
shape=arm,
angle=120.0,
axis=(0.0, 0.0, 1.0),
origin=(0.0, 0.0, 5.0),
)
arm_c = scad.rotate_shape(
shape=arm,
angle=240.0,
axis=(0.0, 0.0, 1.0),
origin=(0.0, 0.0, 5.0),
)
scad.union_rsolid([hub, arm, arm_b, arm_c], glue=False)
payload = scad.export_model_json(session)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
union_objs = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_union_rsolid']
final_union = union_objs[-1]
shape = final_union.Shape
bb = shape.BoundBox
materialized = [obj for obj in doc.Objects if hasattr(obj, 'SimpleCADMaterializedFromLink')]
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'solid_count': len(shape.Solids),
'volume': float(shape.Volume),
'bbox': [float(bb.XMin), float(bb.XMax), float(bb.YMin), float(bb.YMax), float(bb.ZMin), float(bb.ZMax)],
'materialized_count': len(materialized),
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["solid_count"], 1)
self.assertLess(result["bbox"][2], -3.0)
self.assertGreater(result["bbox"][3], 3.0)
self.assertAlmostEqual(result["bbox"][4], 0.0, places=6)
self.assertAlmostEqual(result["bbox"][5], 1.0, places=6)
self.assertGreaterEqual(result["materialized_count"], 2)
def test_translate_model_json_emits_native_loft_feature(self):
with GraphSession() as session:
base = scad.make_rectangle_rwire(2.0, 2.0, center=(0.0, 0.0, 0.0))
top = scad.make_rectangle_rwire(1.0, 1.0, center=(0.0, 0.0, 3.0))
scad.loft_rsolid([base, top], ruled=True)
payload_obj = self._expression_payload(scad.export_model_json(session))
payload_obj["expression_graph"]["nodes"] = [
{"expr_id": "var_ruled", "kind": "var", "name": "ruled", "default": 1.0}
]
for node in payload_obj["graph"]["nodes"]:
if node["op"] == "make_loft_rsolid":
node["param_exprs"] = {"ruled": {"expr_id": "var_ruled"}}
script = _compile_model_json(json.dumps(payload_obj))
self.assertIn("Part::Loft", script)
self.assertIn(".Sections = [GRAPH_NODES", script)
self.assertIn(".Ruled = bool(", script)
self.assertIn("'Ruled'", script)
def test_translate_model_json_binds_feature_properties_to_freecad_expressions(self):
with GraphSession() as session:
helix = scad.make_helix_rwire(1.0, 3.0, 2.0)
extrude_face = scad.make_rectangle_rface(width=2.0, height=1.0)
scad.extrude_rsolid(
profile=extrude_face,
direction=(0.0, 0.0, 1.0),
distance=2.0,
)
rev_wire = scad.make_rectangle_rwire(1.0, 2.0, center=(2.0, 0.0, 0.0))
rev_face = scad.make_face_from_wire_rface(rev_wire)
scad.revolve_rsolid(rev_face, axis=(0.0, 0.0, 1.0), angle=180.0)
sweep_face = scad.make_circle_rface((0.0, 0.0, 0.0), 1.0)
scad.sweep_rsolid(sweep_face, helix, is_frenet=True)
box = scad.make_box_rsolid(2.0, 2.0, 2.0)
scad.shell_rsolid(box, [box.get_faces(0)], 0.25)
payload = scad.export_model_json(session)
payload_obj = self._expression_payload(payload)
payload_obj["expression_graph"]["nodes"] = [
{"expr_id": "var_pitch", "kind": "var", "name": "pitch", "default": 1.0},
{"expr_id": "var_radius", "kind": "var", "name": "radius", "default": 2.0},
{"expr_id": "var_angle", "kind": "var", "name": "angle", "default": 180.0},
{"expr_id": "var_frenet", "kind": "var", "name": "frenet", "default": 1.0},
{
"expr_id": "var_thickness",
"kind": "var",
"name": "thickness",
"default": 0.25,
},
]
graph_nodes = payload_obj["graph"]["nodes"]
for node in graph_nodes:
if node["op"] == "make_helix_redge":
node["param_exprs"] = {
"pitch": {"expr_id": "var_pitch"},
"radius": {"expr_id": "var_radius"},
}
elif node["op"] == "make_extrude_rsolid":
node["param_exprs"] = {"distance": {"expr_id": "var_radius"}}
elif node["op"] == "make_revolve_rsolid":
node["param_exprs"] = {"angle": {"expr_id": "var_angle"}}
elif node["op"] == "make_sweep_rsolid":
node["param_exprs"] = {"is_frenet": {"expr_id": "var_frenet"}}
elif node["op"] == "make_shell_rsolid":
node["param_exprs"] = {"thickness": {"expr_id": "var_thickness"}}
expr_aliases = {
(
node["name"] if node.get("kind") == "var" else node.get("op")
): self._expr_alias(node["expr_id"])
for node in payload_obj["expression_graph"]["nodes"]
if isinstance(node, dict) and node.get("expr_id")
}
payload = json.dumps(payload_obj)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
targets = {
'Part::Extrusion': ['LengthFwd'],
'Part::Revolution': ['Angle'],
'Part::Helix': ['Pitch', 'Radius'],
'Part::Sweep': ['Frenet'],
'Part::Thickness': ['Value'],
}
result = {}
for obj in doc.Objects:
props = targets.get(getattr(obj, 'TypeId', ''))
if not props:
continue
result[obj.TypeId] = list(getattr(obj, 'ExpressionEngine', []))
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump(result, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertIn(
["LengthFwd", f"<<SimpleCADExpressions>>.{expr_aliases['radius']}"],
result["Part::Extrusion"],
)
self.assertIn(
["Angle", f"<<SimpleCADExpressions>>.{expr_aliases['angle']}"],
result["Part::Revolution"],
)
self.assertIn(
["Pitch", f"<<SimpleCADExpressions>>.{expr_aliases['pitch']}"],
result["Part::Helix"],
)
self.assertIn(
["Radius", f"<<SimpleCADExpressions>>.{expr_aliases['radius']}"],
result["Part::Helix"],
)
self.assertIn(
["Frenet", f"<<SimpleCADExpressions>>.{expr_aliases['frenet']}"],
result["Part::Sweep"],
)
self.assertIn(
["Value", f"<<SimpleCADExpressions>>.{expr_aliases['thickness']}"],
result["Part::Thickness"],
)
def test_translate_model_json_binds_transform_and_detail_expressions(self):
with GraphSession() as session:
box = scad.make_box_rsolid(2.0, 2.0, 2.0)
scad.translate_shape(box, (1.0, 2.0, 3.0))
scad.rotate_shape(box, 30.0, axis=(0.0, 0.0, 1.0), origin=(1.0, 0.0, 0.0))
scad.mirror_shape(
box, plane_origin=(0.0, 0.0, 0.0), plane_normal=(0.0, 0.0, 1.0)
)
scad.fillet_rsolid(box, [box.get_edges(0)], 0.2)
scad.chamfer_rsolid(box, [box.get_edges(0)], 0.3)
payload_obj = self._expression_payload(scad.export_model_json(session))
payload_obj["expression_graph"]["nodes"] = [
{"expr_id": "var_tx", "kind": "var", "name": "tx", "default": 1.0},
{"expr_id": "var_ty", "kind": "var", "name": "ty", "default": 2.0},
{"expr_id": "var_tz", "kind": "var", "name": "tz", "default": 3.0},
{"expr_id": "var_angle", "kind": "var", "name": "angle", "default": 30.0},
{"expr_id": "var_ox", "kind": "var", "name": "ox", "default": 1.0},
{"expr_id": "var_nz", "kind": "var", "name": "nz", "default": 1.0},
{"expr_id": "var_fillet", "kind": "var", "name": "fillet", "default": 0.2},
{
"expr_id": "var_chamfer",
"kind": "var",
"name": "chamfer",
"default": 0.3,
},
]
for node in payload_obj["graph"]["nodes"]:
if node["op"] == "make_translate_rshape":
node["param_exprs"] = {
"vector": [
{"expr_id": "var_tx"},
{"expr_id": "var_ty"},
{"expr_id": "var_tz"},
]
}
elif node["op"] == "make_rotate_rshape":
node["param_exprs"] = {
"origin": [{"expr_id": "var_ox"}, None, None],
"axis": [None, None, {"expr_id": "var_nz"}],
"angle": {"expr_id": "var_angle"},
}
elif node["op"] == "make_mirror_rshape":
node["param_exprs"] = {
"plane_origin": [{"expr_id": "var_ox"}, None, None],
"plane_normal": [None, None, {"expr_id": "var_nz"}],
}
elif node["op"] == "make_fillet_rsolid":
node["param_exprs"] = {"radius": {"expr_id": "var_fillet"}}
elif node["op"] == "make_chamfer_rsolid":
node["param_exprs"] = {"distance": {"expr_id": "var_chamfer"}}
expr_aliases = {
node["name"]: self._expr_alias(node["expr_id"])
for node in payload_obj["expression_graph"]["nodes"]
}
payload = json.dumps(payload_obj)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
result = {}
for obj in doc.Objects:
if getattr(obj, 'TypeId', '') in {'App::Link', 'Part::Mirroring', 'Part::Fillet', 'Part::Chamfer'}:
result.setdefault(obj.TypeId, []).append(list(getattr(obj, 'ExpressionEngine', [])))
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump(result, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
link_engines = [item for group in result["App::Link"] for item in group]
mirror_engines = [item for group in result["Part::Mirroring"] for item in group]
fillet_engines = [item for group in result["Part::Fillet"] for item in group]
chamfer_engines = [item for group in result["Part::Chamfer"] for item in group]
self.assertIn(
[".Placement.Base.x", f"<<SimpleCADExpressions>>.{expr_aliases['tx']}"],
link_engines,
)
self.assertIn(
[".Placement.Base.y", f"<<SimpleCADExpressions>>.{expr_aliases['ty']}"],
link_engines,
)
self.assertIn(
[".Placement.Base.z", f"<<SimpleCADExpressions>>.{expr_aliases['tz']}"],
link_engines,
)
self.assertIn(
[
".Placement.Rotation.Angle",
f"<<SimpleCADExpressions>>.{expr_aliases['angle']}",
],
link_engines,
)
self.assertIn(
[".Base.x", f"<<SimpleCADExpressions>>.{expr_aliases['ox']}"],
mirror_engines,
)
self.assertIn(
[".Normal.z", f"<<SimpleCADExpressions>>.{expr_aliases['nz']}"],
mirror_engines,
)
self.assertIn(
["Edges[0]", f"<<SimpleCADExpressions>>.{expr_aliases['fillet']}"],
fillet_engines,
)
self.assertIn(
["Edges[0]", f"<<SimpleCADExpressions>>.{expr_aliases['chamfer']}"],
chamfer_engines,
)
def test_translate_model_json_binds_sketch_primitive_expressions(self):
graph = OperationGraph(graph_id="graph_sketch_exprs")
line = graph.add_node(
op="make_line_redge",
node_id="line_expr",
params={"start": [0.0, 0.0, 0.0], "end": [1.0, 0.0, 0.0]},
param_exprs={
"start": [{"expr_id": "var_lsx"}, {"expr_id": "var_lsy"}, None],
"end": [{"expr_id": "var_lex"}, {"expr_id": "var_ley"}, None],
},
)
circle = graph.add_node(
op="make_circle_redge",
node_id="circle_expr",
params={"center": [2.0, 3.0, 0.0], "radius": 4.0},
param_exprs={
"center": [
{"expr_id": "var_cx"},
{"expr_id": "var_cy"},
{"expr_id": "var_cz"},
],
"radius": {"expr_id": "var_cr"},
},
)
wire_line = graph.add_node(
op="make_wire_from_edges_rwire",
node_id="wire_line",
params={"edge_count": 1},
inputs=[line],
)
face_circle = graph.add_node(
op="make_face_from_wire_rface",
node_id="face_circle",
params={"edge_count": 1},
inputs=[
graph.add_node(
op="make_wire_from_edges_rwire",
node_id="wire_circle",
params={"edge_count": 1},
inputs=[circle],
)
],
)
payload = {
"schema_version": "2.0",
"canonical_contract": {"contract_version": "2.0"},
"graph": graph.to_dict(),
"leaf_ids": [wire_line.node_id, face_circle.node_id],
"expression_graph": {
"nodes": [
{
"expr_id": "var_lsx",
"kind": "var",
"name": "lsx",
"default": 0.0,
},
{
"expr_id": "var_lsy",
"kind": "var",
"name": "lsy",
"default": 0.0,
},
{
"expr_id": "var_lex",
"kind": "var",
"name": "lex",
"default": 1.0,
},
{
"expr_id": "var_ley",
"kind": "var",
"name": "ley",
"default": 0.0,
},
{"expr_id": "var_cx", "kind": "var", "name": "cx", "default": 2.0},
{"expr_id": "var_cy", "kind": "var", "name": "cy", "default": 3.0},
{"expr_id": "var_cz", "kind": "var", "name": "cz", "default": 0.0},
{"expr_id": "var_cr", "kind": "var", "name": "cr", "default": 4.0},
]
},
"frame_graph": {"nodes": []},
"geometry_registry": [],
"semantic_entity_registry": [],
"sketch_profile_registry": [],
"semantic_delta_log": [],
"topology_delta_log": [],
}
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
result = {}
for obj in doc.Objects:
if getattr(obj, 'TypeId', '') == 'Sketcher::SketchObject':
result[obj.Name] = list(getattr(obj, 'ExpressionEngine', []))
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump(result, fh)
"""
result = self._inspect_fcstd_json(json.dumps(payload), probe)
all_entries = [entry for entries in result.values() for entry in entries]
self.assertTrue(all_entries)
self.assertIn(
[".Placement.Base.x", "<<SimpleCADExpressions>>.var_lsx"],
all_entries,
)
self.assertIn(
[
"Constraints[0]",
"sqrt(pow(<<SimpleCADExpressions>>.var_lex - <<SimpleCADExpressions>>.var_lsx; 2) + pow(<<SimpleCADExpressions>>.var_ley - <<SimpleCADExpressions>>.var_lsy; 2) + pow(0 - 0; 2))",
],
all_entries,
)
self.assertIn(
[
"Constraints[1]",
"<<SimpleCADExpressions>>.var_lex - <<SimpleCADExpressions>>.var_lsx",
],
all_entries,
)
self.assertIn(
[
"Constraints[2]",
"<<SimpleCADExpressions>>.var_ley - <<SimpleCADExpressions>>.var_lsy",
],
all_entries,
)
self.assertIn(
[
"Geometry[0].EndPoint.x",
"sqrt(pow(<<SimpleCADExpressions>>.var_lex - <<SimpleCADExpressions>>.var_lsx; 2) + pow(<<SimpleCADExpressions>>.var_ley - <<SimpleCADExpressions>>.var_lsy; 2) + pow(0 - 0; 2))",
],
all_entries,
)
self.assertIn(
[".Placement.Base.x", "<<SimpleCADExpressions>>.var_cx"], all_entries
)
self.assertIn(
["Constraints[0]", "2 * <<SimpleCADExpressions>>.var_cr"], all_entries
)
def test_translate_model_json_binds_mixed_sketch_arc_radius_expressions(self):
graph = OperationGraph(graph_id="graph_mixed_arc_expr")
line = graph.add_node(
op="make_line_redge",
node_id="line_expr",
params={"start": [0.0, 0.0, 0.0], "end": [1.0, 0.0, 0.0]},
)
arc = graph.add_node(
op="make_angle_arc_redge",
node_id="arc_expr",
params={
"center": [1.0, 1.0, 0.0],
"radius": 1.0,
"start_angle": -1.5707963267948966,
"end_angle": 0.0,
},
param_exprs={"radius": {"expr_id": "var_r"}},
)
wire = graph.add_node(
op="make_wire_from_edges_rwire",
node_id="wire_expr",
params={"edge_count": 2},
inputs=[line, arc],
)
payload = {
"schema_version": "2.0",
"canonical_contract": {"contract_version": "2.0"},
"graph": graph.to_dict(),
"leaf_ids": [wire.node_id],
"expression_graph": {
"nodes": [
{"expr_id": "var_r", "kind": "var", "name": "r", "default": 1.0}
]
},
"frame_graph": {"nodes": []},
"geometry_registry": [],
"semantic_entity_registry": [],
"sketch_profile_registry": [],
"semantic_delta_log": [],
"topology_delta_log": [],
}
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
result = {}
for obj in doc.Objects:
if getattr(obj, 'TypeId', '') == 'Sketcher::SketchObject':
result[obj.Name] = list(getattr(obj, 'ExpressionEngine', []))
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump(result, fh)
"""
result = self._inspect_fcstd_json(json.dumps(payload), probe)
all_entries = [entry for entries in result.values() for entry in entries]
self.assertIn(
["Geometry[1].Radius", "<<SimpleCADExpressions>>.var_r"], all_entries
)
def test_translate_model_json_binds_mixed_sketch_angle_arc_endpoint_expressions(
self,
):
graph = OperationGraph(graph_id="graph_mixed_angle_arc_expr")
line = graph.add_node(
op="make_line_redge",
node_id="line_expr",
params={"start": [0.0, 0.0, 0.0], "end": [2.0, 0.0, 0.0]},
)
arc = graph.add_node(
op="make_angle_arc_redge",
node_id="arc_expr",
params={
"center": [2.0, 2.0, 0.0],
"radius": 2.0,
"start_angle": -1.5707963267948966,
"end_angle": 0.0,
"normal": [0.0, 0.0, 1.0],
},
param_exprs={
"center": [{"expr_id": "var_cx"}, {"expr_id": "var_cy"}, None],
"radius": {"expr_id": "var_r"},
"start_angle": {"expr_id": "var_a0"},
"end_angle": {"expr_id": "var_a1"},
},
)
wire = graph.add_node(
op="make_wire_from_edges_rwire",
node_id="wire_expr",
params={"edge_count": 2},
inputs=[line, arc],
)
payload = {
"schema_version": "2.0",
"canonical_contract": {"contract_version": "2.0"},
"graph": graph.to_dict(),
"leaf_ids": [wire.node_id],
"expression_graph": {
"nodes": [
{"expr_id": "var_cx", "kind": "var", "name": "cx", "default": 2.0},
{"expr_id": "var_cy", "kind": "var", "name": "cy", "default": 2.0},
{"expr_id": "var_r", "kind": "var", "name": "r", "default": 2.0},
{
"expr_id": "var_a0",
"kind": "var",
"name": "a0",
"default": -1.5707963267948966,
},
{"expr_id": "var_a1", "kind": "var", "name": "a1", "default": 0.0},
]
},
"frame_graph": {"nodes": []},
"geometry_registry": [],
"semantic_entity_registry": [],
"sketch_profile_registry": [],
"semantic_delta_log": [],
"topology_delta_log": [],
}
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
result = {}
for obj in doc.Objects:
if getattr(obj, 'TypeId', '') == 'Sketcher::SketchObject':
result[obj.Name] = list(getattr(obj, 'ExpressionEngine', []))
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump(result, fh)
"""
result = self._inspect_fcstd_json(json.dumps(payload), probe)
expr_map = {prop: expr for entries in result.values() for prop, expr in entries}
self.assertIn("Geometry[1].Center.x", expr_map)
self.assertIn("Geometry[1].Center.y", expr_map)
self.assertIn("Geometry[1].Radius", expr_map)
self.assertIn("Geometry[1].StartPoint.x", expr_map)
self.assertIn("Geometry[1].StartPoint.y", expr_map)
self.assertIn("Geometry[1].EndPoint.x", expr_map)
self.assertIn("Geometry[1].EndPoint.y", expr_map)
self.assertIn("<<SimpleCADExpressions>>.var_r", expr_map["Geometry[1].Radius"])
radius_constraint = next(
expr
for prop, expr in expr_map.items()
if prop.startswith("Constraints[")
and expr == "<<SimpleCADExpressions>>.var_r"
)
angle_constraint = next(
expr
for prop, expr in expr_map.items()
if prop.startswith("Constraints[")
and "<<SimpleCADExpressions>>.var_a1" in expr
and "<<SimpleCADExpressions>>.var_a0" in expr
)
self.assertEqual(radius_constraint, "<<SimpleCADExpressions>>.var_r")
self.assertIn("<<SimpleCADExpressions>>.var_a1", angle_constraint)
self.assertIn("<<SimpleCADExpressions>>.var_a0", angle_constraint)
self.assertIn(
"<<SimpleCADExpressions>>.var_a0", expr_map["Geometry[1].StartPoint.x"]
)
self.assertIn(
"<<SimpleCADExpressions>>.var_a0", expr_map["Geometry[1].StartPoint.y"]
)
self.assertIn(
"<<SimpleCADExpressions>>.var_a1", expr_map["Geometry[1].EndPoint.x"]
)
self.assertIn(
"<<SimpleCADExpressions>>.var_a1", expr_map["Geometry[1].EndPoint.y"]
)
self.assertTrue(
any(
token in expr_map["Geometry[1].StartPoint.x"]
for token in ("sin(", "cos(")
)
)
self.assertTrue(
any(
token in expr_map["Geometry[1].StartPoint.y"]
for token in ("sin(", "cos(")
)
)
self.assertTrue(
any(
token in expr_map["Geometry[1].EndPoint.x"]
for token in ("sin(", "cos(")
)
)
self.assertTrue(
any(
token in expr_map["Geometry[1].EndPoint.y"]
for token in ("sin(", "cos(")
)
)
def test_translate_model_json_exports_single_angle_arc_sketch_with_endpoint_expressions(
self,
):
graph = OperationGraph(graph_id="graph_single_angle_arc_expr")
arc = graph.add_node(
op="make_angle_arc_redge",
node_id="arc_expr",
params={
"center": [0.0, 0.0, 0.0],
"radius": 2.0,
"start_angle": 0.0,
"end_angle": 1.5707963267948966,
"normal": [0.0, 0.0, 1.0],
},
param_exprs={
"center": [{"expr_id": "var_cx"}, {"expr_id": "var_cy"}, None],
"radius": {"expr_id": "var_r"},
"start_angle": {"expr_id": "var_a0"},
"end_angle": {"expr_id": "var_a1"},
},
)
wire = graph.add_node(
op="make_wire_from_edges_rwire",
node_id="wire_expr",
params={"edge_count": 1},
inputs=[arc],
)
payload = {
"schema_version": "2.0",
"canonical_contract": {"contract_version": "2.0"},
"graph": graph.to_dict(),
"leaf_ids": [wire.node_id],
"expression_graph": {
"nodes": [
{"expr_id": "var_cx", "kind": "var", "name": "cx", "default": 0.0},
{"expr_id": "var_cy", "kind": "var", "name": "cy", "default": 0.0},
{"expr_id": "var_r", "kind": "var", "name": "r", "default": 2.0},
{"expr_id": "var_a0", "kind": "var", "name": "a0", "default": 0.0},
{
"expr_id": "var_a1",
"kind": "var",
"name": "a1",
"default": 1.5707963267948966,
},
]
},
"frame_graph": {"nodes": []},
"geometry_registry": [],
"semantic_entity_registry": [],
"sketch_profile_registry": [],
"semantic_delta_log": [],
"topology_delta_log": [],
}
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
sketches = [obj for obj in doc.Objects if getattr(obj, 'TypeId', '') == 'Sketcher::SketchObject']
target = sketches[0]
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'sketch_count': len(sketches),
'exprs': list(getattr(target, 'ExpressionEngine', [])),
'geom_count': len(list(getattr(target, 'Geometry', []))),
'shape_type': target.Shape.ShapeType,
'edge_count': len(target.Shape.Edges),
}, fh)
"""
result = self._inspect_fcstd_json(json.dumps(payload), probe)
self.assertEqual(result["sketch_count"], 1)
self.assertEqual(result["geom_count"], 1)
self.assertEqual(result["shape_type"], "Wire")
self.assertEqual(result["edge_count"], 1)
expr_map = {prop: expr for prop, expr in result["exprs"]}
self.assertIn("Geometry[0].Center.x", expr_map)
self.assertIn("Geometry[0].Center.y", expr_map)
self.assertIn("Geometry[0].Radius", expr_map)
self.assertIn("Geometry[0].StartPoint.x", expr_map)
self.assertIn("Geometry[0].StartPoint.y", expr_map)
self.assertIn("Geometry[0].EndPoint.x", expr_map)
self.assertIn("Geometry[0].EndPoint.y", expr_map)
self.assertEqual(
expr_map["Geometry[0].Radius"], "<<SimpleCADExpressions>>.var_r"
)
self.assertIn(
"<<SimpleCADExpressions>>.var_a0", expr_map["Geometry[0].StartPoint.x"]
)
self.assertIn(
"<<SimpleCADExpressions>>.var_a0", expr_map["Geometry[0].StartPoint.y"]
)
self.assertIn(
"<<SimpleCADExpressions>>.var_a1", expr_map["Geometry[0].EndPoint.x"]
)
self.assertIn(
"<<SimpleCADExpressions>>.var_a1", expr_map["Geometry[0].EndPoint.y"]
)
def test_translate_model_json_marks_spline_expression_mapping_as_unsupported(
self,
):
graph = OperationGraph(graph_id="graph_spline_expr_limit")
spline = graph.add_node(
op="make_spline_redge",
node_id="spline_expr",
params={
"control_points": [
[0.0, 0.0, 0.0],
[0.6, 1.0, 0.0],
[1.4, 1.0, 0.0],
[2.0, 0.0, 0.0],
],
"degree": 3,
"knots": [0.0, 1.0],
"multiplicities": [4, 4],
"weights": None,
"periodic": False,
},
param_exprs={
"control_points": [
[None, None, None],
[None, {"expr_id": "var_sy"}, None],
[None, {"expr_id": "var_sy"}, None],
[None, None, None],
]
},
)
wire = graph.add_node(
op="make_wire_from_edges_rwire",
node_id="wire_expr",
params={"edge_count": 1},
inputs=[spline],
)
payload = {
"schema_version": "2.0",
"canonical_contract": {"contract_version": "2.0"},
"graph": graph.to_dict(),
"leaf_ids": [wire.node_id],
"expression_graph": {
"nodes": [
{"expr_id": "var_sy", "kind": "var", "name": "sy", "default": 1.0}
]
},
"frame_graph": {"nodes": []},
"geometry_registry": [],
"semantic_entity_registry": [],
"sketch_profile_registry": [],
"semantic_delta_log": [],
"topology_delta_log": [],
}
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
sketch = next(obj for obj in doc.Objects if getattr(obj, 'TypeId', '') == 'Sketcher::SketchObject')
note = doc.getObject('simplecad_expression_limitations')
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'exprs': list(getattr(sketch, 'ExpressionEngine', [])),
'expr_support': getattr(sketch, 'SimpleCADExprSupport', ''),
'expr_limitation': getattr(sketch, 'SimpleCADExprLimitation', ''),
'note_payload': getattr(note, 'Payload', '') if note is not None else '',
'geom_count': len(list(getattr(sketch, 'Geometry', []))),
'edge_count': len(sketch.Shape.Edges),
}, fh)
"""
result = self._inspect_fcstd_json(json.dumps(payload), probe)
self.assertEqual(result["geom_count"], 1)
self.assertEqual(result["edge_count"], 1)
self.assertEqual(result["exprs"], [])
self.assertEqual(result["expr_support"], "limited")
self.assertIn(
"make_spline_redge",
result["expr_limitation"],
)
self.assertIn(
"no stable equivalent native FreeCAD Sketcher BSpline parameter host",
result["expr_limitation"],
)
payload_obj = json.loads(result["note_payload"])
self.assertIn("spline_expr", payload_obj)
self.assertEqual(payload_obj["spline_expr"]["op"], "make_spline_redge")
self.assertIn(
"no stable equivalent native FreeCAD Sketcher BSpline parameter host",
payload_obj["spline_expr"]["reason"],
)
def test_translate_model_json_adds_coincident_constraints_for_polyline_wire(self):
graph = OperationGraph(graph_id="graph_polyline_constraints")
e1 = graph.add_node(
op="make_line_redge",
node_id="e1",
params={"start": [0.0, 0.0, 0.0], "end": [1.0, 0.0, 0.0]},
param_exprs={"end": [{"expr_id": "var_x"}, None, None]},
)
e2 = graph.add_node(
op="make_line_redge",
node_id="e2",
params={"start": [1.0, 0.0, 0.0], "end": [1.0, 1.0, 0.0]},
)
e3 = graph.add_node(
op="make_line_redge",
node_id="e3",
params={"start": [1.0, 1.0, 0.0], "end": [0.0, 0.0, 0.0]},
)
wire = graph.add_node(
op="make_wire_from_edges_rwire",
node_id="wire",
params={"edge_count": 3},
inputs=[e1, e2, e3],
)
payload = {
"schema_version": "2.0",
"canonical_contract": {"contract_version": "2.0"},
"graph": graph.to_dict(),
"leaf_ids": [wire.node_id],
"expression_graph": {
"nodes": [
{
"expr_id": "var_x",
"kind": "var",
"name": "x",
"default": 1.0,
}
]
},
"frame_graph": {"nodes": []},
"geometry_registry": [],
"semantic_entity_registry": [],
"sketch_profile_registry": [],
"semantic_delta_log": [],
"topology_delta_log": [],
}
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
sketch = next(obj for obj in doc.Objects if getattr(obj, 'TypeId', '') == 'Sketcher::SketchObject')
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'constraints': [str(c) for c in sketch.Constraints],
'constraint_count': len(sketch.Constraints),
}, fh)
"""
result = self._inspect_fcstd_json(json.dumps(payload), probe)
self.assertGreaterEqual(result["constraint_count"], 3)
self.assertGreaterEqual(
sum(1 for item in result["constraints"] if "Coincident" in item), 3
)
def _functional_rectangle_sketch_model_json(self) -> str:
width = scad.var("fcstd_sketch_width", 2.0)
height = scad.var("fcstd_sketch_height", 1.0)
thickness = scad.var("fcstd_sketch_thickness", 0.5)
with GraphSession() as session:
sketch = scad.make_sketch_rsketch("fcstd_rect")
sketch = scad.add_point_rsketch(sketch, "p0", 0.0, 0.0)
sketch = scad.add_point_rsketch(sketch, "p1", width, 0.0)
sketch = scad.add_point_rsketch(sketch, "p2", width, height)
sketch = scad.add_point_rsketch(sketch, "p3", 0.0, height)
sketch = scad.add_line_rsketch(sketch, "bottom", "p0", "p1")
sketch = scad.add_line_rsketch(sketch, "right", "p1", "p2")
sketch = scad.add_line_rsketch(sketch, "top", "p2", "p3")
sketch = scad.add_line_rsketch(sketch, "left", "p3", "p0")
sketch = scad.constrain_fix_rsketch(sketch, "p0")
sketch = scad.constrain_horizontal_rsketch(sketch, "bottom")
sketch = scad.constrain_vertical_rsketch(sketch, "right")
sketch = scad.constrain_parallel_rsketch(sketch, "bottom", "top")
sketch = scad.constrain_parallel_rsketch(sketch, "left", "right")
sketch = scad.constrain_perpendicular_rsketch(sketch, "bottom", "right")
sketch = scad.constrain_distance_rsketch(sketch, "p0", "p1", width)
sketch = scad.constrain_distance_rsketch(sketch, "p0", "p3", height)
face = scad.make_face_from_sketch_rface(
sketch,
require_fully_constrained=True,
)
scad.extrude_rsolid(face, (0.0, 0.0, 1.0), thickness)
return scad.export_model_json(session)
def test_translate_model_json_supports_functional_sketch_promotion_script(self):
payload = self._functional_rectangle_sketch_model_json()
script = _compile_model_json(payload)
self.assertIn("_make_sketch_promotion_object", script)
self.assertIn("make_face_from_sketch_rface", script)
self.assertIn("add_point_rsketch", script)
self.assertIn("make_constrain_distance_rsketch", script)
self.assertIn("SimpleCADSketchSolve", script)
self.assertIn("SimpleCADSketchConstraints", script)
self.assertIn("Part::Extrusion", script)
self.assertNotIn("make_solve_sketch_rsketchresult", script)
def test_translate_model_json_functional_sketch_promotion_fcstd_valid(self):
payload = self._functional_rectangle_sketch_model_json()
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
op_objects = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_face_from_sketch_rface']
sketches = [obj for obj in doc.Objects if getattr(obj, 'TypeId', '') == 'Sketcher::SketchObject' and getattr(obj, 'SimpleCADOp', '') == 'make_face_from_sketch_rface']
bridge_features = [obj for obj in doc.Objects if getattr(obj, 'TypeId', '') == 'Part::Feature' and getattr(obj, 'SimpleCADOp', '') == 'make_face_from_sketch_rface']
extrusions = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_extrude_rsolid']
sketch = sketches[-1]
extrusion = extrusions[-1]
solve = json.loads(sketch.SimpleCADSketchSolve)
constraint_status = json.loads(sketch.SimpleCADSketchConstraints)
exprs = list(getattr(sketch, 'ExpressionEngine', []))
shape = extrusion.Shape
base = extrusion.Base
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'op_object_count': len(op_objects),
'sketch_count': len(sketches),
'bridge_feature_count': len(bridge_features),
'extrusion_count': len(extrusions),
'extrusion_base_name': getattr(base, 'Name', ''),
'extrusion_base_type': getattr(base, 'TypeId', ''),
'sketch_name': sketch.Name,
'geom_count': len(list(sketch.Geometry)),
'constraint_count': len(sketch.Constraints),
'mapped_count': len(constraint_status.get('mapped', [])),
'skipped_count': len(constraint_status.get('skipped', [])),
'solve_status': solve.get('status'),
'solve_dof': int(solve.get('dof', -1)),
'exprs': exprs,
'solid_count': 0 if shape.isNull() else len(shape.Solids),
'volume': 0.0 if shape.isNull() else float(shape.Volume),
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["op_object_count"], 1)
self.assertEqual(result["sketch_count"], 1)
self.assertEqual(result["bridge_feature_count"], 0)
self.assertEqual(result["extrusion_count"], 1)
self.assertEqual(result["extrusion_base_name"], result["sketch_name"])
self.assertEqual(result["extrusion_base_type"], "Sketcher::SketchObject")
self.assertEqual(result["geom_count"], 4)
self.assertGreaterEqual(result["constraint_count"], 10)
self.assertEqual(result["mapped_count"], result["constraint_count"])
self.assertGreaterEqual(result["mapped_count"] + result["skipped_count"], 13)
self.assertEqual(result["solve_status"], "solved")
self.assertEqual(result["solve_dof"], 0)
self.assertEqual(result["solid_count"], 1)
self.assertAlmostEqual(result["volume"], 1.0, places=6)
expr_map = {prop: expr for prop, expr in result["exprs"]}
self.assertTrue(
any(
prop.startswith("Constraints[") and "var_fcstd_sketch_width" in expr
for prop, expr in expr_map.items()
)
)
self.assertTrue(
any(
prop.startswith("Constraints[") and "var_fcstd_sketch_height" in expr
for prop, expr in expr_map.items()
)
)
def test_translate_model_json_large_sketch_promotion_fcstd_stays_sketcher_object(
self,
):
segment_count = 60
radius = 5.0
with GraphSession() as session:
sketch = scad.make_sketch_rsketch("large_fcstd_profile")
for idx in range(segment_count):
angle = 2.0 * math.pi * idx / segment_count
sketch = scad.add_point_rsketch(
sketch,
f"p{idx}",
radius * math.cos(angle),
radius * math.sin(angle),
)
for idx in range(segment_count):
sketch = scad.add_line_rsketch(
sketch,
f"l{idx}",
f"p{idx}",
f"p{(idx + 1) % segment_count}",
)
face = scad.make_face_from_sketch_rface(sketch)
scad.extrude_rsolid(face, (0.0, 0.0, 1.0), 0.5)
payload = scad.export_model_json(session)
script = _compile_model_json(payload)
self.assertNotIn("Large sketch (>50 entities)", script)
self.assertNotIn("materialised as Part::Feature for performance", script)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
sketches = [obj for obj in doc.Objects if getattr(obj, 'TypeId', '') == 'Sketcher::SketchObject' and getattr(obj, 'SimpleCADOp', '') == 'make_face_from_sketch_rface']
bridge_features = [obj for obj in doc.Objects if getattr(obj, 'TypeId', '') == 'Part::Feature' and getattr(obj, 'SimpleCADOp', '') == 'make_face_from_sketch_rface']
extrusions = [obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_extrude_rsolid']
sketch = sketches[-1]
extrusion = extrusions[-1]
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'sketch_count': len(sketches),
'bridge_feature_count': len(bridge_features),
'geom_count': len(list(sketch.Geometry)),
'extrusion_base_type': getattr(extrusion.Base, 'TypeId', ''),
'solid_count': 0 if extrusion.Shape.isNull() else len(extrusion.Shape.Solids),
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["sketch_count"], 1)
self.assertEqual(result["bridge_feature_count"], 0)
self.assertEqual(result["geom_count"], segment_count)
self.assertEqual(result["extrusion_base_type"], "Sketcher::SketchObject")
self.assertEqual(result["solid_count"], 1)
def test_translate_model_json_functional_circle_sketch_promotion_fcstd_valid(self):
radius = scad.var("fcstd_circle_radius", 1.5)
thickness = scad.var("fcstd_circle_thickness", 0.5)
with GraphSession() as session:
sketch = scad.make_sketch_rsketch("fcstd_circle")
sketch = scad.add_point_rsketch(sketch, "center", 0.0, 0.0)
sketch = scad.add_circle_rsketch(sketch, "outer", "center", radius)
sketch = scad.constrain_fix_rsketch(sketch, "center")
sketch = scad.constrain_radius_rsketch(sketch, "outer", radius)
face = scad.make_face_from_sketch_rface(
sketch,
require_fully_constrained=True,
)
scad.extrude_rsolid(face, (0.0, 0.0, 1.0), thickness)
payload = scad.export_model_json(session)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
sketch = next(obj for obj in doc.Objects if getattr(obj, 'TypeId', '') == 'Sketcher::SketchObject' and getattr(obj, 'SimpleCADOp', '') == 'make_face_from_sketch_rface')
extrusion = next(obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_extrude_rsolid')
constraint_status = json.loads(sketch.SimpleCADSketchConstraints)
solve = json.loads(sketch.SimpleCADSketchSolve)
exprs = list(getattr(sketch, 'ExpressionEngine', []))
shape = extrusion.Shape
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'geom_count': len(list(sketch.Geometry)),
'constraint_count': len(sketch.Constraints),
'mapped_count': len(constraint_status.get('mapped', [])),
'skipped_count': len(constraint_status.get('skipped', [])),
'solve_status': solve.get('status'),
'solve_dof': int(solve.get('dof', -1)),
'exprs': exprs,
'solid_count': 0 if shape.isNull() else len(shape.Solids),
'volume': 0.0 if shape.isNull() else float(shape.Volume),
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["geom_count"], 1)
self.assertGreaterEqual(result["constraint_count"], 3)
self.assertEqual(result["mapped_count"], result["constraint_count"])
self.assertEqual(result["skipped_count"], 0)
self.assertEqual(result["solve_status"], "solved")
self.assertEqual(result["solve_dof"], 0)
self.assertEqual(result["solid_count"], 1)
self.assertAlmostEqual(
result["volume"], 3.141592653589793 * 1.5 * 1.5 * 0.5, places=5
)
expr_map = {prop: expr for prop, expr in result["exprs"]}
self.assertTrue(
any(
prop.startswith("Constraints[") and "var_fcstd_circle_radius" in expr
for prop, expr in expr_map.items()
)
)
def test_translate_model_json_complex_guided_sketch_constraints_fcstd_valid(self):
with GraphSession() as session:
sketch = scad.make_sketch_rsketch("fcstd_guided_diamond")
sketch = scad.add_point_rsketch(sketch, "center", 10.0, 8.0)
sketch = scad.add_point_rsketch(sketch, "left", 3.0, 8.0)
sketch = scad.add_point_rsketch(sketch, "top", 10.0, 12.0)
sketch = scad.add_point_rsketch(sketch, "right", 17.0, 8.0)
sketch = scad.add_point_rsketch(sketch, "bottom", 10.0, 4.0)
sketch = scad.add_point_rsketch(sketch, "guide_upper_start", 3.0, 13.0)
sketch = scad.add_point_rsketch(sketch, "guide_upper_end", 10.0, 17.0)
sketch = scad.add_point_rsketch(sketch, "guide_lower_start", 17.0, 3.0)
sketch = scad.add_point_rsketch(sketch, "guide_lower_end", 10.0, -1.0)
sketch = scad.add_line_rsketch(sketch, "bottom_left", "left", "bottom")
sketch = scad.add_line_rsketch(sketch, "right_bottom", "bottom", "right")
sketch = scad.add_line_rsketch(sketch, "top_right", "right", "top")
sketch = scad.add_line_rsketch(sketch, "left_top", "top", "left")
sketch = scad.add_line_rsketch(
sketch,
"guide_upper",
"guide_upper_start",
"guide_upper_end",
construction=True,
)
sketch = scad.add_line_rsketch(
sketch,
"guide_lower",
"guide_lower_start",
"guide_lower_end",
construction=True,
)
sketch = scad.constrain_fix_rsketch(sketch, "center")
sketch = scad.constrain_distance_x_rsketch(sketch, "left", "center", 7.0)
sketch = scad.constrain_distance_y_rsketch(sketch, "left", "center", 0.0)
sketch = scad.constrain_distance_x_rsketch(sketch, "center", "right", 7.0)
sketch = scad.constrain_distance_y_rsketch(sketch, "center", "right", 0.0)
sketch = scad.constrain_distance_x_rsketch(sketch, "center", "top", 0.0)
sketch = scad.constrain_distance_y_rsketch(sketch, "center", "top", 4.0)
sketch = scad.constrain_distance_x_rsketch(sketch, "bottom", "center", 0.0)
sketch = scad.constrain_distance_y_rsketch(sketch, "bottom", "center", 4.0)
sketch = scad.constrain_parallel_rsketch(sketch, "bottom_left", "top_right")
sketch = scad.constrain_parallel_rsketch(sketch, "right_bottom", "left_top")
sketch = scad.constrain_equal_length_rsketch(
sketch, "bottom_left", "right_bottom"
)
sketch = scad.constrain_equal_length_rsketch(
sketch, "right_bottom", "top_right"
)
sketch = scad.constrain_equal_length_rsketch(
sketch, "top_right", "left_top"
)
sketch = scad.constrain_distance_x_rsketch(
sketch, "left", "guide_upper_start", 0.0
)
sketch = scad.constrain_distance_y_rsketch(
sketch, "left", "guide_upper_start", 5.0
)
sketch = scad.constrain_distance_x_rsketch(
sketch, "top", "guide_upper_end", 0.0
)
sketch = scad.constrain_distance_y_rsketch(
sketch, "top", "guide_upper_end", 5.0
)
sketch = scad.constrain_distance_x_rsketch(
sketch, "guide_lower_start", "right", 0.0
)
sketch = scad.constrain_distance_y_rsketch(
sketch, "guide_lower_start", "right", 5.0
)
sketch = scad.constrain_distance_x_rsketch(
sketch, "guide_lower_end", "bottom", 0.0
)
sketch = scad.constrain_distance_y_rsketch(
sketch, "guide_lower_end", "bottom", 5.0
)
sketch = scad.constrain_parallel_rsketch(
sketch, "guide_upper", "guide_lower"
)
sketch = scad.constrain_parallel_rsketch(
sketch, "guide_upper", "right_bottom"
)
sketch = scad.constrain_parallel_rsketch(sketch, "guide_lower", "left_top")
sketch = scad.constrain_equal_length_rsketch(
sketch, "guide_upper", "right_bottom"
)
sketch = scad.constrain_equal_length_rsketch(
sketch, "guide_lower", "left_top"
)
face = scad.make_face_from_sketch_rface(
sketch,
require_fully_constrained=True,
)
scad.extrude_rsolid(face, (0.0, 0.0, 1.0), 1.0)
payload = scad.export_model_json(session)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
sketch = next(obj for obj in doc.Objects if getattr(obj, 'TypeId', '') == 'Sketcher::SketchObject' and getattr(obj, 'SimpleCADOp', '') == 'make_face_from_sketch_rface')
extrusion = next(obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_extrude_rsolid')
constraint_status = json.loads(sketch.SimpleCADSketchConstraints)
solve = json.loads(sketch.SimpleCADSketchSolve)
promotion = json.loads(sketch.SimpleCADSketchPromotion)
shape = extrusion.Shape
construction_count = 0
for idx, _geo in enumerate(sketch.Geometry):
try:
construction_count += 1 if sketch.getConstruction(idx) else 0
except Exception:
pass
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'geom_count': len(list(sketch.Geometry)),
'construction_count': construction_count,
'constraint_count': len(sketch.Constraints),
'mapped_count': len(constraint_status.get('mapped', [])),
'skipped_count': len(constraint_status.get('skipped', [])),
'solve_status': solve.get('status'),
'solve_dof': int(solve.get('dof', -1)),
'promotion_edges': [edge.get('entity_id') for edge in promotion.get('edges', [])],
'solid_count': 0 if shape.isNull() else len(shape.Solids),
'volume': 0.0 if shape.isNull() else float(shape.Volume),
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["geom_count"], 6)
self.assertEqual(result["construction_count"], 2)
self.assertGreaterEqual(result["constraint_count"], 12)
self.assertGreaterEqual(result["mapped_count"], 12)
self.assertGreaterEqual(result["mapped_count"] + result["skipped_count"], 31)
self.assertEqual(result["solve_status"], "solved")
self.assertEqual(result["solve_dof"], 0)
self.assertEqual(
result["promotion_edges"],
["bottom_left", "right_bottom", "top_right", "left_top"],
)
self.assertEqual(result["solid_count"], 1)
self.assertAlmostEqual(result["volume"], 56.0, places=5)
def test_translate_model_json_curve_guided_sketch_constraints_fcstd_valid(self):
with GraphSession() as session:
sketch = scad.make_sketch_rsketch("fcstd_curve_guided")
sketch = scad.add_point_rsketch(sketch, "center", 32.0, 42.0)
sketch = scad.add_point_rsketch(sketch, "rim", 36.0, 42.0)
sketch = scad.add_point_rsketch(sketch, "clearance_center", 32.0, 42.0)
sketch = scad.add_point_rsketch(sketch, "upper_left", 23.0, 46.0)
sketch = scad.add_point_rsketch(sketch, "upper_right", 41.0, 46.0)
sketch = scad.add_point_rsketch(sketch, "lower_left", 23.0, 38.0)
sketch = scad.add_point_rsketch(sketch, "lower_right", 41.0, 38.0)
sketch = scad.add_circle_rsketch(sketch, "relief", "center", 4.0)
sketch = scad.add_circle_rsketch(
sketch, "clearance", "clearance_center", 4.0, construction=True
)
sketch = scad.add_line_rsketch(
sketch, "radius_probe", "center", "rim", construction=True
)
sketch = scad.add_line_rsketch(
sketch, "upper_rail", "upper_left", "upper_right", construction=True
)
sketch = scad.add_line_rsketch(
sketch, "lower_rail", "lower_left", "lower_right", construction=True
)
sketch = scad.constrain_fix_rsketch(sketch, "center")
sketch = scad.constrain_radius_rsketch(sketch, "relief", 4.0)
sketch = scad.constrain_point_on_rsketch(sketch, "rim", "relief")
sketch = scad.constrain_horizontal_rsketch(sketch, "radius_probe")
sketch = scad.constrain_length_rsketch(sketch, "radius_probe", 4.0)
sketch = scad.constrain_concentric_rsketch(sketch, "relief", "clearance")
sketch = scad.constrain_equal_radius_rsketch(sketch, "relief", "clearance")
sketch = scad.constrain_horizontal_rsketch(sketch, "upper_rail")
sketch = scad.constrain_horizontal_rsketch(sketch, "lower_rail")
sketch = scad.constrain_tangent_rsketch(sketch, "upper_rail", "relief")
sketch = scad.constrain_tangent_rsketch(sketch, "lower_rail", "relief")
sketch = scad.constrain_distance_x_rsketch(
sketch, "center", "upper_left", -9.0
)
sketch = scad.constrain_distance_x_rsketch(
sketch, "center", "upper_right", 9.0
)
sketch = scad.constrain_distance_x_rsketch(
sketch, "center", "lower_left", -9.0
)
sketch = scad.constrain_distance_x_rsketch(
sketch, "center", "lower_right", 9.0
)
face = scad.make_face_from_sketch_rface(
sketch,
require_fully_constrained=True,
)
scad.extrude_rsolid(face, (0.0, 0.0, 1.0), 1.0)
payload = scad.export_model_json(session)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
sketch = next(obj for obj in doc.Objects if getattr(obj, 'TypeId', '') == 'Sketcher::SketchObject' and getattr(obj, 'SimpleCADOp', '') == 'make_face_from_sketch_rface')
extrusion = next(obj for obj in doc.Objects if getattr(obj, 'SimpleCADOp', '') == 'make_extrude_rsolid')
constraint_status = json.loads(sketch.SimpleCADSketchConstraints)
solve = json.loads(sketch.SimpleCADSketchSolve)
promotion = json.loads(sketch.SimpleCADSketchPromotion)
shape = extrusion.Shape
geometry_type_names = [geo.__class__.__name__ for geo in sketch.Geometry]
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'geom_count': len(list(sketch.Geometry)),
'circle_count': sum(1 for item in geometry_type_names if item == 'Circle'),
'line_count': sum(1 for item in geometry_type_names if item == 'LineSegment'),
'constraint_count': len(sketch.Constraints),
'mapped_kinds': [item.get('kind') for item in constraint_status.get('mapped', [])],
'skipped_count': len(constraint_status.get('skipped', [])),
'solve_status': solve.get('status'),
'solve_dof': int(solve.get('dof', -1)),
'promotion_edges': [edge.get('entity_id') for edge in promotion.get('edges', [])],
'solid_count': 0 if shape.isNull() else len(shape.Solids),
'volume': 0.0 if shape.isNull() else float(shape.Volume),
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["geom_count"], 5)
self.assertEqual(result["circle_count"], 2)
self.assertEqual(result["line_count"], 3)
self.assertGreaterEqual(result["constraint_count"], 15)
self.assertGreaterEqual(result["mapped_kinds"].count("tangent"), 2)
self.assertIn("point_on", result["mapped_kinds"])
self.assertIn("equal_radius", result["mapped_kinds"])
self.assertIn("concentric", result["mapped_kinds"])
self.assertLessEqual(result["skipped_count"], 1)
self.assertEqual(result["solve_status"], "solved")
self.assertEqual(result["solve_dof"], 0)
self.assertEqual(result["promotion_edges"], ["relief"])
self.assertEqual(result["solid_count"], 1)
self.assertAlmostEqual(result["volume"], 16.0 * 3.141592653589793, places=5)
def test_translate_model_json_records_unsupported_functional_sketch_constraints(
self,
):
with GraphSession() as session:
sketch = scad.make_sketch_rsketch("fcstd_midpoint_record")
sketch = scad.add_point_rsketch(sketch, "p0", 0.0, 0.0)
sketch = scad.add_point_rsketch(sketch, "p1", 2.0, 0.0)
sketch = scad.add_point_rsketch(sketch, "p2", 2.0, 1.0)
sketch = scad.add_point_rsketch(sketch, "p3", 0.0, 1.0)
sketch = scad.add_point_rsketch(sketch, "mid", 1.0, 0.0)
sketch = scad.add_line_rsketch(sketch, "bottom", "p0", "p1")
sketch = scad.add_line_rsketch(sketch, "right", "p1", "p2")
sketch = scad.add_line_rsketch(sketch, "top", "p2", "p3")
sketch = scad.add_line_rsketch(sketch, "left", "p3", "p0")
sketch = scad.constrain_fix_rsketch(sketch, "p0")
sketch = scad.constrain_horizontal_rsketch(sketch, "bottom")
sketch = scad.constrain_vertical_rsketch(sketch, "right")
sketch = scad.constrain_parallel_rsketch(sketch, "bottom", "top")
sketch = scad.constrain_parallel_rsketch(sketch, "left", "right")
sketch = scad.constrain_distance_rsketch(sketch, "p0", "p1", 2.0)
sketch = scad.constrain_distance_rsketch(sketch, "p0", "p3", 1.0)
sketch = scad.constrain_midpoint_rsketch(sketch, "mid", "bottom")
scad.make_face_from_sketch_rface(sketch)
payload = scad.export_model_json(session)
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
sketch = next(obj for obj in doc.Objects if getattr(obj, 'TypeId', '') == 'Sketcher::SketchObject' and getattr(obj, 'SimpleCADOp', '') == 'make_face_from_sketch_rface')
constraint_status = json.loads(sketch.SimpleCADSketchConstraints)
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'mapped_kinds': [item.get('kind') for item in constraint_status.get('mapped', [])],
'skipped': constraint_status.get('skipped', []),
'shape_edges': len(sketch.Shape.Edges),
}, fh)
"""
result = self._inspect_fcstd_json(payload, probe)
self.assertEqual(result["shape_edges"], 4)
self.assertIn("midpoint", [item.get("kind") for item in result["skipped"]])
self.assertTrue(
any(
"no crash-safe FreeCAD Sketcher mapping" in str(item.get("reason"))
for item in result["skipped"]
)
)
def test_translate_model_json_binds_mixed_sketch_local_line_and_arc_center_expressions(
self,
):
graph = OperationGraph(graph_id="graph_mixed_local_expr")
line = graph.add_node(
op="make_line_redge",
node_id="line_expr",
params={"start": [0.0, 0.0, 0.0], "end": [1.0, 0.0, 0.0]},
param_exprs={"end": [{"expr_id": "var_lx"}, {"expr_id": "var_ly"}, None]},
)
arc = graph.add_node(
op="make_angle_arc_redge",
node_id="arc_expr",
params={
"center": [1.0, 1.0, 0.0],
"radius": 1.0,
"start_angle": -1.5707963267948966,
"end_angle": 0.0,
},
param_exprs={
"center": [{"expr_id": "var_cx"}, {"expr_id": "var_cy"}, None],
"radius": {"expr_id": "var_r"},
},
)
wire = graph.add_node(
op="make_wire_from_edges_rwire",
node_id="wire_expr",
params={"edge_count": 2},
inputs=[line, arc],
)
payload = {
"schema_version": "2.0",
"canonical_contract": {"contract_version": "2.0"},
"graph": graph.to_dict(),
"leaf_ids": [wire.node_id],
"expression_graph": {
"nodes": [
{"expr_id": "var_lx", "kind": "var", "name": "lx", "default": 1.0},
{"expr_id": "var_ly", "kind": "var", "name": "ly", "default": 0.0},
{"expr_id": "var_cx", "kind": "var", "name": "cx", "default": 1.0},
{"expr_id": "var_cy", "kind": "var", "name": "cy", "default": 1.0},
{"expr_id": "var_r", "kind": "var", "name": "r", "default": 1.0},
]
},
"frame_graph": {"nodes": []},
"geometry_registry": [],
"semantic_entity_registry": [],
"sketch_profile_registry": [],
"semantic_delta_log": [],
"topology_delta_log": [],
}
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
result = {}
for obj in doc.Objects:
if getattr(obj, 'TypeId', '') == 'Sketcher::SketchObject':
result[obj.Name] = list(getattr(obj, 'ExpressionEngine', []))
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump(result, fh)
"""
result = self._inspect_fcstd_json(json.dumps(payload), probe)
all_entries = [entry for entries in result.values() for entry in entries]
self.assertIn(
["Geometry[0].EndPoint.x", "<<SimpleCADExpressions>>.var_lx"],
all_entries,
)
self.assertIn(
["Geometry[0].EndPoint.y", "<<SimpleCADExpressions>>.var_ly"],
all_entries,
)
self.assertIn(
["Geometry[1].Center.x", "<<SimpleCADExpressions>>.var_cx"],
all_entries,
)
self.assertIn(
["Geometry[1].Center.y", "<<SimpleCADExpressions>>.var_cy"],
all_entries,
)
self.assertIn(
["Geometry[1].Radius", "<<SimpleCADExpressions>>.var_r"],
all_entries,
)
def test_translate_model_json_binds_mixed_sketch_three_point_arc_expressions(
self,
):
graph = OperationGraph(graph_id="graph_mixed_three_point_expr")
line = graph.add_node(
op="make_line_redge",
node_id="line_expr",
params={"start": [0.0, 0.0, 0.0], "end": [1.0, 0.0, 0.0]},
)
arc = graph.add_node(
op="make_three_point_arc_redge",
node_id="arc_expr",
params={
"start": [1.0, 0.0, 0.0],
"middle": [1.5, 0.5, 0.0],
"end": [1.0, 1.0, 0.0],
},
param_exprs={
"start": [{"expr_id": "var_sx"}, {"expr_id": "var_sy"}, None],
"middle": [{"expr_id": "var_mx"}, {"expr_id": "var_my"}, None],
"end": [{"expr_id": "var_ex"}, {"expr_id": "var_ey"}, None],
},
)
wire = graph.add_node(
op="make_wire_from_edges_rwire",
node_id="wire_expr",
params={"edge_count": 2},
inputs=[line, arc],
)
payload = {
"schema_version": "2.0",
"canonical_contract": {"contract_version": "2.0"},
"graph": graph.to_dict(),
"leaf_ids": [wire.node_id],
"expression_graph": {
"nodes": [
{"expr_id": "var_sx", "kind": "var", "name": "sx", "default": 1.0},
{"expr_id": "var_sy", "kind": "var", "name": "sy", "default": 0.0},
{"expr_id": "var_mx", "kind": "var", "name": "mx", "default": 1.5},
{"expr_id": "var_my", "kind": "var", "name": "my", "default": 0.5},
{"expr_id": "var_ex", "kind": "var", "name": "ex", "default": 1.0},
{"expr_id": "var_ey", "kind": "var", "name": "ey", "default": 1.0},
]
},
"frame_graph": {"nodes": []},
"geometry_registry": [],
"semantic_entity_registry": [],
"sketch_profile_registry": [],
"semantic_delta_log": [],
"topology_delta_log": [],
}
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
result = {}
for obj in doc.Objects:
if getattr(obj, 'TypeId', '') == 'Sketcher::SketchObject':
result[obj.Name] = list(getattr(obj, 'ExpressionEngine', []))
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump(result, fh)
"""
result = self._inspect_fcstd_json(json.dumps(payload), probe)
all_entries = [entry for entries in result.values() for entry in entries]
self.assertIn(
["Geometry[1].StartPoint.x", "<<SimpleCADExpressions>>.var_sx"],
all_entries,
)
self.assertIn(
["Geometry[1].StartPoint.y", "<<SimpleCADExpressions>>.var_sy"],
all_entries,
)
self.assertIn(
["Geometry[1].EndPoint.x", "<<SimpleCADExpressions>>.var_ex"],
all_entries,
)
self.assertIn(
["Geometry[1].EndPoint.y", "<<SimpleCADExpressions>>.var_ey"],
all_entries,
)
center_x = next(
expr for prop, expr in all_entries if prop == "Geometry[1].Center.x"
)
center_y = next(
expr for prop, expr in all_entries if prop == "Geometry[1].Center.y"
)
radius = next(
expr for prop, expr in all_entries if prop == "Geometry[1].Radius"
)
self.assertIn("<<SimpleCADExpressions>>.var_sx", center_x)
self.assertIn("<<SimpleCADExpressions>>.var_mx", center_x)
self.assertIn("<<SimpleCADExpressions>>.var_ex", center_x)
self.assertIn("<<SimpleCADExpressions>>.var_sy", center_y)
self.assertIn("<<SimpleCADExpressions>>.var_my", center_y)
self.assertIn("<<SimpleCADExpressions>>.var_ey", center_y)
self.assertIn("Geometry[1].Center.x", [prop for prop, _ in all_entries])
self.assertIn("Geometry[1].Center.y", [prop for prop, _ in all_entries])
self.assertIn("pow(", radius)
self.assertIn("<<SimpleCADExpressions>>.var_sx", radius)
self.assertIn("<<SimpleCADExpressions>>.var_sy", radius)
self.assertIn("<<SimpleCADExpressions>>.var_mx", radius)
self.assertIn("<<SimpleCADExpressions>>.var_my", radius)
self.assertIn("<<SimpleCADExpressions>>.var_ex", radius)
self.assertIn("<<SimpleCADExpressions>>.var_ey", radius)
def test_translate_model_json_exports_single_three_point_arc_sketch_with_expressions(
self,
):
graph = OperationGraph(graph_id="graph_single_three_point_expr")
arc = graph.add_node(
op="make_three_point_arc_redge",
node_id="arc_expr",
params={
"start": [0.0, 0.0, 0.0],
"middle": [1.0, 1.0, 0.0],
"end": [2.0, 0.0, 0.0],
},
param_exprs={
"start": [{"expr_id": "var_sx"}, {"expr_id": "var_sy"}, None],
"middle": [{"expr_id": "var_mx"}, {"expr_id": "var_my"}, None],
"end": [{"expr_id": "var_ex"}, {"expr_id": "var_ey"}, None],
},
)
wire = graph.add_node(
op="make_wire_from_edges_rwire",
node_id="wire_expr",
params={"edge_count": 1},
inputs=[arc],
)
payload = {
"schema_version": "2.0",
"canonical_contract": {"contract_version": "2.0"},
"graph": graph.to_dict(),
"leaf_ids": [wire.node_id],
"expression_graph": {
"nodes": [
{"expr_id": "var_sx", "kind": "var", "name": "sx", "default": 0.0},
{"expr_id": "var_sy", "kind": "var", "name": "sy", "default": 0.0},
{"expr_id": "var_mx", "kind": "var", "name": "mx", "default": 1.0},
{"expr_id": "var_my", "kind": "var", "name": "my", "default": 1.0},
{"expr_id": "var_ex", "kind": "var", "name": "ex", "default": 2.0},
{"expr_id": "var_ey", "kind": "var", "name": "ey", "default": 0.0},
]
},
"frame_graph": {"nodes": []},
"geometry_registry": [],
"semantic_entity_registry": [],
"sketch_profile_registry": [],
"semantic_delta_log": [],
"topology_delta_log": [],
}
probe = """
import json
import FreeCAD as App
doc = App.openDocument(FCSTD_PATH)
sketches = [obj for obj in doc.Objects if getattr(obj, 'TypeId', '') == 'Sketcher::SketchObject']
target = sketches[0]
with open(OUT_PATH, 'w', encoding='utf-8') as fh:
json.dump({
'sketch_count': len(sketches),
'exprs': list(getattr(target, 'ExpressionEngine', [])),
'geom_count': len(list(getattr(target, 'Geometry', []))),
'shape_type': target.Shape.ShapeType,
'edge_count': len(target.Shape.Edges),
}, fh)
"""
result = self._inspect_fcstd_json(json.dumps(payload), probe)
self.assertEqual(result["sketch_count"], 1)
self.assertEqual(result["geom_count"], 1)
self.assertEqual(result["shape_type"], "Wire")
self.assertEqual(result["edge_count"], 1)
expr_map = {prop: expr for prop, expr in result["exprs"]}
self.assertIn("Geometry[0].StartPoint.x", expr_map)
self.assertIn("Geometry[0].StartPoint.y", expr_map)
self.assertIn("Geometry[0].EndPoint.x", expr_map)
self.assertIn("Geometry[0].EndPoint.y", expr_map)
self.assertIn("Geometry[0].Center.x", expr_map)
self.assertIn("Geometry[0].Center.y", expr_map)
self.assertIn("Geometry[0].Radius", expr_map)
self.assertIn(
"<<SimpleCADExpressions>>.var_sx", expr_map["Geometry[0].StartPoint.x"]
)
self.assertIn(
"<<SimpleCADExpressions>>.var_sy", expr_map["Geometry[0].StartPoint.x"]
)
self.assertIn(
"<<SimpleCADExpressions>>.var_sx", expr_map["Geometry[0].StartPoint.y"]
)
self.assertIn(
"<<SimpleCADExpressions>>.var_sy", expr_map["Geometry[0].StartPoint.y"]
)
self.assertIn(
"<<SimpleCADExpressions>>.var_ex", expr_map["Geometry[0].EndPoint.x"]
)
self.assertIn(
"<<SimpleCADExpressions>>.var_ey", expr_map["Geometry[0].EndPoint.x"]
)
self.assertIn(
"<<SimpleCADExpressions>>.var_ex", expr_map["Geometry[0].EndPoint.y"]
)
self.assertIn(
"<<SimpleCADExpressions>>.var_ey", expr_map["Geometry[0].EndPoint.y"]
)
def test_translate_model_json_uses_selector_index_fallback_for_detail_features(
self,
):
with GraphSession() as session:
box = scad.make_box_rsolid(2.0, 2.0, 2.0)
scad.chamfer_rsolid(box, [box.get_edges(0)], 0.2)
scad.shell_rsolid(box, [box.get_faces(0)], 0.1)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("Part::Chamfer", script)
self.assertIn("Part::Thickness", script)
self.assertIn("selected_edge_indices", script)
self.assertIn("selected_face_indices", script)
def test_translate_model_json_does_not_emit_assembly_object_for_plain_geometry(
self,
):
with GraphSession() as session:
scad.make_box_rsolid(1.0, 1.0, 1.0)
script = _compile_model_json(scad.export_model_json(session))
self.assertNotIn("= _make_native_assembly(", script)
self.assertNotIn("PART_REGISTRY", script)
self.assertNotIn("CONSTRAINT_REGISTRY", script)
self.assertNotIn("SimpleCAD Constraint", script)
def test_translate_model_json_preserves_pattern_multi_output_structure(self):
with GraphSession() as session:
box = scad.make_box_rsolid(1.0, 1.0, 1.0)
scad.linear_pattern_rsolidlist(box, (1.0, 0.0, 0.0), 3, 2.0)
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("GRAPH_OUTPUTS", script)
self.assertIn("App::Link", script)
self.assertNotIn("linear_pattern", script)
self.assertIn("RESULT_NODE_IDS", script)
def test_translate_model_json_hides_non_leaf_graph_objects(self):
with GraphSession() as session:
box = scad.make_box_rsolid(2.0, 3.0, 4.0)
scad.translate_shape(box, (1.0, 2.0, 3.0))
script = _compile_model_json(scad.export_model_json(session))
self.assertIn("_apply_result_visibility(RESULT_NODE_IDS)", script)
self.assertIn("_set_active_result_object(RESULT_NODE_IDS)", script)
self.assertIn("def _set_visibility", script)
self.assertIn("def _save_fcstd_with_gui_visibility", script)
self.assertIn("def _apply_result_visibility", script)
def test_translate_model_json_rejects_field_surface_ops(self):
graph = OperationGraph(graph_id="graph_field")
graph.add_node(
op="make_field_surface_rsolid",
params={
"bounds": {"min": [0.0, 0.0, 0.0], "max": [1.0, 1.0, 1.0]},
"resolution": [8, 8, 8],
"iso": 0.0,
"cap_bounds": True,
"field_serialization_mode": "scalar_field",
"field_tree": {
"op": "box",
"params": {"center": [0.0, 0.0, 0.0], "size": [1.0, 1.0, 1.0]},
"children": [],
},
},
)
payload = {
"schema_version": "2.0",
"canonical_contract": {"contract_version": "2.0"},
"graph": graph.to_dict(),
"leaf_ids": [graph.leaf_nodes()[0].node_id],
"expression_graph": {"nodes": []},
"frame_graph": {"nodes": []},
"geometry_registry": [],
"semantic_entity_registry": [],
"sketch_profile_registry": [],
"semantic_delta_log": [],
"topology_delta_log": [],
}
with self.assertRaises(ValueError):
_compile_model_json(json.dumps(payload))
def test_translate_model_json_to_fcstd_invokes_freecadcmd(self):
with GraphSession() as session:
scad.make_box_rsolid(1.0, 1.0, 1.0)
payload = scad.export_model_json(session)
with (
mock.patch(
"shutil.which",
side_effect=lambda name: (
"/usr/bin/FreeCADCmd" if name == "FreeCADCmd" else None
),
),
mock.patch("subprocess.run") as run_mock,
mock.patch("os.path.exists", return_value=True),
mock.patch("os.path.getsize", return_value=1024),
):
run_mock.return_value = mock.Mock(
returncode=0, stdout="/tmp/out.FCStd\n", stderr=""
)
out = _compile_model_json_to_fcstd(payload, "/tmp/out.FCStd")
self.assertEqual(out, "/tmp/out.FCStd")
run_mock.assert_called_once()
def test_translate_model_json_to_fcstd_requires_freecadcmd(self):
with GraphSession() as session:
scad.make_box_rsolid(1.0, 1.0, 1.0)
payload = scad.export_model_json(session)
with (
mock.patch("shutil.which", return_value=None),
mock.patch("os.path.exists", return_value=False),
):
with self.assertRaises(scad.SimpleCADError):
_compile_model_json_to_fcstd(payload, "/tmp/out.FCStd")
def test_translate_model_json_to_fcstd_discovers_macos_bundle_freecadcmd(self):
with GraphSession() as session:
scad.make_box_rsolid(1.0, 1.0, 1.0)
payload = scad.export_model_json(session)
def fake_exists(path: str) -> bool:
return path in {
"/Applications/FreeCAD.app/Contents/Resources/bin/freecadcmd",
"/tmp/out.FCStd",
}
with (
mock.patch("shutil.which", return_value=None),
mock.patch("os.path.exists", side_effect=fake_exists),
mock.patch("os.path.getsize", return_value=1024),
mock.patch("subprocess.run") as run_mock,
):
run_mock.return_value = mock.Mock(
returncode=0, stdout="/tmp/out.FCStd\n", stderr=""
)
out = _compile_model_json_to_fcstd(payload, "/tmp/out.FCStd")
self.assertEqual(out, "/tmp/out.FCStd")
args, _kwargs = run_mock.call_args
self.assertEqual(
args[0][0], "/Applications/FreeCAD.app/Contents/Resources/bin/freecadcmd"
)
class TestGeoSelectorStabilityCriterion(unittest.TestCase):
"""The FreeCAD runtime accepts a clearly separated best geo match.
A rebuild in FreeCAD's OCC differs from the recorded OCP geometry in the
4th-6th significant digit, scoring the correct candidate in the
0.01-0.5 band; wrong candidates score >= ~1. Stability is separation,
not near-bit-identity.
"""
@classmethod
def setUpClass(cls):
import math as math_module
from simplecadapi.translator.freecad_translator.runtime import (
assemble_runtime_source,
)
source = assemble_runtime_source()
# One namespace dict so runtime snippet functions share globals,
# mirroring how the emitter concatenates them into one script scope.
cls.runtime = {"math": math_module}
exec(compile(source, "<freecad-runtime>", "exec"), cls.runtime)
@staticmethod
def _edge(length, start, end, center=None):
class Point:
def __init__(self, vector):
self.x, self.y, self.z = vector
class Vertex:
def __init__(self, vector):
self.Point = Point(vector)
class Box:
XMin = min(start[0], end[0]) - 0.1
XMax = max(start[0], end[0]) + 0.1
YMin = min(start[1], end[1]) - 0.1
YMax = max(start[1], end[1]) + 0.1
ZMin = min(start[2], end[2]) - 0.1
ZMax = max(start[2], end[2]) + 0.1
class Edge:
Length = length
Vertexes = [Vertex(start), Vertex(end)]
BoundBox = Box()
CenterOfMass = Point(
center
if center is not None
else tuple((s + e) / 2.0 for s, e in zip(start, end))
)
return Edge()
@classmethod
def _selector(cls):
return {
"mode": "geo_exact",
"kind": "edge",
"bbox": {"min": (-0.1, -0.1, -0.1), "max": (10.1, 0.1, 0.1)},
"length": 10.0,
"center": (5.0, 0.0, 0.0),
"start": (0.0, 0.0, 0.0),
"end": (10.0, 0.0, 0.0),
}
def _select(self, candidates):
class Shape:
Edges = list(candidates)
return self.runtime["_selection_index_for_selector"](
Shape(), self._selector(), context="unit test"
)
def test_near_exact_match_still_accepted(self):
drifted = self._edge(10.0005, (0.0002, 0, 0), (10.0006, 0, 0))
decoy = self._edge(4.0, (20, 20, 20), (24, 20, 20))
self.assertEqual(self._select([drifted, decoy]), 0)
def test_kernel_drift_match_accepted_when_clearly_separated(self):
# ~0.5% aggregate drift: score lands in the 0.01-0.5 band.
drifted = self._edge(10.05, (0.02, 0, 0), (10.07, 0, 0))
decoy = self._edge(4.0, (20, 20, 20), (24, 20, 20))
self.assertEqual(self._select([drifted, decoy]), 0)
self.assertEqual(self._select([decoy, drifted]), 1)
def test_similar_runner_up_is_rejected_as_unstable(self):
first = self._edge(10.05, (0.02, 0, 0), (10.07, 0, 0))
twin = self._edge(10.06, (0.03, 0, 0), (10.08, 0, 0))
with self.assertRaisesRegex(RuntimeError, "stable"):
self._select([first, twin])
def test_absent_target_is_rejected(self):
decoy = self._edge(4.0, (20, 20, 20), (24, 20, 20))
with self.assertRaisesRegex(RuntimeError, "stable"):
self._select([decoy])
def test_single_drifted_candidate_without_rival_is_accepted(self):
drifted = self._edge(10.05, (0.02, 0, 0), (10.07, 0, 0))
self.assertEqual(self._select([drifted]), 0)
if __name__ == "__main__":
unittest.main()