Jerry
242 lines
7.9 KiB
Python
242 lines
7.9 KiB
Python
"""FreeCAD runtime tests for geometric signature topology matching."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
import tempfile
|
|
import unittest
|
|
|
|
from simplecadapi.translator.freecad_translator.runtime import (
|
|
assemble_runtime_source,
|
|
)
|
|
|
|
|
|
class TestFreeCADTranslatorGSM(unittest.TestCase):
|
|
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 _run_runtime_probe(self, probe: str) -> dict:
|
|
freecad_cmd = self._discover_freecadcmd()
|
|
if not freecad_cmd:
|
|
self.skipTest("freecadcmd not available")
|
|
|
|
with tempfile.TemporaryDirectory() as tmp_dir:
|
|
script_path = os.path.join(tmp_dir, "probe.py")
|
|
result_path = os.path.join(tmp_dir, "result.json")
|
|
script = "\n".join(
|
|
[
|
|
"import json",
|
|
"import math",
|
|
"import FreeCAD as App",
|
|
"import Part",
|
|
"doc = App.newDocument('SimpleCADGSMProbe')",
|
|
"GRAPH_NODES = {}",
|
|
"GRAPH_OUTPUTS = {}",
|
|
"GRAPH_METADATA = {}",
|
|
"GRAPH_SELECTIONS = {}",
|
|
"GRAPH_SPINE_OBJECTS = {}",
|
|
"GRAPH_LIMITATIONS = {}",
|
|
"GRAPH_TRANSLATION_LIMITATIONS = {}",
|
|
"PRODUCT_VALUES = {}",
|
|
"ASSEMBLY_PROJECTION_INPUTS = {}",
|
|
"GUI_VISIBILITY_BY_NAME = {}",
|
|
"GUI_EXPANDED_BY_NAME = {}",
|
|
"GUI_SHAPE_COLOR_BY_NAME = {}",
|
|
"GUI_MATERIAL_OVERRIDE_BY_NAME = {}",
|
|
"MATERIAL_OBJECTS_BY_ID = {}",
|
|
"SIMPLECAD_JOINT_OBJECTS = {}",
|
|
"SKETCH_REGISTRY = []",
|
|
"OP_EXPRESSION_BINDINGS = {}",
|
|
"OP_EXPRESSION_LIMITATIONS = {}",
|
|
"EXPRESSION_GRAPH = {}",
|
|
f"RESULT_PATH = {json.dumps(result_path)}",
|
|
assemble_runtime_source(),
|
|
probe,
|
|
]
|
|
)
|
|
with open(script_path, "w", encoding="utf-8") as handle:
|
|
handle.write(script)
|
|
completed = subprocess.run(
|
|
[freecad_cmd, script_path],
|
|
check=False,
|
|
text=True,
|
|
capture_output=True,
|
|
)
|
|
self.assertEqual(
|
|
completed.returncode,
|
|
0,
|
|
msg=f"stdout={completed.stdout!r}\nstderr={completed.stderr!r}",
|
|
)
|
|
with open(result_path, "r", encoding="utf-8") as handle:
|
|
return json.load(handle)
|
|
|
|
def test_split_line_selector_resolves_unique_fragment_chain(self):
|
|
result = self._run_runtime_probe(
|
|
"""
|
|
shape = Part.makeCompound([
|
|
Part.makeLine(App.Vector(0, 0, 0), App.Vector(1, 0, 0)),
|
|
Part.makeLine(App.Vector(1, 0, 0), App.Vector(2, 0, 0)),
|
|
])
|
|
selector = {
|
|
'kind': 'edge',
|
|
'geom_type': 'LINE',
|
|
'start': [0, 0, 0],
|
|
'end': [2, 0, 0],
|
|
'center': [1, 0, 0],
|
|
'length': 2,
|
|
'bbox': {'min': [0, 0, 0], 'max': [2, 0, 0]},
|
|
}
|
|
indices = _selection_indices_for_selector(shape, selector, context='split test')
|
|
with open(RESULT_PATH, 'w', encoding='utf-8') as handle:
|
|
json.dump({'indices': indices}, handle)
|
|
"""
|
|
)
|
|
|
|
self.assertEqual(result["indices"], [0, 1])
|
|
|
|
def test_two_source_selectors_resolve_one_merged_edge(self):
|
|
result = self._run_runtime_probe(
|
|
"""
|
|
shape = Part.makeCompound([
|
|
Part.makeLine(App.Vector(0, 0, 0), App.Vector(2, 0, 0)),
|
|
])
|
|
selectors = [
|
|
{
|
|
'kind': 'edge', 'geom_type': 'LINE',
|
|
'start': [0, 0, 0], 'end': [1, 0, 0],
|
|
'center': [0.5, 0, 0], 'length': 1,
|
|
'bbox': {'min': [0, 0, 0], 'max': [1, 0, 0]},
|
|
},
|
|
{
|
|
'kind': 'edge', 'geom_type': 'LINE',
|
|
'start': [1, 0, 0], 'end': [2, 0, 0],
|
|
'center': [1.5, 0, 0], 'length': 1,
|
|
'bbox': {'min': [1, 0, 0], 'max': [2, 0, 0]},
|
|
},
|
|
]
|
|
indices = _selection_indices_for_selectors(shape, selectors, context='merge test')
|
|
with open(RESULT_PATH, 'w', encoding='utf-8') as handle:
|
|
json.dump({'indices': indices}, handle)
|
|
"""
|
|
)
|
|
|
|
self.assertEqual(result["indices"], [0])
|
|
|
|
def test_identical_candidates_are_rejected_as_ambiguous(self):
|
|
result = self._run_runtime_probe(
|
|
"""
|
|
shape = Part.makeCompound([
|
|
Part.makeLine(App.Vector(0, 0, 0), App.Vector(2, 0, 0)),
|
|
Part.makeLine(App.Vector(0, 0, 0), App.Vector(2, 0, 0)),
|
|
])
|
|
selector = {
|
|
'kind': 'edge', 'geom_type': 'LINE',
|
|
'start': [0, 0, 0], 'end': [2, 0, 0],
|
|
'center': [1, 0, 0], 'length': 2,
|
|
'bbox': {'min': [0, 0, 0], 'max': [2, 0, 0]},
|
|
}
|
|
try:
|
|
_selection_indices_for_selector(shape, selector, context='ambiguity test')
|
|
except RuntimeError as error:
|
|
message = str(error)
|
|
else:
|
|
message = ''
|
|
with open(RESULT_PATH, 'w', encoding='utf-8') as handle:
|
|
json.dump({'message': message}, handle)
|
|
"""
|
|
)
|
|
|
|
self.assertIn("ambiguous", result["message"].lower())
|
|
|
|
def test_second_candidate_inside_match_threshold_is_ambiguous(self):
|
|
result = self._run_runtime_probe(
|
|
"""
|
|
shape = Part.makeCompound([
|
|
Part.makeLine(App.Vector(0, 0, 0), App.Vector(2, 0, 0)),
|
|
Part.makeLine(App.Vector(0, 0.000005, 0), App.Vector(2, 0.000005, 0)),
|
|
])
|
|
selector = {
|
|
'kind': 'edge', 'geom_type': 'LINE',
|
|
'start': [0, 0, 0], 'end': [2, 0, 0],
|
|
'center': [1, 0, 0], 'length': 2,
|
|
'bbox': {'min': [0, 0, 0], 'max': [2, 0, 0]},
|
|
}
|
|
scores = [
|
|
_geo_selector_score(candidate, selector, index)
|
|
for index, candidate in enumerate(shape.Edges)
|
|
]
|
|
try:
|
|
_selection_indices_for_selector(shape, selector, context='near ambiguity test')
|
|
except RuntimeError as error:
|
|
message = str(error)
|
|
else:
|
|
message = ''
|
|
with open(RESULT_PATH, 'w', encoding='utf-8') as handle:
|
|
json.dump({'message': message, 'scores': scores}, handle)
|
|
"""
|
|
)
|
|
|
|
self.assertLessEqual(result["scores"][1], 1e-4)
|
|
self.assertIn("ambiguous", result["message"].lower())
|
|
|
|
def test_split_full_circle_selector_resolves_unique_closed_chain(self):
|
|
result = self._run_runtime_probe(
|
|
"""
|
|
shape = Part.makeCompound([
|
|
Part.Arc(App.Vector(1, 0, 0), App.Vector(0, 1, 0), App.Vector(-1, 0, 0)).toShape(),
|
|
Part.Arc(App.Vector(-1, 0, 0), App.Vector(0, -1, 0), App.Vector(1, 0, 0)).toShape(),
|
|
])
|
|
selector = {
|
|
'kind': 'edge', 'geom_type': 'CIRCLE',
|
|
'start': [1, 0, 0], 'end': [1, 0, 0],
|
|
'center': [0, 0, 0], 'length': 2 * math.pi,
|
|
'bbox': {'min': [-1, -1, 0], 'max': [1, 1, 0]},
|
|
}
|
|
indices = _selection_indices_for_selector(shape, selector, context='circle split test')
|
|
with open(RESULT_PATH, 'w', encoding='utf-8') as handle:
|
|
json.dump({'indices': indices}, handle)
|
|
"""
|
|
)
|
|
|
|
self.assertEqual(result["indices"], [0, 1])
|
|
|
|
def test_three_source_selectors_resolve_one_merged_edge(self):
|
|
result = self._run_runtime_probe(
|
|
"""
|
|
shape = Part.makeCompound([
|
|
Part.makeLine(App.Vector(0, 0, 0), App.Vector(3, 0, 0)),
|
|
])
|
|
selectors = [
|
|
{
|
|
'kind': 'edge', 'geom_type': 'LINE',
|
|
'start': [index, 0, 0], 'end': [index + 1, 0, 0],
|
|
'center': [index + 0.5, 0, 0], 'length': 1,
|
|
'bbox': {'min': [index, 0, 0], 'max': [index + 1, 0, 0]},
|
|
}
|
|
for index in range(3)
|
|
]
|
|
indices = _selection_indices_for_selectors(shape, selectors, context='three-way merge test')
|
|
with open(RESULT_PATH, 'w', encoding='utf-8') as handle:
|
|
json.dump({'indices': indices}, handle)
|
|
"""
|
|
)
|
|
|
|
self.assertEqual(result["indices"], [0])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|