| from __future__ import annotations |
|
|
| import math |
| import os |
| import re |
| from dataclasses import dataclass |
| from pathlib import Path |
|
|
|
|
| TARGET = Path(os.environ.get("EVAL_TARGET_DIR", r"C:\Users\User\Desktop")) |
| NC_NAME = "task-19.nc" |
| TOOL_SPEC = { |
| 1: {"diameter": 4.0, "spindle": 8500.0, "feed": 420.0}, |
| 2: {"diameter": 4.0, "spindle": 6500.0, "feed": 360.0}, |
| } |
| WORD_RE = re.compile(r"([A-Z])\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+))") |
| ALLOWED_LETTERS = set("NGMXYZIJKRFSTHDP") |
|
|
|
|
| class EvaluationError(ValueError): |
| pass |
|
|
|
|
| @dataclass(frozen=True) |
| class Point: |
| x: float |
| y: float |
| z: float |
|
|
|
|
| @dataclass(frozen=True) |
| class Segment: |
| start: Point |
| end: Point |
| points: tuple[Point, ...] |
| motion: int |
| tool: int | None |
| spindle: float | None |
| spindle_on: bool |
| feed: float | None |
| wcs: int | None |
| length_comp: bool |
| h_offset: int | None |
| cutter_comp: int | None |
|
|
|
|
| @dataclass |
| class Program: |
| segments: list[Segment] |
| tool_changes: list[int] |
| terminated: bool |
| executable_blocks: int |
| units_selected: bool |
| distance_mode_selected: bool |
|
|
|
|
| @dataclass(frozen=True) |
| class Frame: |
| ux: float |
| uy: float |
| vx: float |
| vy: float |
| cx: float |
| cy: float |
| umin: float |
| umax: float |
| vmin: float |
| vmax: float |
| surface_z: float |
| profile_bottom_z: float |
|
|
| def map(self, point: Point) -> tuple[float, float, float]: |
| dx, dy = point.x - self.cx, point.y - self.cy |
| return dx * self.ux + dy * self.uy, dx * self.vx + dy * self.vy, point.z |
|
|
|
|
| def close(actual: float, expected: float, tolerance: float) -> bool: |
| return abs(actual - expected) <= tolerance |
|
|
|
|
| def distance(a: Point, b: Point) -> float: |
| return math.dist((a.x, a.y, a.z), (b.x, b.y, b.z)) |
|
|
|
|
| def dense_points(a: Point, b: Point, spacing: float = 0.5) -> tuple[Point, ...]: |
| count = max(1, int(math.ceil(distance(a, b) / spacing))) |
| return tuple( |
| 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 strip_comments(source: str) -> list[str]: |
| lines: list[str] = [] |
| depth = 0 |
| for raw in source.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 closing comment") |
| depth -= 1 |
| elif depth == 0: |
| clean.append(char) |
| lines.append("".join(clean).strip()) |
| if depth: |
| raise EvaluationError("unterminated parenthesis comment") |
| return lines |
|
|
|
|
| def parse_program(source: str) -> Program: |
| units: str | None = None |
| absolute: bool | None = None |
| motion: int | None = None |
| current = Point(0.0, 0.0, 0.0) |
| pending_tool = active_tool = None |
| spindle = feed = None |
| spindle_on = False |
| wcs = None |
| length_comp = False |
| h_offset = None |
| cutter_comp = None |
| terminated = False |
| executable = 0 |
| segments: list[Segment] = [] |
| tool_changes: list[int] = [] |
|
|
| for line in strip_comments(source): |
| if not line or line == "%": |
| continue |
| if terminated: |
| raise EvaluationError("executable content after M30") |
| if any(char in line for char in "#[]="): |
| raise EvaluationError("expressions and macros are unsupported") |
| if re.fullmatch(r"/?\s*O\d+", line): |
| executable += 1 |
| continue |
| words = WORD_RE.findall(line) |
| residue = re.sub(r"[\s/]+", "", WORD_RE.sub("", line)) |
| if not words or residue: |
| raise EvaluationError(f"unknown executable content: {line!r}") |
| executable += 1 |
| grouped: dict[str, list[float]] = {} |
| for letter, raw_value in words: |
| if letter not in ALLOWED_LETTERS: |
| raise EvaluationError(f"unsupported address word {letter}") |
| grouped.setdefault(letter, []).append(float(raw_value)) |
| if any(letter in grouped for letter in ("A", "B", "C")): |
| raise EvaluationError("rotary-axis output is forbidden") |
| for letter in ("X", "Y", "Z", "I", "J", "K", "R", "F", "S", "T", "H", "D", "P"): |
| if len(grouped.get(letter, [])) > 1: |
| raise EvaluationError(f"ambiguous repeated {letter} word") |
|
|
| reference_return = False |
| for raw_g in grouped.get("G", []): |
| rounded = int(round(raw_g)) |
| if not close(raw_g, rounded, 1e-7): |
| raise EvaluationError(f"unsupported non-integral G code G{raw_g:g}") |
| if rounded == 20: |
| units = "inch" |
| elif rounded == 21: |
| units = "mm" |
| elif rounded == 90: |
| absolute = True |
| elif rounded == 91: |
| absolute = False |
| elif rounded in (0, 1, 2, 3): |
| motion = rounded |
| elif rounded == 28: |
| reference_return = True |
| elif rounded in (54, 55, 56, 57, 58, 59): |
| wcs = rounded |
| elif rounded == 43: |
| length_comp = True |
| elif rounded == 49: |
| length_comp = False |
| h_offset = None |
| elif rounded == 40: |
| cutter_comp = None |
| elif rounded in (41, 42): |
| cutter_comp = rounded |
| elif rounded in (17, 80, 94): |
| pass |
| else: |
| raise EvaluationError(f"unsupported G code G{rounded}") |
|
|
| mcodes: list[int] = [] |
| for raw_m in grouped.get("M", []): |
| if not close(raw_m, round(raw_m), 1e-7): |
| raise EvaluationError("non-integral M code") |
| mcode = int(round(raw_m)) |
| if mcode not in (0, 1, 2, 3, 4, 5, 6, 8, 9, 30): |
| raise EvaluationError(f"unsupported M code M{mcode}") |
| mcodes.append(mcode) |
|
|
| if "T" in grouped: |
| raw_tool = grouped["T"][0] |
| if not close(raw_tool, round(raw_tool), 1e-7): |
| raise EvaluationError("non-integral tool number") |
| pending_tool = int(round(raw_tool)) |
| if "S" in grouped: |
| spindle = grouped["S"][0] |
| if "H" in grouped: |
| raw_h = grouped["H"][0] |
| if not close(raw_h, round(raw_h), 1e-7): |
| raise EvaluationError("non-integral H offset") |
| h_offset = int(round(raw_h)) |
| if 6 in mcodes: |
| if pending_tool is None: |
| raise EvaluationError("M6 without pending tool") |
| active_tool = pending_tool |
| tool_changes.append(active_tool) |
| if 3 in mcodes or 4 in mcodes: |
| spindle_on = True |
| if 5 in mcodes: |
| spindle_on = False |
| if 30 in mcodes: |
| if mcodes != [30] or any(letter not in {"N", "M"} for letter in grouped): |
| raise EvaluationError("M30 must be a terminal-only block") |
| terminated = True |
| continue |
|
|
| coordinate_letters = {"X", "Y", "Z"} & grouped.keys() |
| if units is None and (coordinate_letters or "F" in grouped): |
| raise EvaluationError("coordinate/feed before unit selection") |
| factor = 25.4 if units == "inch" else 1.0 |
| if "F" in grouped: |
| feed = grouped["F"][0] * factor |
| if reference_return: |
| continue |
| if absolute is None and coordinate_letters: |
| raise EvaluationError("coordinate before distance mode") |
|
|
| def coordinate(letter: str, old: float) -> float: |
| if letter not in grouped: |
| return old |
| value = grouped[letter][0] * factor |
| return value if absolute else old + value |
|
|
| new_point = Point( |
| coordinate("X", current.x), |
| coordinate("Y", current.y), |
| coordinate("Z", current.z), |
| ) |
| if coordinate_letters and motion is not None and distance(current, new_point) > 1e-9: |
| segments.append( |
| Segment( |
| current, |
| new_point, |
| dense_points(current, new_point), |
| motion, |
| active_tool, |
| spindle, |
| spindle_on, |
| feed, |
| wcs, |
| length_comp, |
| h_offset, |
| cutter_comp, |
| ) |
| ) |
| current = new_point |
|
|
| return Program( |
| segments, |
| tool_changes, |
| terminated, |
| executable, |
| units is not None, |
| absolute is not None, |
| ) |
|
|
|
|
| def cutting_segments(program: Program, tool: int) -> list[Segment]: |
| expected = TOOL_SPEC[tool] |
| rows = [] |
| for segment in program.segments: |
| if segment.tool != tool or segment.motion not in (1, 2, 3) or distance(segment.start, segment.end) <= 0.01: |
| continue |
| if ( |
| not segment.spindle_on |
| or segment.spindle is None |
| or not close(segment.spindle, expected["spindle"], 1.0) |
| or segment.feed is None |
| or not close(segment.feed, expected["feed"], 0.8) |
| or segment.wcs is None |
| or not segment.length_comp |
| or segment.h_offset is None |
| or segment.h_offset <= 0 |
| ): |
| raise EvaluationError(f"tool {tool} cutting state is incomplete or incorrect") |
| rows.append(segment) |
| if not rows: |
| raise EvaluationError(f"tool {tool} has no valid cutting motion") |
| return rows |
|
|
|
|
| def projected(point: Point, ux: float, uy: float, vx: float, vy: float) -> tuple[float, float]: |
| return point.x * ux + point.y * uy, point.x * vx + point.y * vy |
|
|
|
|
| def profile_frame(tool2: list[Segment]) -> Frame: |
| bottom = min(min(segment.start.z, segment.end.z) for segment in tool2) |
| full_depth = [ |
| segment |
| for segment in tool2 |
| if abs(segment.start.z - bottom) <= 0.4 |
| and abs(segment.end.z - bottom) <= 0.4 |
| and math.hypot(segment.end.x - segment.start.x, segment.end.y - segment.start.y) >= 20.0 |
| ] |
| if len(full_depth) < 4: |
| raise EvaluationError("outside profile lacks four full-depth boundary spans") |
| longest = max( |
| full_depth, |
| key=lambda segment: math.hypot(segment.end.x - segment.start.x, segment.end.y - segment.start.y), |
| ) |
| dx, dy = longest.end.x - longest.start.x, longest.end.y - longest.start.y |
| length = math.hypot(dx, dy) |
| ux, uy = dx / length, dy / length |
| vx, vy = -uy, ux |
| endpoints = [point for segment in full_depth for point in (segment.start, segment.end)] |
| raw = [projected(point, ux, uy, vx, vy) for point in endpoints] |
| umin, umax = min(x for x, _ in raw), max(x for x, _ in raw) |
| vmin, vmax = min(y for _, y in raw), max(y for _, y in raw) |
| width, height = umax - umin, vmax - vmin |
| center_u, center_v = (umin + umax) / 2.0, (vmin + vmax) / 2.0 |
| cx = center_u * ux + center_v * vx |
| cy = center_u * uy + center_v * vy |
| umin -= center_u |
| umax -= center_u |
| vmin -= center_v |
| vmax -= center_v |
| centerline_profile = close(width, 84.0, 1.2) and close(height, 50.0, 1.2) |
| compensated_nominal = close(width, 80.0, 1.2) and close(height, 46.0, 1.2) |
| if not (centerline_profile or compensated_nominal): |
| raise EvaluationError(f"outside profile dimensions are incorrect: {width:g} x {height:g}") |
| if compensated_nominal and not all(segment.cutter_comp in (41, 42) for segment in full_depth): |
| raise EvaluationError("nominal outside contour requires active G41/G42 compensation") |
|
|
| samples = [] |
| for segment in full_depth: |
| samples.extend( |
| ( |
| (point.x - cx) * ux + (point.y - cy) * uy, |
| (point.x - cx) * vx + (point.y - cy) * vy, |
| ) |
| for point in segment.points |
| ) |
| side_tolerance = 0.7 |
| u_low = [v for u, v in samples if abs(u - umin) <= side_tolerance] |
| u_high = [v for u, v in samples if abs(u - umax) <= side_tolerance] |
| v_low = [u for u, v in samples if abs(v - vmin) <= side_tolerance] |
| v_high = [u for u, v in samples if abs(v - vmax) <= side_tolerance] |
| if ( |
| not u_low |
| or not u_high |
| or not v_low |
| or not v_high |
| or min(u_low) > vmin + 1.2 |
| or max(u_low) < vmax - 1.2 |
| or min(u_high) > vmin + 1.2 |
| or max(u_high) < vmax - 1.2 |
| or min(v_low) > umin + 1.2 |
| or max(v_low) < umax - 1.2 |
| or min(v_high) > umin + 1.2 |
| or max(v_high) < umax - 1.2 |
| ): |
| raise EvaluationError("outside profile is open or misses a boundary side") |
| return Frame(ux, uy, vx, vy, cx, cy, umin, umax, vmin, vmax, bottom + 10.0, bottom) |
|
|
|
|
| def validate_channels(tool1: list[Segment], frame: Frame) -> None: |
| bottom = frame.surface_z - 3.0 |
| if any(min(segment.start.z, segment.end.z) < bottom - 0.45 for segment in tool1): |
| raise EvaluationError("channel tool cuts below the 3 mm channel floor") |
| bottom_points = [ |
| frame.map(point) |
| for segment in tool1 |
| for point in segment.points |
| if abs(point.z - bottom) <= 0.4 |
| ] |
| if not bottom_points: |
| raise EvaluationError("no channel-floor cutting motion") |
| for center_v in (-12.0, 0.0, 12.0): |
| lane = [(u, v) for u, v, _ in bottom_points if abs(v - center_v) <= 0.8] |
| if ( |
| len(lane) < 80 |
| or min(u for u, _ in lane) > -25.4 |
| or max(u for u, _ in lane) < 25.4 |
| or min(v for _, v in lane) > center_v - 0.35 |
| or max(v for _, v in lane) < center_v + 0.35 |
| ): |
| raise EvaluationError(f"channel at relative Y={center_v:g} is incomplete") |
| for segment in tool1: |
| for point in segment.points: |
| if point.z >= frame.surface_z - 0.1: |
| continue |
| u, v, _ = frame.map(point) |
| in_channel = abs(u) <= 26.7 and any(abs(v - center) <= 0.8 for center in (-12.0, 0.0, 12.0)) |
| if not in_channel: |
| raise EvaluationError("T1 contains destructive cutting outside the three channels") |
|
|
|
|
| def validate_profile_exclusivity(tool2: list[Segment], frame: Frame) -> None: |
| for segment in tool2: |
| if max(segment.start.z, segment.end.z) > frame.surface_z - 0.5: |
| continue |
| for point in segment.points: |
| u, v, _ = frame.map(point) |
| outside_or_boundary = ( |
| u <= frame.umin + 0.8 |
| or u >= frame.umax - 0.8 |
| or v <= frame.vmin + 0.8 |
| or v >= frame.vmax - 0.8 |
| ) |
| if not outside_or_boundary: |
| raise EvaluationError("T2 contains destructive cutting inside the finished outside profile") |
|
|
|
|
| def validate_program(program: Program) -> None: |
| if ( |
| not program.terminated |
| or not program.units_selected |
| or not program.distance_mode_selected |
| or program.executable_blocks < 30 |
| ): |
| raise EvaluationError("program is incomplete") |
| if program.tool_changes != [1, 2]: |
| raise EvaluationError("expected exactly one T1 change followed by one T2 change") |
| for segment in program.segments: |
| if segment.motion in (1, 2, 3) and distance(segment.start, segment.end) > 0.01: |
| if segment.tool not in (1, 2): |
| raise EvaluationError("cutting move uses an unexpected tool") |
| tool1 = cutting_segments(program, 1) |
| tool2 = cutting_segments(program, 2) |
| frame = profile_frame(tool2) |
| validate_channels(tool1, frame) |
| validate_profile_exclusivity(tool2, frame) |
|
|
|
|
| def evaluate_text(source: str) -> bool: |
| try: |
| validate_program(parse_program(source)) |
| return True |
| except (EvaluationError, ValueError, OverflowError): |
| return False |
|
|
|
|
| def main() -> bool: |
| path = TARGET / NC_NAME |
| if not path.is_file() or path.stat().st_size < 150 or path.stat().st_size > 5_000_000: |
| return False |
| return evaluate_text(path.read_text(encoding="utf-8", errors="strict")) |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| result = main() |
| except Exception: |
| result = False |
| print("True" if result else "False") |
| raise SystemExit(0) |
|
|
|
|
|
|
