| from __future__ import annotations |
|
|
| import json |
| import math |
| import os |
| import re |
| import subprocess |
| import tempfile |
| import textwrap |
| from dataclasses import dataclass |
| from pathlib import Path |
|
|
|
|
| TARGET = Path(os.environ.get("ENGIWORLD_EVAL_TARGET", "/home/user/Desktop")) |
| NC_PATH = TARGET / "task-01.nc" |
| FCSTD_PATH = TARGET / "task-01.FCStd" |
| TOL = 1e-3 |
| WORD_RE = re.compile( |
| r"([A-Z])\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:E[+-]?\d+)?)", |
| re.IGNORECASE, |
| ) |
| NATIVE_MARKER = "TASK_C01_NATIVE=" |
|
|
|
|
| @dataclass(frozen=True) |
| class Move: |
| block: int |
| motion: int |
| start_x: float | None |
| start_y: float | None |
| start_z: float | None |
| end_x: float | None |
| end_y: float | None |
| end_z: float | None |
| feed: float | None |
| i: float | None |
| j: float | None |
|
|
| @property |
| def xy_distance(self) -> float: |
| if None in (self.start_x, self.start_y, self.end_x, self.end_y): |
| return 0.0 |
| arc = self.arc_geometry |
| if arc is not None: |
| _center_x, _center_y, radius, sweep = arc |
| return radius * sweep |
| return math.hypot(self.end_x - self.start_x, self.end_y - self.start_y) |
|
|
| @property |
| def arc_geometry(self) -> tuple[float, float, float, float] | None: |
| if self.motion not in (2, 3) or None in (self.start_x, self.start_y, self.end_x, self.end_y): |
| return None |
| i_offset = 0.0 if self.i is None else self.i |
| j_offset = 0.0 if self.j is None else self.j |
| center_x = float(self.start_x) + i_offset |
| center_y = float(self.start_y) + j_offset |
| radius = math.hypot(i_offset, j_offset) |
| if radius <= TOL: |
| return None |
| start_angle = math.atan2(float(self.start_y) - center_y, float(self.start_x) - center_x) |
| end_angle = math.atan2(float(self.end_y) - center_y, float(self.end_x) - center_x) |
| sweep = (start_angle - end_angle) % math.tau if self.motion == 2 else (end_angle - start_angle) % math.tau |
| if sweep <= 1e-9: |
| sweep = math.tau |
| return center_x, center_y, radius, sweep |
|
|
|
|
| def close(a: float | None, b: float, tol: float = TOL) -> bool: |
| return a is not None and abs(a - b) <= tol |
|
|
|
|
| def point_segment_distance( |
| point: tuple[float, float], |
| start: tuple[float, float], |
| end: tuple[float, float], |
| ) -> float: |
| dx = end[0] - start[0] |
| dy = end[1] - start[1] |
| length_squared = dx * dx + dy * dy |
| if length_squared <= TOL * TOL: |
| return math.dist(point, start) |
| projection = ((point[0] - start[0]) * dx + (point[1] - start[1]) * dy) / length_squared |
| projection = max(0.0, min(1.0, projection)) |
| closest = (start[0] + projection * dx, start[1] + projection * dy) |
| return math.dist(point, closest) |
|
|
|
|
| def point_move_distance(point: tuple[float, float], move: Move) -> float: |
| if None in (move.start_x, move.start_y, move.end_x, move.end_y): |
| return math.inf |
| arc = move.arc_geometry |
| if arc is None: |
| return point_segment_distance( |
| point, |
| (float(move.start_x), float(move.start_y)), |
| (float(move.end_x), float(move.end_y)), |
| ) |
| center_x, center_y, radius, sweep = arc |
| start_angle = math.atan2(float(move.start_y) - center_y, float(move.start_x) - center_x) |
| point_angle = math.atan2(point[1] - center_y, point[0] - center_x) |
| directed = (start_angle - point_angle) % math.tau if move.motion == 2 else (point_angle - start_angle) % math.tau |
| if directed <= sweep + 1e-9: |
| return abs(math.hypot(point[0] - center_x, point[1] - center_y) - radius) |
| return min( |
| math.dist(point, (float(move.start_x), float(move.start_y))), |
| math.dist(point, (float(move.end_x), float(move.end_y))), |
| ) |
|
|
|
|
| def strip_comments(text: str) -> str: |
| output: list[str] = [] |
| depth = 0 |
| for char in text: |
| if char == "\n": |
| depth = 0 |
| output.append(char) |
| elif depth: |
| if char == "(": |
| depth += 1 |
| elif char == ")": |
| depth -= 1 |
| elif char == "(": |
| depth = 1 |
| elif char == ";": |
| depth = 1 |
| else: |
| output.append(char) |
| return "".join(output) |
|
|
|
|
| def words_for_line(line: str) -> list[tuple[str, float]] | None: |
| cleaned = line.strip().upper().replace("%", "") |
| if not cleaned: |
| return [] |
| words: list[tuple[str, float]] = [] |
| cursor = 0 |
| for match in WORD_RE.finditer(cleaned): |
| if cleaned[cursor : match.start()].strip(): |
| return None |
| try: |
| value = float(match.group(2)) |
| except ValueError: |
| return None |
| if not math.isfinite(value): |
| return None |
| words.append((match.group(1), value)) |
| cursor = match.end() |
| if cleaned[cursor:].strip() or not words: |
| return None |
| return words |
|
|
|
|
| def parse_nc(path: Path) -> dict[str, object] | None: |
| if not path.is_file() or not 300 <= path.stat().st_size <= 2_000_000: |
| return None |
| raw = path.read_text(encoding="utf-8", errors="strict") |
| if "\x00" in raw: |
| return None |
| lines = strip_comments(raw).splitlines() |
|
|
| x = y = z = feed = None |
| motion: int | None = None |
| selected_tool: int | None = None |
| tool_changed = False |
| spindle_on = False |
| spindle_speed: float | None = None |
| metric = absolute = False |
| active_fixture: float | None = None |
| active_plane: int | None = None |
| length_offset_active = False |
| length_offset: int | None = None |
| stop_after_cut = False |
| end_after_cut = False |
| program_ended = False |
| last_cut_block = -1 |
| retract_after_cut = False |
| moves: list[Move] = [] |
|
|
| for block, line in enumerate(lines): |
| words = words_for_line(line) |
| if words is None: |
| return None |
| if not words: |
| continue |
| if program_ended: |
| return None |
| values: dict[str, list[float]] = {} |
| for letter, value in words: |
| values.setdefault(letter, []).append(value) |
| if set(values) - set("NGMTSFXYZIJH"): |
| return None |
| if any(len(values.get(letter, [])) > 1 for letter in "TSFXYZIJH"): |
| return None |
|
|
| motion_codes = [ |
| g |
| for g in values.get("G", []) |
| if any(close(g, code) for code in (0.0, 1.0, 2.0, 3.0)) |
| ] |
| if len(motion_codes) > 1: |
| return None |
| modal_groups = ( |
| (20.0, 21.0), |
| (90.0, 91.0), |
| (90.1, 91.1), |
| (17.0, 18.0, 19.0), |
| (40.0, 41.0, 42.0), |
| (43.0, 49.0), |
| (54.0, 55.0, 56.0, 57.0, 58.0, 59.0), |
| (61.0, 61.1, 64.0), |
| (93.0, 94.0, 95.0), |
| ) |
| if any( |
| sum(any(close(g, code) for code in group) for g in values.get("G", [])) > 1 |
| for group in modal_groups |
| ): |
| return None |
| has_g43 = any(close(g, 43.0) for g in values.get("G", [])) |
| has_g49 = any(close(g, 49.0) for g in values.get("G", [])) |
| if has_g43 and has_g49: |
| return None |
|
|
| for g in values.get("G", []): |
| if close(g, 20.0): |
| metric = False |
| elif close(g, 21.0): |
| metric = True |
| elif close(g, 90.0): |
| absolute = True |
| elif close(g, 91.0): |
| absolute = False |
| elif any(close(g, code) for code in (54.0, 55.0, 56.0, 57.0, 58.0, 59.0)): |
| active_fixture = next(code for code in (54.0, 55.0, 56.0, 57.0, 58.0, 59.0) if close(g, code)) |
| elif close(g, 17.0): |
| active_plane = 17 |
| elif any( |
| close(g, code) |
| for code in (10.0, 28.0, 30.0, 50.0, 51.0, 52.0, 53.0, 68.0, 69.0, 92.0, 92.1, 92.2, 92.3) |
| ): |
| return None |
| elif any(close(g, code) for code in (0.0, 1.0, 2.0, 3.0)): |
| motion = int(round(g)) |
| elif any(close(g, code) for code in (40.0, 43.0, 49.0, 61.0, 61.1, 64.0, 80.0, 91.1, 94.0)): |
| pass |
| else: |
| return None |
|
|
| if values.get("T"): |
| tool_value = values["T"][-1] |
| if abs(tool_value - round(tool_value)) > TOL: |
| return None |
| selected_tool = int(round(tool_value)) |
|
|
| if values.get("H"): |
| if not has_g43: |
| return None |
| h_value = values["H"][-1] |
| if abs(h_value - round(h_value)) > TOL or int(round(h_value)) != 1: |
| return None |
| length_offset = int(round(h_value)) |
| if has_g43: |
| if length_offset != 1: |
| return None |
| length_offset_active = True |
| if has_g49: |
| length_offset_active = False |
| length_offset = None |
|
|
| if values.get("S"): |
| spindle_speed = values["S"][-1] |
| if values.get("F"): |
| feed = values["F"][-1] |
|
|
| m_codes = values.get("M", []) |
| if any( |
| not any(close(m, allowed) for allowed in (0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 30.0)) |
| for m in m_codes |
| ): |
| return None |
| if len({round(m, 6) for m in m_codes}) != len(m_codes): |
| return None |
| if sum(any(close(m, code) for code in (3.0, 4.0, 5.0)) for m in m_codes) > 1: |
| return None |
| if any(close(m, 6.0) for m in m_codes) and any(close(m, code) for m in m_codes for code in (3.0, 4.0, 5.0)): |
| return None |
| if sum(any(close(m, code) for code in (2.0, 30.0)) for m in m_codes) > 1: |
| return None |
| if any(close(m, code) for m in m_codes for code in (2.0, 30.0)) and any( |
| close(m, code) for m in m_codes for code in (3.0, 4.0, 6.0) |
| ): |
| return None |
| if sum(any(close(m, code) for code in (7.0, 8.0, 9.0)) for m in m_codes) > 1: |
| return None |
| if any(close(m, 5.0) for m in m_codes): |
| spindle_on = False |
| if last_cut_block >= 0 and block > last_cut_block: |
| stop_after_cut = True |
| if any(close(m, 6.0) for m in m_codes): |
| if selected_tool != 1 or spindle_on or length_offset_active: |
| return None |
| tool_changed = True |
| if any(close(m, code) for m in m_codes for code in (3.0, 4.0)): |
| if not tool_changed or not close(spindle_speed, 6000.0): |
| return None |
| if any(close(m, 4.0) for m in m_codes): |
| return None |
| spindle_on = True |
| if any(close(m, code) for m in m_codes for code in (2.0, 30.0)): |
| if any(axis in values for axis in ("X", "Y", "Z")): |
| return None |
| if last_cut_block >= 0 and block > last_cut_block: |
| end_after_cut = True |
| stop_after_cut = True |
| spindle_on = False |
| program_ended = True |
|
|
| has_axis = any(axis in values for axis in ("X", "Y", "Z")) |
| if not has_axis: |
| continue |
| if motion is None or not absolute or not metric or not close(active_fixture, 54.0): |
| return None |
|
|
| nx = values.get("X", [x])[-1] |
| ny = values.get("Y", [y])[-1] |
| nz = values.get("Z", [z])[-1] |
| i_value = values.get("I", [None])[-1] |
| j_value = values.get("J", [None])[-1] |
| move = Move(block, motion, x, y, z, nx, ny, nz, feed, i_value, j_value) |
| has_xy_word = "X" in values or "Y" in values |
| moved_xy = has_xy_word and ( |
| move.start_x is None |
| or move.start_y is None |
| or move.end_x is None |
| or move.end_y is None |
| or move.xy_distance > TOL |
| or motion in (2, 3) |
| ) |
| moved_z = ( |
| move.start_z is not None |
| and move.end_z is not None |
| and abs(move.end_z - move.start_z) > TOL |
| ) |
|
|
| if motion in (2, 3): |
| if ( |
| active_plane != 17 |
| or not ("I" in values or "J" in values) |
| or None in (move.start_x, move.start_y, move.end_x, move.end_y) |
| ): |
| return None |
| i_offset = 0.0 if move.i is None else move.i |
| j_offset = 0.0 if move.j is None else move.j |
| radius = math.hypot(i_offset, j_offset) |
| end_radius = math.hypot( |
| float(move.end_x) - (float(move.start_x) + i_offset), |
| float(move.end_y) - (float(move.start_y) + j_offset), |
| ) |
| if radius <= TOL or abs(end_radius - radius) > max(0.01, radius * 1e-5): |
| return None |
| elif "I" in values or "J" in values: |
| return None |
|
|
| if motion == 0: |
| if moved_xy and ( |
| move.start_z is None |
| or move.end_z is None |
| or min(move.start_z, move.end_z) <= TOL |
| ): |
| return None |
| if moved_z and move.end_z is not None and move.end_z <= TOL: |
| return None |
| intersects_material_z = ( |
| move.end_z is not None |
| and (move.end_z <= TOL or move.start_z is not None and move.start_z <= TOL) |
| ) |
| is_cut = motion in (1, 2, 3) and intersects_material_z and (moved_xy or moved_z) |
| if is_cut: |
| if not ( |
| tool_changed |
| and spindle_on |
| and close(spindle_speed, 6000.0) |
| and close(active_fixture, 54.0) |
| ): |
| return None |
| if move.end_z < -8.0 - TOL: |
| return None |
| if moved_xy and not close(feed, 750.0): |
| return None |
| if moved_z and not moved_xy and (feed is None or feed <= 0.0): |
| return None |
| last_cut_block = block |
| retract_after_cut = False |
| if last_cut_block >= 0 and block > last_cut_block and motion == 0 and move.end_z is not None and move.end_z > TOL: |
| retract_after_cut = True |
| moves.append(move) |
| x, y, z = nx, ny, nz |
|
|
| if not ( |
| metric |
| and absolute |
| and close(active_fixture, 54.0) |
| and active_plane == 17 |
| and tool_changed |
| and program_ended |
| ): |
| return None |
| if not (last_cut_block >= 0 and stop_after_cut and end_after_cut and retract_after_cut): |
| return None |
| return {"moves": moves} |
|
|
|
|
| def native_check(path: Path) -> dict[str, object] | None: |
| if not path.is_file() or not 1_000 <= path.stat().st_size <= 20_000_000: |
| return None |
| checker = textwrap.dedent( |
| f""" |
| import json |
| import math |
| import FreeCAD as App |
| |
| FILE = {str(path)!r} |
| MARKER = {NATIVE_MARKER!r} |
| result = {{"ok": False}} |
| doc = None |
| |
| def near(value, expected, tol=1e-6): |
| return abs(float(value) - expected) <= tol |
| |
| def bbox_values(shape): |
| box = shape.BoundBox |
| return [box.XMin, box.XMax, box.YMin, box.YMax, box.ZMin, box.ZMax] |
| |
| try: |
| if tuple(App.Version()[:3]) != ("0", "21", "2"): |
| raise RuntimeError("wrong FreeCAD version") |
| doc = App.openDocument(FILE) |
| if doc is None: |
| raise RuntimeError("document did not open") |
| doc.recompute() |
| |
| jobs = [ |
| obj for obj in doc.Objects |
| if type(getattr(obj, "Proxy", None)).__module__ == "Path.Main.Job" |
| and type(getattr(obj, "Proxy", None)).__name__ == "ObjectJob" |
| ] |
| if len(jobs) != 1: |
| raise RuntimeError("expected one native Job") |
| job = jobs[0] |
| operations = list(job.Operations.Group) |
| controllers = list(job.Tools.Group) |
| models = list(job.Model.Group) |
| if len(operations) != 1 or len(controllers) != 1 or len(models) != 1: |
| raise RuntimeError("wrong Job group cardinality") |
| |
| op = operations[0] |
| if type(getattr(op, "Proxy", None)).__module__ != "Path.Op.MillFace": |
| raise RuntimeError("operation is not MillFace") |
| if type(op.Proxy).__name__ != "ObjectFace" or not bool(op.Active): |
| raise RuntimeError("inactive or invalid MillFace") |
| if not near(op.StartDepth.Value, 0.0) or not near(op.FinalDepth.Value, -8.0): |
| raise RuntimeError("wrong operation depths") |
| if op.SafeHeight.Value <= 0.0 or op.ClearanceHeight.Value <= 0.0: |
| raise RuntimeError("unsafe operation heights") |
| |
| expected_box = [-60.0, 60.0, -40.0, 40.0, -18.0, 0.0] |
| for shape in (models[0].Shape, job.Stock.Shape): |
| if shape.isNull() or not shape.isValid() or len(shape.Solids) != 1: |
| raise RuntimeError("model or stock is not one valid solid") |
| if any(not near(a, b) for a, b in zip(bbox_values(shape), expected_box)): |
| raise RuntimeError("model or zero-extension stock bounds are wrong") |
| for prop in ("ExtXneg", "ExtXpos", "ExtYneg", "ExtYpos", "ExtZneg", "ExtZpos"): |
| if not near(getattr(job.Stock, prop).Value, 0.0): |
| raise RuntimeError("stock extension is nonzero") |
| if str(job.PostProcessor).lower() != "linuxcnc" or "G54" not in list(job.Fixtures): |
| raise RuntimeError("wrong postprocessor or fixture") |
| |
| if len(op.Base) != 1 or len(op.Base[0][1]) != 1: |
| raise RuntimeError("Face operation lacks one base face") |
| base_obj, subnames = op.Base[0] |
| selected_face = base_obj.Shape.getElement(subnames[0]) |
| face_box = selected_face.BoundBox |
| if not ( |
| near(face_box.XMin, -60.0) and near(face_box.XMax, 60.0) |
| and near(face_box.YMin, -40.0) and near(face_box.YMax, 40.0) |
| and near(face_box.ZMin, 0.0) and near(face_box.ZMax, 0.0) |
| and near(abs(selected_face.normalAt(0, 0).z), 1.0) |
| ): |
| raise RuntimeError("operation is not based on the top face") |
| |
| controller = controllers[0] |
| if op.ToolController is not controller or int(controller.ToolNumber) != 1: |
| raise RuntimeError("wrong ToolController") |
| if not near(controller.SpindleSpeed, 6000.0) or str(controller.SpindleDir) != "Forward": |
| raise RuntimeError("wrong spindle configuration") |
| if not near(controller.HorizFeed.Value, 12.5): |
| raise RuntimeError("horizontal feed is not 750 mm/min") |
| tool = controller.Tool |
| descriptor = " ".join( |
| str(value) for value in ( |
| getattr(tool, "Label", ""), |
| getattr(tool, "ToolFamily", ""), |
| getattr(tool, "ShapeName", ""), |
| ) |
| ).lower().replace("_", " ").replace("-", " ") |
| if "face mill" not in descriptor: |
| raise RuntimeError("T1 is not identified as a face mill") |
| diameter = float(tool.Diameter.Value) |
| if not math.isfinite(diameter) or diameter <= 0.0 or diameter > 500.0: |
| raise RuntimeError("invalid tool diameter") |
| |
| commands = list(op.Path.Commands) |
| if len(commands) < 10: |
| raise RuntimeError("MillFace path is empty or trivial") |
| path_z = [float(c.Parameters["Z"]) for c in commands if "Z" in c.Parameters] |
| if not path_z or not near(min(path_z), -8.0, 1e-3): |
| raise RuntimeError("actual MillFace path misses final depth") |
| result = {{"ok": True, "tool_diameter": diameter}} |
| except Exception as exc: |
| result = {{"ok": False, "error": str(exc)}} |
| finally: |
| if doc is not None: |
| App.closeDocument(doc.Name) |
| print(MARKER + json.dumps(result, sort_keys=True)) |
| """ |
| ) |
| try: |
| with tempfile.TemporaryDirectory(prefix="task_c01_eval_") as tmp: |
| script = Path(tmp) / "check_native.py" |
| script.write_text(checker, encoding="utf-8") |
| completed = subprocess.run( |
| ["/usr/bin/freecadcmd", str(script)], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.STDOUT, |
| text=True, |
| timeout=90, |
| check=False, |
| ) |
| except (OSError, subprocess.SubprocessError): |
| return None |
| if completed.returncode != 0: |
| return None |
| reports = [line[len(NATIVE_MARKER) :] for line in completed.stdout.splitlines() if line.startswith(NATIVE_MARKER)] |
| if len(reports) != 1: |
| return None |
| try: |
| report = json.loads(reports[0]) |
| except (TypeError, json.JSONDecodeError): |
| return None |
| if not isinstance(report, dict) or report.get("ok") is not True: |
| return None |
| return report |
|
|
|
|
| def coverage_ok(moves: list[Move], tool_diameter: float) -> bool: |
| radius = tool_diameter / 2.0 |
| final_moves = [ |
| move |
| for move in moves |
| if move.motion in (1, 2, 3) |
| and close(move.start_z, -8.0) |
| and close(move.end_z, -8.0) |
| and move.xy_distance > TOL |
| ] |
| if not final_moves: |
| return False |
| xs = [value for move in final_moves for value in (move.start_x, move.end_x) if value is not None] |
| ys = [value for move in final_moves for value in (move.start_y, move.end_y) if value is not None] |
| if not xs or not ys: |
| return False |
| if min(xs) - radius > -60.0 + TOL or max(xs) + radius < 60.0 - TOL: |
| return False |
| if min(ys) - radius > -40.0 + TOL or max(ys) + radius < 40.0 - TOL: |
| return False |
| segments = [ |
| ((float(move.start_x), float(move.start_y)), (float(move.end_x), float(move.end_y))) |
| for move in final_moves |
| if None not in (move.start_x, move.start_y, move.end_x, move.end_y) |
| ] |
| if not segments: |
| return False |
| for x in range(-60, 61): |
| for y in range(-40, 41): |
| point = (float(x), float(y)) |
| if min(point_segment_distance(point, start, end) for start, end in segments) > radius + 0.1: |
| return False |
| travel = sum(move.xy_distance for move in final_moves) |
| return travel >= 0.60 * (120.0 * 80.0) / tool_diameter |
|
|
|
|
| def main() -> bool: |
| native = native_check(FCSTD_PATH) |
| if native is None: |
| return False |
| parsed = parse_nc(NC_PATH) |
| if parsed is None: |
| return False |
| diameter = native.get("tool_diameter") |
| moves = parsed.get("moves") |
| if not isinstance(diameter, (int, float)) or not isinstance(moves, list): |
| return False |
| return coverage_ok(moves, float(diameter)) |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| result = main() |
| except Exception: |
| result = False |
| print(True if result else False) |
|
|
