| from __future__ import annotations |
|
|
| import csv |
| import json |
| import math |
| import os |
| import subprocess |
| import tempfile |
| import textwrap |
| from pathlib import Path |
|
|
|
|
| TARGET = Path(os.environ.get("ENGIWORLD_EVAL_TARGET", "/home/user/Desktop")) |
| CSV_PATH = TARGET / "tool_library.csv" |
| STEP_PATH = TARGET / "multi_feature.step" |
| FCSTD_PATH = TARGET / "task-05.FCStd" |
| NC_PATH = TARGET / "task-05.nc" |
| NATIVE_MARKER = "TASK_C05_NATIVE=" |
| EXPECTED_TOOLS = ( |
| (1, "end mill", 16.0, 7000.0, 500.0, 5), |
| (2, "drill", 14.0, 7000.0, 500.0, 5), |
| (3, "drill", 12.0, 7000.0, 500.0, 5), |
| ) |
|
|
|
|
| def close(actual: float, expected: float, tolerance: float = 1e-6) -> bool: |
| return math.isfinite(actual) and abs(actual - expected) <= tolerance |
|
|
|
|
| def load_tool_library(path: Path) -> bool: |
| if not path.is_file() or not 40 <= path.stat().st_size <= 20_000: |
| return False |
| try: |
| with path.open(newline="", encoding="utf-8-sig") as stream: |
| reader = csv.DictReader(stream) |
| if reader.fieldnames != [ |
| "tool_number", |
| "type", |
| "diameter", |
| "spindle", |
| "feed", |
| "operation_count", |
| ]: |
| return False |
| rows = list(reader) |
| parsed = [] |
| for row in rows: |
| number = float(row["tool_number"]) |
| operation_count = float(row["operation_count"]) |
| if not close(number, round(number)) or not close(operation_count, round(operation_count)): |
| return False |
| parsed.append( |
| ( |
| int(round(number)), |
| row["type"].strip().lower(), |
| float(row["diameter"]), |
| float(row["spindle"]), |
| float(row["feed"]), |
| int(round(operation_count)), |
| ) |
| ) |
| except (OSError, TypeError, ValueError, csv.Error): |
| return False |
| if len(parsed) != len(EXPECTED_TOOLS): |
| return False |
| for actual, expected in zip(parsed, EXPECTED_TOOLS): |
| if actual[:2] != expected[:2] or actual[-1] != expected[-1]: |
| return False |
| if any(not close(float(a), float(e)) for a, e in zip(actual[2:5], expected[2:5])): |
| return False |
| return True |
|
|
|
|
| def native_check(fcstd_path: Path, step_path: Path, nc_path: Path) -> bool: |
| for path, minimum, maximum in ( |
| (fcstd_path, 1_000, 20_000_000), |
| (step_path, 1_000, 20_000_000), |
| (nc_path, 1_000, 5_000_000), |
| ): |
| if not path.is_file() or not minimum <= path.stat().st_size <= maximum: |
| return False |
|
|
| checker = textwrap.dedent( |
| r''' |
| import json |
| import math |
| import re |
| import FreeCAD as App |
| import Part |
| import Path.Post.Command as PathPostCommand |
| from Path.Post.Processor import PostProcessor |
| |
| FILE = __FILE__ |
| STEP_FILE = __STEP_FILE__ |
| NC_FILE = __NC_FILE__ |
| MARKER = __MARKER__ |
| TOL = 1e-4 |
| WORD_RE = re.compile(r"([A-Z])\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:E[+-]?\d+)?)", re.I) |
| HOLES = { |
| (-42.0, 0.0): (2, 14.0), |
| (42.0, 0.0): (2, 14.0), |
| (0.0, -28.0): (3, 12.0), |
| (0.0, 28.0): (3, 12.0), |
| } |
| EXPECTED_MODULES = [ |
| "Path.Op.MillFace", |
| "Path.Op.PocketShape", |
| "Path.Op.Drilling", |
| "Path.Op.Drilling", |
| "Path.Op.Profile", |
| ] |
| EXPECTED_CLASSES = ["ObjectFace", "ObjectPocket", "ObjectDrilling", "ObjectDrilling", "ObjectProfile"] |
| result = {"ok": False} |
| doc = None |
| |
| def near(value, expected, tolerance=TOL): |
| return math.isfinite(float(value)) and abs(float(value) - expected) <= tolerance |
| |
| def bounds(shape): |
| box = shape.BoundBox |
| return [box.XMin, box.XMax, box.YMin, box.YMax, box.ZMin, box.ZMax] |
| |
| def cylinders(shape): |
| found = [] |
| for face in shape.Faces: |
| if isinstance(face.Surface, Part.Cylinder): |
| surface = face.Surface |
| box = face.BoundBox |
| found.append(( |
| round(surface.Center.x, 4), |
| round(surface.Center.y, 4), |
| round(2.0 * surface.Radius, 4), |
| round(box.ZMin, 4), |
| round(box.ZMax, 4), |
| )) |
| return sorted(found) |
| |
| def check_shape(shape, expected_box, expected_cylinders, expected_volume, label): |
| if shape.isNull() or not shape.isValid() or len(shape.Solids) != 1: |
| raise RuntimeError(label + " is not one valid solid") |
| if any(not near(a, b, 1e-5) for a, b in zip(bounds(shape), expected_box)): |
| raise RuntimeError(label + " bounds are wrong") |
| if not near(shape.Volume, expected_volume, 1e-3): |
| raise RuntimeError(label + " volume is wrong") |
| if cylinders(shape) != sorted(expected_cylinders): |
| raise RuntimeError(label + " cylindrical geometry is wrong") |
| |
| def shape_of_reference(base, subname): |
| try: |
| return base.Shape.getElement(str(subname)) |
| except Exception: |
| return None |
| |
| def selected_points(operation): |
| points = [(float(point.x), float(point.y)) for point in operation.Locations] |
| disabled = set(str(value) for value in operation.Disabled) |
| for base, subnames in operation.Base: |
| for subname in subnames: |
| if "{}.{}".format(base.Name, subname) in disabled: |
| continue |
| point = operation.Proxy.holePosition(operation, base, subname) |
| if point is None: |
| raise RuntimeError("Drilling Base contains a non-hole feature") |
| points.append((float(point.x), float(point.y))) |
| return points |
| |
| def sampled_segments(operation, target_z, z_tolerance=0.03): |
| segments = [] |
| x = y = z = None |
| for command in operation.Path.Commands: |
| name = str(command.Name).upper() |
| params = command.Parameters |
| if name not in ("G0", "G00", "G1", "G01", "G2", "G02", "G3", "G03"): |
| continue |
| nx = float(params.get("X", x)) if params.get("X", x) is not None else None |
| ny = float(params.get("Y", y)) if params.get("Y", y) is not None else None |
| nz = float(params.get("Z", z)) if params.get("Z", z) is not None else None |
| cutting = name in ("G1", "G01", "G2", "G02", "G3", "G03") |
| if cutting and None not in (x, y, z, nx, ny, nz) and near(z, target_z, z_tolerance) and near(nz, target_z, z_tolerance): |
| start = (float(x), float(y)) |
| end = (float(nx), float(ny)) |
| if name in ("G2", "G02", "G3", "G03") and "I" in params and "J" in params: |
| cx = float(x) + float(params["I"]) |
| cy = float(y) + float(params["J"]) |
| radius = math.hypot(float(x) - cx, float(y) - cy) |
| a0 = math.atan2(float(y) - cy, float(x) - cx) |
| a1 = math.atan2(float(ny) - cy, float(nx) - cx) |
| if name in ("G2", "G02"): |
| sweep = -((a0 - a1) % (2.0 * math.pi)) |
| else: |
| sweep = (a1 - a0) % (2.0 * math.pi) |
| if near(sweep, 0.0, 1e-8) and math.hypot(end[0] - start[0], end[1] - start[1]) < TOL: |
| sweep = -2.0 * math.pi if name in ("G2", "G02") else 2.0 * math.pi |
| count = max(2, int(math.ceil(abs(sweep) * max(radius, 1.0) / 0.5))) |
| previous = start |
| for index in range(1, count + 1): |
| angle = a0 + sweep * index / count |
| point = (cx + radius * math.cos(angle), cy + radius * math.sin(angle)) |
| segments.append((previous, point)) |
| previous = point |
| elif math.hypot(end[0] - start[0], end[1] - start[1]) > TOL: |
| segments.append((start, end)) |
| x, y, z = nx, ny, nz |
| return segments |
| |
| def point_segment_distance(point, segment): |
| px, py = point |
| (ax, ay), (bx, by) = segment |
| dx, dy = bx - ax, by - ay |
| length2 = dx * dx + dy * dy |
| if length2 <= 1e-16: |
| return math.hypot(px - ax, py - ay) |
| t = max(0.0, min(1.0, ((px - ax) * dx + (py - ay) * dy) / length2)) |
| return math.hypot(px - (ax + t * dx), py - (ay + t * dy)) |
| |
| def arc_points(start, end, name, params): |
| if "I" not in params or "J" not in params: |
| raise RuntimeError("arc lacks I/J center offsets") |
| cx = start[0] + float(params["I"]) |
| cy = start[1] + float(params["J"]) |
| radius = math.hypot(start[0] - cx, start[1] - cy) |
| if radius <= TOL: |
| raise RuntimeError("arc radius is zero") |
| if abs(math.hypot(end[0] - cx, end[1] - cy) - radius) > 0.02: |
| raise RuntimeError("arc end radius differs from its start radius") |
| a0 = math.atan2(start[1] - cy, start[0] - cx) |
| a1 = math.atan2(end[1] - cy, end[0] - cx) |
| if name in ("G2", "G02"): |
| sweep = -((a0 - a1) % (2.0 * math.pi)) |
| else: |
| sweep = (a1 - a0) % (2.0 * math.pi) |
| if near(sweep, 0.0, 1e-8) and math.hypot(end[0] - start[0], end[1] - start[1]) < TOL: |
| sweep = -2.0 * math.pi if name in ("G2", "G02") else 2.0 * math.pi |
| count = max(2, int(math.ceil(abs(sweep) * radius / 0.5))) |
| points = [ |
| (cx + radius * math.cos(a0 + sweep * index / count), cy + radius * math.sin(a0 + sweep * index / count)) |
| for index in range(count + 1) |
| ] |
| points[-1] = end |
| return points |
| |
| def validate_area_motion(operation, kind): |
| safe_z = float(operation.SafeHeight.Value) |
| x = y = z = None |
| allowed = {"G0", "G00", "G1", "G01", "G2", "G02", "G3", "G03"} |
| for command in operation.Path.Commands: |
| name = str(command.Name).upper() |
| params = command.Parameters |
| if name.startswith(("M", "T", "S")): |
| raise RuntimeError(kind + " operation contains a tool or spindle command") |
| if name.startswith("G") and name not in allowed: |
| raise RuntimeError(kind + " contains an unexpected modal command") |
| if name not in allowed: |
| continue |
| nx = float(params.get("X", x)) if params.get("X", x) is not None else None |
| ny = float(params.get("Y", y)) if params.get("Y", y) is not None else None |
| nz = float(params.get("Z", z)) if params.get("Z", z) is not None else None |
| has_xy = "X" in params or "Y" in params |
| if name in ("G0", "G00") and has_xy: |
| if z is None or nz is None or float(z) < safe_z - TOL or float(nz) < safe_z - TOL: |
| raise RuntimeError(kind + " contains an unsafe low-Z XY rapid") |
| if name in ("G0", "G00") and "Z" in params: |
| if nz is None or ((z is None or float(nz) < float(z) - TOL) and float(nz) < safe_z - TOL): |
| raise RuntimeError(kind + " contains an unsafe downward Z rapid") |
| if name in ("G1", "G01", "G2", "G02", "G3", "G03"): |
| if None in (x, y, z, nx, ny, nz): |
| raise RuntimeError(kind + " cutting move has unknown coordinates") |
| lower_z = min(float(z), float(nz)) |
| limit = {"Face": 0.0, "Pocket": -6.0, "Profile": -18.0}[kind] |
| if lower_z < limit - 0.02: |
| raise RuntimeError(kind + " cuts below its final depth") |
| start = (float(x), float(y)) |
| end = (float(nx), float(ny)) |
| points = arc_points(start, end, name, params) if name in ("G2", "G02", "G3", "G03") else [start, end] |
| if kind == "Pocket" and any(abs(px) > 17.08 or abs(py) > 7.08 for px, py in points): |
| raise RuntimeError("Pocket cutter gouges outside the R8 pocket") |
| if kind == "Profile" and any(rectangle_distance(px, py) < 7.92 for px, py in points): |
| raise RuntimeError("Profile cutter enters the finished part") |
| x, y, z = nx, ny, nz |
| |
| def validate_drill_motion(operation): |
| x = y = z = None |
| retract_mode = None |
| cycle_active = False |
| allowed = {"G0", "G00", "G80", "G81", "G82", "G83", "G90", "G98", "G99"} |
| for command in operation.Path.Commands: |
| name = str(command.Name).upper() |
| params = command.Parameters |
| if name.startswith(("M", "T", "S")): |
| raise RuntimeError("Drilling operation contains a tool or spindle command") |
| if name.startswith("G") and name not in allowed: |
| raise RuntimeError("Drilling contains an unexpected motion command") |
| if name == "G98": |
| retract_mode = 98 |
| continue |
| if name == "G99": |
| retract_mode = 99 |
| continue |
| if name == "G80": |
| cycle_active = False |
| continue |
| if name in ("G0", "G00"): |
| nx = float(params.get("X", x)) if params.get("X", x) is not None else None |
| ny = float(params.get("Y", y)) if params.get("Y", y) is not None else None |
| nz = float(params.get("Z", z)) if params.get("Z", z) is not None else None |
| has_xy = "X" in params or "Y" in params |
| if has_xy and (z is None or nz is None or float(z) <= 1.0 or float(nz) <= 1.0): |
| raise RuntimeError("Drilling contains an unsafe low-Z XY rapid") |
| if "Z" in params and (nz is None or ((z is None or float(nz) < float(z) - TOL) and float(nz) <= 1.0)): |
| raise RuntimeError("Drilling contains an unsafe downward Z rapid") |
| x, y, z = nx, ny, nz |
| elif name in ("G81", "G82", "G83"): |
| if retract_mode not in (98, 99) or z is None: |
| raise RuntimeError("Drilling cycle lacks a safe retract mode") |
| nx = float(params.get("X", x)) if params.get("X", x) is not None else None |
| ny = float(params.get("Y", y)) if params.get("Y", y) is not None else None |
| if nx is None or ny is None or "R" not in params or "Z" not in params: |
| raise RuntimeError("Drilling cycle coordinates are incomplete") |
| return_z = float(z) if retract_mode == 98 else float(params["R"]) |
| if return_z <= 1.0: |
| raise RuntimeError("Drilling returns below the stock top") |
| cycle_active = True |
| x, y, z = nx, ny, return_z |
| if cycle_active: |
| raise RuntimeError("Drilling leaves a canned cycle active") |
| |
| def distance_to_path(point, segments): |
| if not segments: |
| return float("inf") |
| return min(point_segment_distance(point, segment) for segment in segments) |
| |
| def check_face_coverage(operation): |
| segments = sampled_segments(operation, 0.0) |
| if not segments: |
| raise RuntimeError("Face path is empty or trivial") |
| for ix in range(63): |
| x = -62.0 + 2.0 * ix |
| for iy in range(43): |
| y = -42.0 + 2.0 * iy |
| if distance_to_path((x, y), segments) > 8.08: |
| raise RuntimeError("Face path does not cover the complete stock top") |
| |
| def inside_rounded_pocket(x, y): |
| ax, ay = abs(x), abs(y) |
| if ax > 25.0 + TOL or ay > 15.0 + TOL: |
| return False |
| if ax <= 17.0 or ay <= 7.0: |
| return True |
| return (ax - 17.0) ** 2 + (ay - 7.0) ** 2 <= 64.0 + TOL |
| |
| def check_pocket_coverage(operation): |
| segments = sampled_segments(operation, -6.0) |
| if not segments: |
| raise RuntimeError("Pocket path does not clear the final depth") |
| for ix in range(101): |
| x = -25.0 + 0.5 * ix |
| for iy in range(61): |
| y = -15.0 + 0.5 * iy |
| if inside_rounded_pocket(x, y) and distance_to_path((x, y), segments) > 8.08: |
| raise RuntimeError("Pocket path leaves material at final depth") |
| all_cutting = [] |
| for depth in (-3.0, -6.0): |
| all_cutting.extend(sampled_segments(operation, depth)) |
| for segment in all_cutting: |
| for x, y in segment: |
| if abs(x) > 17.08 or abs(y) > 7.08: |
| raise RuntimeError("Pocket cutter gouges outside the R8 pocket") |
| |
| def rectangle_distance(x, y): |
| return math.hypot(max(abs(x) - 60.0, 0.0), max(abs(y) - 40.0, 0.0)) |
| |
| def check_profile_coverage(operation): |
| segments = sampled_segments(operation, -18.0) |
| if len(segments) < 4: |
| raise RuntimeError("Profile path is empty or not closed") |
| for segment in segments: |
| for x, y in segment: |
| if rectangle_distance(x, y) < 7.92: |
| raise RuntimeError("Profile cutter enters the finished part") |
| boundary = [] |
| for index in range(121): |
| x = -60.0 + index |
| boundary.extend(((x, -40.0), (x, 40.0))) |
| for index in range(81): |
| y = -40.0 + index |
| boundary.extend(((-60.0, y), (60.0, y))) |
| closed_contour = None |
| for start in range(len(segments)): |
| for end in range(start + 3, len(segments)): |
| first = segments[start][0] |
| last = segments[end][1] |
| if math.hypot(first[0] - last[0], first[1] - last[1]) > 0.12: |
| continue |
| candidate = segments[start : end + 1] |
| if all(distance_to_path(point, candidate) <= 8.08 for point in boundary): |
| closed_contour = candidate |
| break |
| if closed_contour is not None: |
| break |
| if closed_contour is None: |
| raise RuntimeError("Profile lacks a closed contour covering the complete outside boundary") |
| |
| def strip_comments(text): |
| output = [] |
| paren_depth = 0 |
| semicolon_comment = False |
| for char in text: |
| if semicolon_comment: |
| if char == "\n": |
| semicolon_comment = False |
| output.append(char) |
| elif paren_depth: |
| if char == "(": |
| paren_depth += 1 |
| elif char == ")": |
| paren_depth -= 1 |
| elif char == "\n": |
| output.append(char) |
| elif char == "(": |
| paren_depth = 1 |
| elif char == ")": |
| raise RuntimeError("unmatched NC comment terminator") |
| elif char == ";": |
| semicolon_comment = True |
| else: |
| output.append(char) |
| if paren_depth: |
| raise RuntimeError("unterminated NC comment") |
| return "".join(output) |
| |
| def canonical_nc(text): |
| canonical = [] |
| blocks = [line.strip().upper() for line in strip_comments(text).splitlines() if line.strip()] |
| wrappers = [index for index, block in enumerate(blocks) if block == "%"] |
| if wrappers: |
| if wrappers != [0, len(blocks) - 1]: |
| raise RuntimeError("percent wrappers are not a single outer pair") |
| blocks = blocks[1:-1] |
| for cleaned in blocks: |
| if "%" in cleaned: |
| raise RuntimeError("percent wrapper is embedded in an NC block") |
| words = [] |
| cursor = 0 |
| for match in WORD_RE.finditer(cleaned): |
| if cleaned[cursor:match.start()].strip(): |
| raise RuntimeError("malformed NC block") |
| letter = match.group(1) |
| value = float(match.group(2)) |
| if not math.isfinite(value): |
| raise RuntimeError("non-finite NC word") |
| if letter != "N": |
| if letter in ("G", "M", "T", "H"): |
| if not near(value, round(value), 1e-6): |
| raise RuntimeError("non-integral modal NC word") |
| value = int(round(value)) |
| if letter == "M" and value == 30: |
| value = 2 |
| else: |
| value = round(value, 3) |
| if value == -0.0: |
| value = 0.0 |
| words.append((letter, value)) |
| cursor = match.end() |
| if cleaned[cursor:].strip() or not words: |
| raise RuntimeError("malformed or empty NC block") |
| canonical.append(tuple(sorted(words))) |
| return canonical |
| |
| try: |
| version = App.Version() |
| if tuple(version[:3]) != ("0", "21", "2") or "b9bfa5c5507506e4515816414cd27f4851d00489" not in version: |
| raise RuntimeError("wrong FreeCAD build") |
| doc = App.openDocument(FILE) |
| if doc is None: |
| raise RuntimeError("FCStd 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 exactly one native Job") |
| job = jobs[0] |
| models = list(job.Model.Group) |
| controllers = list(job.Tools.Group) |
| operations = list(job.Operations.Group) |
| if len(models) != 1 or len(controllers) != 3 or len(operations) != 5: |
| raise RuntimeError("wrong Job group cardinality") |
| if [type(op.Proxy).__module__ for op in operations] != EXPECTED_MODULES: |
| raise RuntimeError("wrong native operation sequence") |
| if [type(op.Proxy).__name__ for op in operations] != EXPECTED_CLASSES: |
| raise RuntimeError("wrong native operation types") |
| path_ops = [obj for obj in doc.Objects if type(getattr(obj, "Proxy", None)).__module__.startswith("Path.Op.")] |
| if set(path_ops) != set(operations): |
| raise RuntimeError("FCStd contains ungrouped or fake Path operations") |
| if any(not bool(op.Active) for op in operations): |
| raise RuntimeError("an operation is inactive") |
| if str(job.PostProcessor).lower() != "linuxcnc" or list(job.Fixtures) != ["G54"]: |
| raise RuntimeError("wrong postprocessor or fixture") |
| if str(job.OrderOutputBy) != "Operation" or bool(job.SplitOutput): |
| raise RuntimeError("wrong operation output ordering") |
| if str(job.PostProcessorOutputFile) != "/home/user/Desktop/task-05.nc": |
| raise RuntimeError("wrong NC output path") |
| |
| source_objects = list(job.Proxy.baseObjects(job)) |
| if len(source_objects) != 1: |
| raise RuntimeError("Job must reference exactly one source model") |
| pocket_area = 50.0 * 30.0 - 4.0 * 8.0 ** 2 + math.pi * 8.0 ** 2 |
| removed_holes = 2.0 * math.pi * 7.0 ** 2 * 18.0 + 2.0 * math.pi * 6.0 ** 2 * 18.0 |
| expected_volume = 120.0 * 80.0 * 18.0 - pocket_area * 6.0 - removed_holes |
| source_cylinders = [ |
| (-42.0, 0.0, 14.0, 0.0, 18.0), |
| (42.0, 0.0, 14.0, 0.0, 18.0), |
| (0.0, -28.0, 12.0, 0.0, 18.0), |
| (0.0, 28.0, 12.0, 0.0, 18.0), |
| ] + [(x, y, 16.0, 12.0, 18.0) for x in (-17.0, 17.0) for y in (-7.0, 7.0)] |
| model_cylinders = [ |
| (-42.0, 0.0, 14.0, -18.0, 0.0), |
| (42.0, 0.0, 14.0, -18.0, 0.0), |
| (0.0, -28.0, 12.0, -18.0, 0.0), |
| (0.0, 28.0, 12.0, -18.0, 0.0), |
| ] + [(x, y, 16.0, -6.0, 0.0) for x in (-17.0, 17.0) for y in (-7.0, 7.0)] |
| actual_step = Part.read(STEP_FILE) |
| check_shape(actual_step, [-60.0, 60.0, -40.0, 40.0, 0.0, 18.0], source_cylinders, expected_volume, "input STEP") |
| check_shape(source_objects[0].Shape, [-60.0, 60.0, -40.0, 40.0, 0.0, 18.0], source_cylinders, expected_volume, "FCStd source") |
| expected_shape = Part.makeBox(120.0, 80.0, 18.0, App.Vector(-60.0, -40.0, 0.0)) |
| expected_pocket = Part.makeBox(34.0, 30.0, 6.0, App.Vector(-17.0, -15.0, 12.0)) |
| expected_pocket = expected_pocket.fuse(Part.makeBox(50.0, 14.0, 6.0, App.Vector(-25.0, -7.0, 12.0))) |
| for x in (-17.0, 17.0): |
| for y in (-7.0, 7.0): |
| expected_pocket = expected_pocket.fuse(Part.makeCylinder(8.0, 6.0, App.Vector(x, y, 12.0))) |
| expected_shape = expected_shape.cut(expected_pocket) |
| for (x, y), (_tool, diameter) in HOLES.items(): |
| expected_shape = expected_shape.cut(Part.makeCylinder(diameter / 2.0, 20.0, App.Vector(x, y, -1.0))) |
| expected_shape = expected_shape.removeSplitter() |
| if not near(actual_step.common(expected_shape).Volume, expected_volume, 1e-3): |
| raise RuntimeError("input STEP differs from the required finished geometry") |
| if not near(actual_step.common(source_objects[0].Shape).Volume, expected_volume, 1e-3): |
| raise RuntimeError("FCStd source differs from the submitted STEP") |
| check_shape(models[0].Shape, [-60.0, 60.0, -40.0, 40.0, -18.0, 0.0], model_cylinders, expected_volume, "Job model") |
| translated = actual_step.copy() |
| translated.translate(App.Vector(0.0, 0.0, -18.0)) |
| if not near(translated.common(models[0].Shape).Volume, expected_volume, 1e-3): |
| raise RuntimeError("Job model differs from the translated STEP") |
| if not (near(models[0].Placement.Base.x, 0.0) and near(models[0].Placement.Base.y, 0.0) and near(models[0].Placement.Base.z, -18.0)): |
| raise RuntimeError("G54 is not at the source top-face center") |
| |
| stock = job.Stock |
| if stock.Shape.isNull() or not stock.Shape.isValid() or len(stock.Shape.Solids) != 1: |
| raise RuntimeError("stock is invalid") |
| if any(not near(a, b, 1e-5) for a, b in zip(bounds(stock.Shape), [-62.0, 62.0, -42.0, 42.0, -18.0, 1.0])): |
| raise RuntimeError("stock bounds are wrong") |
| if not near(stock.Shape.Volume, 124.0 * 84.0 * 19.0, 1e-3): |
| raise RuntimeError("stock volume is wrong") |
| expected_stock = Part.makeBox(124.0, 84.0, 19.0, App.Vector(-62.0, -42.0, -18.0)) |
| if not near(stock.Shape.common(expected_stock).Volume, expected_stock.Volume, 1e-3): |
| raise RuntimeError("stock is not the required complete rectangular block") |
| tool_map = {} |
| expected_tools = {1: ("endmill", 16.0), 2: ("drill", 14.0), 3: ("drill", 12.0)} |
| for controller in controllers: |
| if type(getattr(controller, "Proxy", None)).__module__ != "Path.Tool.Controller" or type(controller.Proxy).__name__ != "ToolController": |
| raise RuntimeError("controller is not native") |
| number = int(controller.ToolNumber) |
| if number in tool_map or number not in expected_tools: |
| raise RuntimeError("invalid or duplicate tool number") |
| tool = controller.Tool |
| if type(getattr(tool, "Proxy", None)).__module__ != "Path.Tool.Bit" or type(tool.Proxy).__name__ != "ToolBit": |
| raise RuntimeError("controller does not reference a native ToolBit") |
| shape_name, diameter = expected_tools[number] |
| if str(tool.ShapeName).lower() != shape_name or not near(tool.Diameter.Value, diameter): |
| raise RuntimeError("tool type or diameter is wrong") |
| if number in (2, 3) and not near(tool.TipAngle.Value, 118.0): |
| raise RuntimeError("drill tip angle is wrong") |
| if not near(controller.SpindleSpeed, 7000.0) or str(controller.SpindleDir) != "Forward": |
| raise RuntimeError("spindle configuration is wrong") |
| if not near(controller.HorizFeed.Value, 500.0 / 60.0) or not near(controller.VertFeed.Value, 500.0 / 60.0): |
| raise RuntimeError("feed does not match the CSV") |
| controller_commands = [ |
| command for command in controller.Path.Commands |
| if not str(command.Name).strip().startswith("(") |
| ] |
| if [str(command.Name).upper() for command in controller_commands] != ["M6", "M3"]: |
| raise RuntimeError("ToolController contains unexpected tool or spindle commands") |
| change, spindle = controller_commands |
| if set(change.Parameters) != {"T"} or not near(change.Parameters["T"], float(number)): |
| raise RuntimeError("ToolController changes to the wrong tool") |
| if set(spindle.Parameters) != {"S"} or not near(spindle.Parameters["S"], 7000.0): |
| raise RuntimeError("ToolController spindle command is wrong") |
| tool_map[number] = controller |
| |
| face, pocket, drill14, drill12, profile = operations |
| expected_assignment = [1, 1, 2, 3, 1] |
| if [int(op.ToolController.ToolNumber) for op in operations] != expected_assignment: |
| raise RuntimeError("operation-to-tool mapping is wrong") |
| for op in operations: |
| if op.ToolController not in controllers or len(op.Path.Commands) < 8: |
| raise RuntimeError("operation uses an external tool or has no real path") |
| if op.SafeHeight.Value <= 1.0 or op.ClearanceHeight.Value <= op.SafeHeight.Value: |
| raise RuntimeError("operation heights are unsafe") |
| |
| if not near(face.StartDepth.Value, 1.0) or not near(face.FinalDepth.Value, 0.0) or face.StepDown.Value <= 0.0: |
| raise RuntimeError("Face depth contract is wrong") |
| if any(base is not models[0] for base, _names in face.Base): |
| raise RuntimeError("Face must reference the Job model") |
| face_refs = [shape_of_reference(base, name) for base, names in face.Base for name in names] |
| if len(face_refs) != 1 or face_refs[0] is None or not near(face_refs[0].BoundBox.ZMin, 0.0) or not near(face_refs[0].BoundBox.ZMax, 0.0): |
| raise RuntimeError("Face does not reference the model top") |
| check_face_coverage(face) |
| validate_area_motion(face, "Face") |
| |
| if not near(pocket.StartDepth.Value, 0.0) or not near(pocket.FinalDepth.Value, -6.0) or pocket.StepDown.Value <= 0.0: |
| raise RuntimeError("Pocket depth contract is wrong") |
| if any(base is not models[0] for base, _names in pocket.Base): |
| raise RuntimeError("Pocket must reference the Job model") |
| pocket_refs = [shape_of_reference(base, name) for base, names in pocket.Base for name in names] |
| if len(pocket_refs) != 1 or pocket_refs[0] is None: |
| raise RuntimeError("Pocket must reference one bottom face") |
| pbox = pocket_refs[0].BoundBox |
| if not (near(pbox.ZMin, -6.0) and near(pbox.ZMax, -6.0) and near(pbox.XLength, 50.0) and near(pbox.YLength, 30.0)): |
| raise RuntimeError("Pocket bottom face is wrong") |
| check_pocket_coverage(pocket) |
| validate_area_motion(pocket, "Pocket") |
| |
| assignments = [] |
| for operation, expected_tool in ((drill14, 2), (drill12, 3)): |
| if not near(operation.StartDepth.Value, 0.0) or not near(operation.FinalDepth.Value, -19.0): |
| raise RuntimeError("Drilling nominal depth is wrong") |
| if str(operation.ExtraOffset) != "Drill Tip" or str(operation.RetractMode) not in ("G98", "G99"): |
| raise RuntimeError("Drilling tip or retract mode is wrong") |
| if operation.RetractHeight.Value <= 1.0: |
| raise RuntimeError("Drilling retract height is unsafe") |
| points = selected_points(operation) |
| expected_points = sorted(point for point, contract in HOLES.items() if contract[0] == expected_tool) |
| if sorted((round(x, 4), round(y, 4)) for x, y in points) != expected_points: |
| raise RuntimeError("Drilling hole assignment is wrong") |
| diameter = HOLES[expected_points[0]][1] |
| tip_length = (diameter / 2.0) / math.tan(math.radians(118.0 / 2.0)) |
| expected_cycle_z = -19.0 - tip_length |
| cycles = [] |
| names = [str(command.Name).upper() for command in operation.Path.Commands] |
| if not any(name in ("G98", "G99") for name in names) or "G80" not in names: |
| raise RuntimeError("Drilling path lacks retract mode or cycle cancel") |
| for command in operation.Path.Commands: |
| if str(command.Name).upper() not in ("G81", "G82", "G83"): |
| continue |
| params = command.Parameters |
| if not all(name in params for name in ("X", "Y", "Z", "R", "F")): |
| raise RuntimeError("Drilling cycle is incomplete") |
| if not near(params["Z"], expected_cycle_z, 0.01) or float(params["R"]) <= 1.0 or not near(params["F"], 500.0 / 60.0): |
| raise RuntimeError("Drilling cycle depth, retract, or feed is wrong") |
| cycles.append((round(float(params["X"]), 4), round(float(params["Y"]), 4))) |
| if sorted(cycles) != expected_points: |
| raise RuntimeError("native path does not drill each hole exactly once") |
| validate_drill_motion(operation) |
| assignments.extend((x, y, expected_tool) for x, y in cycles) |
| if sorted(assignments) != sorted((x, y, contract[0]) for (x, y), contract in HOLES.items()): |
| raise RuntimeError("drilling operations do not cover all holes exactly once") |
| |
| if not near(profile.StartDepth.Value, 0.0) or not near(profile.FinalDepth.Value, -18.0) or profile.StepDown.Value <= 0.0: |
| raise RuntimeError("Profile depth contract is wrong") |
| if str(profile.Side) != "Outside" or not bool(profile.UseComp) or bool(profile.processHoles): |
| raise RuntimeError("Profile is not an outside-only compensated contour") |
| check_profile_coverage(profile) |
| validate_area_motion(profile, "Profile") |
| |
| post_groups = PathPostCommand.buildPostList(job) |
| if len(post_groups) != 1 or not post_groups[0][1]: |
| raise RuntimeError("unable to rebuild the Job post list") |
| regenerated = PostProcessor.load("linuxcnc").export(post_groups[0][1], "-", "--no-show-editor") |
| with open(NC_FILE, "r", encoding="utf-8", errors="strict") as stream: |
| submitted = stream.read() |
| expected_nc = canonical_nc(regenerated) |
| submitted_nc = canonical_nc(submitted) |
| if not expected_nc or submitted_nc != expected_nc: |
| raise RuntimeError("submitted NC does not match this FCStd Job") |
| result = {"ok": True, "operations": 5, "nc_blocks": len(expected_nc), "assignments": len(assignments)} |
| except Exception as exc: |
| result = {"ok": False, "error": str(exc)} |
| finally: |
| if doc is not None: |
| try: |
| App.closeDocument(doc.Name) |
| except Exception: |
| pass |
| print(MARKER + json.dumps(result, sort_keys=True)) |
| ''' |
| ) |
| checker = checker.replace("__FILE__", repr(str(fcstd_path))) |
| checker = checker.replace("__STEP_FILE__", repr(str(step_path))) |
| checker = checker.replace("__NC_FILE__", repr(str(nc_path))) |
| checker = checker.replace("__MARKER__", repr(NATIVE_MARKER)) |
| try: |
| with tempfile.TemporaryDirectory(prefix="task_c05_eval_") as temp_dir: |
| script = Path(temp_dir) / "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=240, |
| check=False, |
| ) |
| except (OSError, subprocess.SubprocessError): |
| return False |
| if completed.returncode != 0: |
| return False |
| reports = [line[len(NATIVE_MARKER) :] for line in completed.stdout.splitlines() if line.startswith(NATIVE_MARKER)] |
| if len(reports) != 1: |
| return False |
| try: |
| report = json.loads(reports[0]) |
| except (TypeError, json.JSONDecodeError): |
| return False |
| return isinstance(report, dict) and report.get("ok") is True |
|
|
|
|
| def main() -> bool: |
| return load_tool_library(CSV_PATH) and native_check(FCSTD_PATH, STEP_PATH, NC_PATH) |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| ok = main() |
| except Exception: |
| ok = False |
| print(True if ok else False) |
|
|
