| from __future__ import annotations |
|
|
| import math |
| import os |
| import re |
| from dataclasses import dataclass, field |
| from pathlib import Path |
|
|
|
|
| TARGET = Path(os.environ.get("EVAL_TARGET_DIR", r"C:\Users\User\Desktop")) |
| NC_NAME = "task-10.nc" |
| MAX_BYTES = 2_000_000 |
| MAX_LINES = 20_000 |
| MAX_EXECUTED_BLOCKS = 50_000 |
| MAX_SEGMENTS = 8_000 |
| MAX_SAMPLES = 250_000 |
| TOOL_RADIUS_MM = 4.0 |
| SPINDLE_RPM = 8000.0 |
| FEED_MM_MIN = 500.0 |
| POCKET_HALF_X_MM = 21.0 |
| POCKET_HALF_Y_MM = 13.0 |
| CENTER_LIMIT_X_MM = POCKET_HALF_X_MM - TOOL_RADIUS_MM |
| CENTER_LIMIT_Y_MM = POCKET_HALF_Y_MM - TOOL_RADIUS_MM |
| FIXTURE_RELATIVE_BOX = (-60.0, 60.0, 39.0, 51.0, -16.0, 8.0) |
| REQUIRED_FIXTURE_CLEARANCE_MM = 3.0 |
| WORD_RE = re.compile(r"([A-Z])\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+))") |
| INTEGER_WORDS = {"N", "O", "M", "T", "H", "D", "P", "L"} |
| ALLOWED_WORDS = set("NOGMXYZIJKRFS THDPL".replace(" ", "")) |
| ALLOWED_G = { |
| 0.0, 1.0, 2.0, 3.0, 17.0, 20.0, 21.0, 28.0, 40.0, 41.0, 42.0, |
| 43.0, 49.0, 52.0, 53.0, 54.0, 55.0, 56.0, 57.0, 58.0, 59.0, |
| 80.0, 90.0, 91.0, 94.0, |
| } |
| ALLOWED_M = {2, 3, 4, 5, 6, 8, 9, 30, 98, 99} |
|
|
|
|
| class EvaluationError(ValueError): |
| pass |
|
|
|
|
| @dataclass(frozen=True) |
| class Point: |
| x: float |
| y: float |
| z: float |
|
|
|
|
| @dataclass |
| class Block: |
| line_no: int |
| words: dict[str, list[float]] |
|
|
|
|
| @dataclass |
| class Segment: |
| start: Point |
| end: Point |
| samples: list[Point] |
| motion: int |
| tool: int | None |
| spindle: float | None |
| spindle_on: bool |
| feed: float | None |
| wcs: str | None |
| local_shift: Point |
| length_comp: bool |
| h_offset: int | None |
| machine: bool |
|
|
|
|
| @dataclass |
| class State: |
| units: str | None = None |
| absolute: bool | None = None |
| motion: int | None = None |
| current: Point = Point(0.0, 0.0, 0.0) |
| pending_tool: int | None = None |
| tool: int | None = None |
| spindle: float | None = None |
| spindle_on: bool = False |
| feed: float | None = None |
| wcs: str | None = None |
| local_shift: Point = Point(0.0, 0.0, 0.0) |
| length_comp: bool = False |
| h_offset: int | None = None |
|
|
|
|
| @dataclass |
| class ProgramResult: |
| segments: list[Segment] = field(default_factory=list) |
| selected_tools: list[int] = field(default_factory=list) |
| changed_tools: list[int] = field(default_factory=list) |
| called_programs: list[int] = field(default_factory=list) |
| executed_blocks: int = 0 |
| sample_count: int = 0 |
| terminated: bool = False |
|
|
|
|
| def close(a: float, b: float, tolerance: float) -> bool: |
| return abs(a - b) <= tolerance |
|
|
|
|
| def integer(value: float, label: str) -> int: |
| rounded = int(round(value)) |
| if abs(value - rounded) > 1e-4: |
| raise EvaluationError(f"{label} must be integer-valued") |
| return rounded |
|
|
|
|
| def distance(a: Point, b: Point) -> float: |
| return math.dist((a.x, a.y, a.z), (b.x, b.y, b.z)) |
|
|
|
|
| def strip_comments(src: str) -> list[str]: |
| lines: list[str] = [] |
| depth = 0 |
| for raw in src.upper().splitlines(): |
| clean: list[str] = [] |
| for char in raw: |
| if char == ";" and depth == 0: |
| break |
| if char == "(": |
| depth += 1 |
| elif char == ")": |
| if depth == 0: |
| raise EvaluationError("unmatched comment") |
| depth -= 1 |
| elif depth == 0: |
| clean.append(char) |
| lines.append("".join(clean).strip()) |
| if depth: |
| raise EvaluationError("unterminated comment") |
| return lines |
|
|
|
|
| def tokenize(src: str) -> tuple[list[int], dict[int, list[Block]]]: |
| if len(src.encode("utf-8")) > MAX_BYTES or len(src.splitlines()) > MAX_LINES: |
| raise EvaluationError("program exceeds resource limits") |
| order: list[int] = [] |
| programs: dict[int, list[Block]] = {} |
| current: int | None = None |
| for line_no, line in enumerate(strip_comments(src), 1): |
| if not line or line == "%": |
| continue |
| if any(char in line for char in "#[]="): |
| raise EvaluationError("expressions and macros are not accepted") |
| found = WORD_RE.findall(line) |
| residue = re.sub(r"[\s/]+", "", WORD_RE.sub("", line)) |
| if not found or residue: |
| raise EvaluationError(f"unknown executable text on line {line_no}") |
| words: dict[str, list[float]] = {} |
| for letter, raw in found: |
| if letter not in ALLOWED_WORDS: |
| raise EvaluationError(f"unsupported address {letter}") |
| value = float(raw) |
| if not math.isfinite(value) or abs(value) > 1e7: |
| raise EvaluationError("non-finite or excessive numeric value") |
| words.setdefault(letter, []).append(value) |
| for letter, values in words.items(): |
| if letter not in {"G", "M"} and len(values) > 1: |
| raise EvaluationError(f"duplicate {letter} address") |
| if letter in INTEGER_WORDS: |
| for value in values: |
| integer(value, letter) |
| if "O" in words: |
| if len(words) != 1: |
| raise EvaluationError("O program label must be on its own line") |
| current = integer(words["O"][0], "O") |
| if current in programs: |
| raise EvaluationError("duplicate O program") |
| order.append(current) |
| programs[current] = [] |
| continue |
| if current is None: |
| raise EvaluationError("executable block before first O program") |
| programs[current].append(Block(line_no, words)) |
| if not order: |
| raise EvaluationError("missing O program") |
| return order, programs |
|
|
|
|
| def validate_program_structure(order: list[int], programs: dict[int, list[Block]]) -> None: |
| main = order[0] |
| for number in order: |
| blocks = programs[number] |
| terminals: list[tuple[int, int]] = [] |
| for index, block in enumerate(blocks): |
| for value in block.words.get("M", []): |
| code = integer(value, "M") |
| if code not in ALLOWED_M: |
| raise EvaluationError(f"unsupported M{code}") |
| if code in {2, 30, 99}: |
| terminals.append((index, code)) |
| expected = {2, 30} if number == main else {99} |
| if len(terminals) != 1 or terminals[0][1] not in expected: |
| raise EvaluationError(f"invalid terminal for O{number}") |
| if terminals[0][0] != len(blocks) - 1: |
| raise EvaluationError(f"code after terminal in O{number}") |
|
|
|
|
| def line_samples(a: Point, b: Point, spacing: float = 0.5) -> list[Point]: |
| length = distance(a, b) |
| count = max(1, min(4000, int(math.ceil(length / spacing)))) |
| return [ |
| Point( |
| a.x + (b.x - a.x) * index / count, |
| a.y + (b.y - a.y) * index / count, |
| a.z + (b.z - a.z) * index / count, |
| ) |
| for index in range(count + 1) |
| ] |
|
|
|
|
| def arc_center_from_r(a: Point, b: Point, radius_word: float, clockwise: bool) -> tuple[float, float]: |
| chord = math.hypot(b.x - a.x, b.y - a.y) |
| radius = abs(radius_word) |
| if chord <= 1e-9 or radius < chord / 2.0 - 1e-6: |
| raise EvaluationError("invalid R arc") |
| mx, my = (a.x + b.x) / 2.0, (a.y + b.y) / 2.0 |
| height = math.sqrt(max(radius * radius - (chord / 2.0) ** 2, 0.0)) |
| nx, ny = -(b.y - a.y) / chord, (b.x - a.x) / chord |
| candidates = [(mx + nx * height, my + ny * height), (mx - nx * height, my - ny * height)] |
| choices: list[tuple[float, float, float]] = [] |
| for cx, cy in candidates: |
| a0 = math.atan2(a.y - cy, a.x - cx) |
| a1 = math.atan2(b.y - cy, b.x - cx) |
| sweep = (a0 - a1) % (2 * math.pi) if clockwise else (a1 - a0) % (2 * math.pi) |
| choices.append((sweep, cx, cy)) |
| desired_major = radius_word < 0 |
| filtered = [value for value in choices if (value[0] > math.pi) == desired_major] |
| _, cx, cy = (filtered or choices)[0] |
| return cx, cy |
|
|
|
|
| def arc_samples(a: Point, b: Point, words: dict[str, list[float]], factor: float, clockwise: bool) -> list[Point]: |
| if "I" in words or "J" in words: |
| if "I" not in words or "J" not in words: |
| raise EvaluationError("arc requires both I and J") |
| cx = a.x + words["I"][-1] * factor |
| cy = a.y + words["J"][-1] * factor |
| elif "R" in words: |
| cx, cy = arc_center_from_r(a, b, words["R"][-1] * factor, clockwise) |
| else: |
| raise EvaluationError("arc requires I/J or R") |
| radius = math.hypot(a.x - cx, a.y - cy) |
| if radius <= 1e-6 or not close(math.hypot(b.x - cx, b.y - cy), radius, 0.25): |
| raise EvaluationError("invalid arc geometry") |
| a0 = math.atan2(a.y - cy, a.x - cx) |
| a1 = math.atan2(b.y - cy, b.x - cx) |
| sweep = (a0 - a1) % (2 * math.pi) if clockwise else (a1 - a0) % (2 * math.pi) |
| if sweep <= 1e-9: |
| sweep = 2 * math.pi |
| count = max(12, min(4000, int(math.ceil(radius * sweep / 0.5)))) |
| direction = -1.0 if clockwise else 1.0 |
| return [ |
| Point( |
| cx + radius * math.cos(a0 + direction * sweep * index / count), |
| cy + radius * math.sin(a0 + direction * sweep * index / count), |
| a.z + (b.z - a.z) * index / count, |
| ) |
| for index in range(count + 1) |
| ] |
|
|
|
|
| def execute(src: str) -> ProgramResult: |
| order, programs = tokenize(src) |
| validate_program_structure(order, programs) |
| result = ProgramResult() |
| state = State() |
| active_calls: list[int] = [] |
|
|
| def run(number: int) -> None: |
| if number in active_calls or len(active_calls) >= 8: |
| raise EvaluationError("recursive or excessive subprogram calls") |
| active_calls.append(number) |
| for block in programs[number]: |
| result.executed_blocks += 1 |
| if result.executed_blocks > MAX_EXECUTED_BLOCKS: |
| raise EvaluationError("executed-block limit exceeded") |
| words = block.words |
| gcodes = words.get("G", []) |
| mcodes = [integer(value, "M") for value in words.get("M", [])] |
| for code in mcodes: |
| if code not in ALLOWED_M: |
| raise EvaluationError(f"unsupported M{code}") |
| for value in gcodes: |
| if not any(close(value, allowed, 1e-6) for allowed in ALLOWED_G) and not close(value, 54.1, 1e-6): |
| raise EvaluationError(f"unsupported G{value:g}") |
|
|
| if any(close(value, 20.0, 1e-6) for value in gcodes): |
| state.units = "inch" |
| if any(close(value, 21.0, 1e-6) for value in gcodes): |
| state.units = "mm" |
| factor = 25.4 if state.units == "inch" else 1.0 |
| machine = any(close(value, 28.0, 1e-6) or close(value, 53.0, 1e-6) for value in gcodes) |
| g52 = any(close(value, 52.0, 1e-6) for value in gcodes) |
| if g52: |
| if state.units is None: |
| raise EvaluationError("G52 before units") |
| state.local_shift = Point( |
| words.get("X", [state.local_shift.x / factor])[-1] * factor, |
| words.get("Y", [state.local_shift.y / factor])[-1] * factor, |
| words.get("Z", [state.local_shift.z / factor])[-1] * factor, |
| ) |
| if max(abs(state.local_shift.x), abs(state.local_shift.y), abs(state.local_shift.z)) > 1000.0: |
| raise EvaluationError("excessive G52 shift") |
|
|
| for value in gcodes: |
| rounded = int(round(value)) |
| if close(value, 90.0, 1e-6): |
| state.absolute = True |
| elif close(value, 91.0, 1e-6): |
| state.absolute = False |
| elif rounded in {0, 1, 2, 3} and close(value, float(rounded), 1e-6): |
| state.motion = rounded |
| elif rounded in {54, 55, 56, 57, 58, 59} and close(value, float(rounded), 1e-6): |
| state.wcs = f"G{rounded}" |
| elif close(value, 54.1, 1e-6): |
| if "P" not in words: |
| raise EvaluationError("G54.1 requires P") |
| p_value = integer(words["P"][-1], "P") |
| if p_value <= 0: |
| raise EvaluationError("invalid G54.1 P") |
| state.wcs = f"G54.1P{p_value}" |
| elif close(value, 43.0, 1e-6): |
| state.length_comp = True |
| elif close(value, 49.0, 1e-6): |
| state.length_comp = False |
| state.h_offset = None |
|
|
| if "T" in words: |
| state.pending_tool = integer(words["T"][-1], "T") |
| result.selected_tools.append(state.pending_tool) |
| if "S" in words: |
| state.spindle = words["S"][-1] |
| if "F" in words: |
| state.feed = words["F"][-1] * factor |
| if "H" in words: |
| state.h_offset = integer(words["H"][-1], "H") |
| if 6 in mcodes: |
| if state.pending_tool is None: |
| raise EvaluationError("M6 without T") |
| state.tool = state.pending_tool |
| result.changed_tools.append(state.tool) |
| if 3 in mcodes or 4 in mcodes: |
| state.spindle_on = True |
| if 5 in mcodes: |
| state.spindle_on = False |
|
|
| has_axis = any(axis in words for axis in ("X", "Y", "Z")) |
| if has_axis and not (machine or g52): |
| if state.units is None or state.absolute is None or state.motion is None: |
| raise EvaluationError("motion before units/distance/motion mode") |
|
|
| def coordinate(axis: str, old: float) -> float: |
| if axis not in words: |
| return old |
| value = words[axis][-1] * factor |
| return value if state.absolute else old + value |
|
|
| new = Point( |
| coordinate("X", state.current.x), |
| coordinate("Y", state.current.y), |
| coordinate("Z", state.current.z), |
| ) |
| samples = ( |
| arc_samples(state.current, new, words, factor, state.motion == 2) |
| if state.motion in {2, 3} |
| else line_samples(state.current, new) |
| ) |
| result.sample_count += len(samples) |
| if len(result.segments) >= MAX_SEGMENTS or result.sample_count > MAX_SAMPLES: |
| raise EvaluationError("geometry resource limit exceeded") |
| result.segments.append( |
| Segment( |
| state.current, |
| new, |
| samples, |
| state.motion, |
| state.tool, |
| state.spindle, |
| state.spindle_on, |
| state.feed, |
| state.wcs, |
| state.local_shift, |
| state.length_comp, |
| state.h_offset, |
| False, |
| ) |
| ) |
| state.current = new |
| elif has_axis and machine and state.motion in {1, 2, 3}: |
| result.segments.append( |
| Segment( |
| state.current, state.current, [state.current], state.motion, state.tool, |
| state.spindle, state.spindle_on, state.feed, state.wcs, state.local_shift, |
| state.length_comp, state.h_offset, True, |
| ) |
| ) |
|
|
| if 98 in mcodes: |
| if "P" not in words: |
| raise EvaluationError("M98 requires P") |
| target = integer(words["P"][-1], "P") |
| repeats = integer(words.get("L", [1])[-1], "L") |
| if target not in programs or target == order[0] or not 1 <= repeats <= 20: |
| raise EvaluationError("invalid M98 target or repeat") |
| result.called_programs.extend([target] * repeats) |
| for _ in range(repeats): |
| run(target) |
| if number == order[0] and (2 in mcodes or 30 in mcodes): |
| result.terminated = True |
| break |
| if number != order[0] and 99 in mcodes: |
| break |
| active_calls.pop() |
|
|
| run(order[0]) |
| if set(result.called_programs) != set(order[1:]): |
| raise EvaluationError("unreferenced or missing subprogram") |
| return result |
|
|
|
|
| def horizontal(segment: Segment, tolerance: float = 0.2) -> bool: |
| return abs(segment.start.z - segment.end.z) <= tolerance and math.hypot( |
| segment.end.x - segment.start.x, segment.end.y - segment.start.y |
| ) > 1e-4 |
|
|
|
|
| def point_box_distance(point: Point, box: tuple[float, ...]) -> float: |
| xmin, xmax, ymin, ymax, zmin, zmax = box |
| return math.sqrt( |
| max(xmin - point.x, 0.0, point.x - xmax) ** 2 |
| + max(ymin - point.y, 0.0, point.y - ymax) ** 2 |
| + max(zmin - point.z, 0.0, point.z - zmax) ** 2 |
| ) |
|
|
|
|
| def covered(points: list[Point], x: float, y: float, tolerance: float) -> bool: |
| return any(math.hypot(point.x - x, point.y - y) <= tolerance for point in points) |
|
|
|
|
| def validate_pocket(result: ProgramResult) -> None: |
| if not result.terminated or not result.segments: |
| raise EvaluationError("program did not terminate after real motion") |
| if not result.selected_tools or any(tool != 1 for tool in result.selected_tools): |
| raise EvaluationError("only T1 may be selected") |
| if not result.changed_tools or any(tool != 1 for tool in result.changed_tools): |
| raise EvaluationError("only T1 may be changed") |
| if any(segment.machine and segment.motion in {1, 2, 3} for segment in result.segments): |
| raise EvaluationError("machine-coordinate cutting is not pocket geometry") |
|
|
| cuts = [ |
| segment |
| for segment in result.segments |
| if segment.motion in {1, 2, 3} and distance(segment.start, segment.end) > 1e-5 |
| ] |
| if not cuts: |
| raise EvaluationError("missing cutting motion") |
| for segment in cuts: |
| if ( |
| segment.tool != 1 |
| or not segment.spindle_on |
| or segment.spindle is None |
| or not close(segment.spindle, SPINDLE_RPM, 1.0) |
| or segment.feed is None |
| or not close(segment.feed, FEED_MM_MIN, 1.0) |
| or not segment.length_comp |
| or segment.h_offset != 1 |
| or (segment.wcs is None and max(abs(segment.local_shift.x), abs(segment.local_shift.y), abs(segment.local_shift.z)) <= 1e-6) |
| ): |
| raise EvaluationError("cutting motion has invalid T/S/F/H/coordinate state") |
|
|
| horizontal_cuts = [segment for segment in cuts if horizontal(segment)] |
| if not horizontal_cuts: |
| raise EvaluationError("missing horizontal pocket clearing") |
| bottom_z = min((segment.start.z + segment.end.z) / 2.0 for segment in horizontal_cuts) |
| if not close(bottom_z, -10.0, 0.35): |
| raise EvaluationError("final pocket depth is not 10 mm") |
| bottom_segments = [ |
| segment |
| for segment in horizontal_cuts |
| if abs((segment.start.z + segment.end.z) / 2.0 - bottom_z) <= 0.35 |
| ] |
| bottom_points = [point for segment in bottom_segments for point in segment.samples] |
| if len(bottom_points) < 80: |
| raise EvaluationError("bottom clearing is incomplete") |
| xmin, xmax = min(point.x for point in bottom_points), max(point.x for point in bottom_points) |
| ymin, ymax = min(point.y for point in bottom_points), max(point.y for point in bottom_points) |
| center_x, center_y = (xmin + xmax) / 2.0, (ymin + ymax) / 2.0 |
| if not (33.0 <= xmax - xmin <= 35.2 and 17.0 <= ymax - ymin <= 19.2): |
| raise EvaluationError("D8 tool-center pocket envelope is wrong") |
| if any( |
| abs(point.x - center_x) > CENTER_LIMIT_X_MM + 0.65 |
| or abs(point.y - center_y) > CENTER_LIMIT_Y_MM + 0.65 |
| for point in bottom_points |
| ): |
| raise EvaluationError("bottom path overcuts the pocket wall") |
|
|
| |
| for ix in range(-10, 11): |
| x = center_x + ix * 2.0 |
| for iy in range(-6, 7): |
| y = center_y + iy * 2.0 |
| corner_dx = max(abs(x - center_x) - CENTER_LIMIT_X_MM, 0.0) |
| corner_dy = max(abs(y - center_y) - CENTER_LIMIT_Y_MM, 0.0) |
| if math.hypot(corner_dx, corner_dy) <= TOOL_RADIUS_MM + 0.05: |
| if not covered(bottom_points, x, y, TOOL_RADIUS_MM + 0.2): |
| raise EvaluationError("pocket bottom undercoverage") |
|
|
| for segment in cuts: |
| if min(segment.start.z, segment.end.z) >= -0.5: |
| continue |
| if any( |
| abs(point.x - center_x) > CENTER_LIMIT_X_MM + 1.25 |
| or abs(point.y - center_y) > CENTER_LIMIT_Y_MM + 1.25 |
| for point in segment.samples |
| ): |
| raise EvaluationError("deep cutting leaves the pocket envelope") |
|
|
| fixture = ( |
| center_x + FIXTURE_RELATIVE_BOX[0], center_x + FIXTURE_RELATIVE_BOX[1], |
| center_y + FIXTURE_RELATIVE_BOX[2], center_y + FIXTURE_RELATIVE_BOX[3], |
| FIXTURE_RELATIVE_BOX[4], FIXTURE_RELATIVE_BOX[5], |
| ) |
| required_center_distance = TOOL_RADIUS_MM + REQUIRED_FIXTURE_CLEARANCE_MM |
| for segment in result.segments: |
| if segment.machine: |
| continue |
| if any(point_box_distance(point, fixture) < required_center_distance - 0.05 for point in segment.samples): |
| raise EvaluationError("continuous tool sweep violates fixture clearance") |
| if not any( |
| segment.motion == 0 and max(point.z for point in segment.samples) >= 25.0 |
| for segment in result.segments if not segment.machine |
| ): |
| raise EvaluationError("missing fixture-safe clearance approach") |
|
|
|
|
| def evaluate_text(src: str) -> bool: |
| try: |
| validate_pocket(execute(src)) |
| return True |
| except (EvaluationError, ValueError, OverflowError, RecursionError): |
| return False |
|
|
|
|
| def main() -> bool: |
| path = TARGET / NC_NAME |
| if not path.is_file() or path.stat().st_size <= 0 or path.stat().st_size > MAX_BYTES: |
| return False |
| return evaluate_text(path.read_text(encoding="utf-8", errors="strict")) |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| ok = main() |
| except Exception: |
| ok = False |
| print("True" if ok else "False") |
| raise SystemExit(0) |
|
|
