| from __future__ import annotations |
|
|
| import hashlib |
| 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")) |
| A_NC_NAME = "task-17_A.nc" |
| B_NC_NAME = "task-17_B.nc" |
| EXPECTED_STEP_SHA256 = "4B56E8F631F34E47A312B5A3C12737A05C150D45F0B2DB24F94D4CA6B5670575" |
| EXPECTED_TOOLS_SHA256 = "9C709FEEB541C22E8717FEF6B6E7A2E6BE2E5DF3F6143B320C804D014ACDF643" |
| FORMAL_INPUT_SHA256 = { |
| "two_sided_part.step": EXPECTED_STEP_SHA256, |
| "tools.csv": EXPECTED_TOOLS_SHA256, |
| } |
| TOOLS = { |
| 1: {"diameter": 10.0, "spindle": 7500.0, "feed": 520.0}, |
| 2: {"diameter": 5.0, "spindle": 5000.0, "feed": 180.0}, |
| 3: {"diameter": 8.0, "spindle": 8500.0, "feed": 420.0}, |
| } |
| B_HOLES = ((-30.0, -20.0), (30.0, -20.0), (-30.0, 20.0), (30.0, 20.0)) |
| WORD_RE = re.compile(r"([A-Z])\s*([-+]?(?:\d+(?:\.\d*)?|\.\d+))") |
| 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, 53.0, 54.0, 54.1, 55.0, 56.0, 57.0, 58.0, 59.0, 80.0, 81.0, 82.0, 83.0, 90.0, 91.0, 94.0, 98.0, 99.0} |
| ALLOWED_M = {0, 1, 2, 3, 4, 5, 6, 8, 9, 30} |
| STATE_TOL = 1.0 |
| DEPTH_TOL = 0.35 |
| MAX_BYTES = 1_000_000 |
| MAX_LINES = 12_000 |
| MAX_WORDS_PER_LINE = 40 |
| MAX_SEGMENTS = 20_000 |
| MAX_SAMPLES = 250_000 |
|
|
|
|
| class EvaluationError(ValueError): |
| pass |
|
|
|
|
| @dataclass(frozen=True) |
| class Point: |
| x: float |
| y: float |
| z: float |
|
|
|
|
| @dataclass |
| class Segment: |
| start: Point |
| end: Point |
| samples: list[Point] |
| motion: int |
| tool: int | None |
| spindle_on: bool |
| spindle: float | None |
| feed: float | None |
| wcs: str | None |
| length_comp: bool |
| h_offset: int | None |
| cutter_comp: int |
| d_offset: int | None |
| line: int |
|
|
|
|
| @dataclass |
| class DrillEvent: |
| x: float |
| y: float |
| bottom_z: float |
| approach_z: float | None |
| retract_z: float | None |
| tool: int | None |
| spindle_on: bool |
| spindle: float | None |
| feed: float | None |
| wcs: str | None |
| length_comp: bool |
| h_offset: int | None |
| line: int |
|
|
|
|
| @dataclass |
| class Program: |
| segments: list[Segment] |
| cycles: list[DrillEvent] |
| tool_changes: list[int] |
| saw_m30: bool |
|
|
|
|
| def close(actual: float, expected: float, tolerance: float) -> bool: |
| return abs(actual - expected) <= tolerance |
|
|
|
|
| def sha256(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for chunk in iter(lambda: handle.read(1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest().upper() |
|
|
|
|
| def comments(source: str) -> list[str]: |
| result: list[str] = [] |
| depth = 0 |
| buffer: list[str] = [] |
| for line_number, raw in enumerate(source.upper().splitlines(), 1): |
| index = 0 |
| while index < len(raw): |
| char = raw[index] |
| if char == ";" and depth == 0: |
| result.append(raw[index + 1 :]) |
| break |
| if char == "(": |
| if depth == 0: |
| buffer = [] |
| depth += 1 |
| if depth > 8: |
| raise EvaluationError("excessive nested comment") |
| elif char == ")": |
| if depth == 0: |
| raise EvaluationError(f"unmatched comment close on line {line_number}") |
| depth -= 1 |
| if depth == 0: |
| result.append("".join(buffer)) |
| buffer = [] |
| elif depth: |
| buffer.append(char) |
| index += 1 |
| if depth: |
| raise EvaluationError("unterminated parenthesized comment") |
| return result |
|
|
|
|
| def executable_lines(source: str) -> list[tuple[int, str]]: |
| result: list[tuple[int, str]] = [] |
| depth = 0 |
| for line_number, raw in enumerate(source.upper().splitlines(), 1): |
| clean: list[str] = [] |
| for char in raw: |
| if char == ";" and depth == 0: |
| break |
| if char == "(": |
| depth += 1 |
| elif char == ")": |
| if depth == 0: |
| raise EvaluationError(f"unmatched comment close on line {line_number}") |
| depth -= 1 |
| elif depth == 0: |
| clean.append(char) |
| result.append((line_number, "".join(clean).strip())) |
| if depth: |
| raise EvaluationError("unterminated parenthesized comment") |
| return result |
|
|
|
|
| def words(code: str, line: int) -> list[tuple[str, float]]: |
| if not code or code == "%": |
| return [] |
| if code.startswith("/"): |
| raise EvaluationError(f"block-delete code is not deterministic on line {line}") |
| matches = list(WORD_RE.finditer(code)) |
| if len(matches) > MAX_WORDS_PER_LINE: |
| raise EvaluationError(f"too many words on line {line}") |
| residue = WORD_RE.sub(" ", code) |
| if residue.strip(): |
| raise EvaluationError(f"unknown executable text on line {line}: {residue.strip()!r}") |
| result = [(match.group(1), float(match.group(2))) for match in matches] |
| if any(not math.isfinite(value) or abs(value) > 10_000_000 for _, value in result): |
| raise EvaluationError(f"non-finite or excessive numeric word on line {line}") |
| return result |
|
|
|
|
| def exact_int(value: float, label: str, line: int) -> int: |
| rounded = round(value) |
| if not close(value, rounded, 1e-8): |
| raise EvaluationError(f"fractional {label} on line {line}") |
| return int(rounded) |
|
|
|
|
| def line_samples(start: Point, end: Point, spacing: float = 0.5) -> list[Point]: |
| length = math.dist((start.x, start.y, start.z), (end.x, end.y, end.z)) |
| if not math.isfinite(length) or length > 1000.0: |
| raise EvaluationError("invalid or excessive line length") |
| count = max(1, int(math.ceil(length / spacing))) |
| return [Point(start.x + (end.x - start.x) * i / count, start.y + (end.y - start.y) * i / count, start.z + (end.z - start.z) * i / count) for i in range(count + 1)] |
|
|
|
|
| def directed_sweep(start: float, end: float, clockwise: bool) -> float: |
| sweep = (start - end) % (2 * math.pi) if clockwise else (end - start) % (2 * math.pi) |
| return sweep if sweep > 1e-9 else 2 * math.pi |
|
|
|
|
| def arc_samples(start: Point, end: Point, grouped: dict[str, list[float]], scale: float, clockwise: bool) -> list[Point]: |
| if "I" in grouped or "J" in grouped: |
| cx = start.x + grouped.get("I", [0.0])[-1] * scale |
| cy = start.y + grouped.get("J", [0.0])[-1] * scale |
| radius = math.hypot(start.x - cx, start.y - cy) |
| if radius <= 1e-6 or radius > 500.0 or not close(math.hypot(end.x - cx, end.y - cy), radius, 0.2): |
| raise EvaluationError("invalid I/J arc") |
| a0 = math.atan2(start.y - cy, start.x - cx) |
| a1 = math.atan2(end.y - cy, end.x - cx) |
| sweep = directed_sweep(a0, a1, clockwise) |
| elif "R" in grouped: |
| dx, dy = end.x - start.x, end.y - start.y |
| chord = math.hypot(dx, dy) |
| signed_radius = grouped["R"][-1] * scale |
| radius = abs(signed_radius) |
| if chord <= 1e-9 or radius > 500.0 or chord > 2 * radius + 0.2: |
| raise EvaluationError("invalid R arc") |
| mx, my = (start.x + end.x) / 2, (start.y + end.y) / 2 |
| height = math.sqrt(max(radius * radius - (chord / 2) ** 2, 0.0)) |
| nx, ny = -dy / chord, dx / chord |
| candidates = [] |
| for cx0, cy0 in ((mx + nx * height, my + ny * height), (mx - nx * height, my - ny * height)): |
| aa0 = math.atan2(start.y - cy0, start.x - cx0) |
| aa1 = math.atan2(end.y - cy0, end.x - cx0) |
| candidates.append((directed_sweep(aa0, aa1, clockwise), cx0, cy0, aa0)) |
| sweep, cx, cy, a0 = (min if signed_radius >= 0 else max)(candidates, key=lambda item: item[0]) |
| else: |
| raise EvaluationError("G2/G3 requires I/J or R") |
| count = max(8, int(math.ceil(radius * sweep / 0.35))) |
| sign = -1.0 if clockwise else 1.0 |
| return [Point(cx + radius * math.cos(a0 + sign * sweep * i / count), cy + radius * math.sin(a0 + sign * sweep * i / count), start.z + (end.z - start.z) * i / count) for i in range(count + 1)] |
|
|
|
|
| def parse_program(source: str) -> Program: |
| units: float | None = None |
| absolute: bool | None = None |
| motion: int | None = None |
| current = Point(0.0, 0.0, 0.0) |
| position_known = True |
| pending_tool: int | None = None |
| active_tool: int | None = None |
| spindle_on = False |
| spindle: float | None = None |
| feed: float | None = None |
| wcs: str | None = None |
| length_comp = False |
| h_offset: int | None = None |
| cutter_comp = 0 |
| d_offset: int | None = None |
| cycle: int | None = None |
| cycle_z: float | None = None |
| cycle_r: float | None = None |
| cycle_q: float | None = None |
| retract_mode = 98 |
| terminated = False |
| segments: list[Segment] = [] |
| cycles: list[DrillEvent] = [] |
| tool_changes: list[int] = [] |
| sample_count = 0 |
|
|
| for line_number, code in executable_lines(source): |
| parsed = words(code, line_number) |
| if not parsed: |
| continue |
| if terminated: |
| raise EvaluationError(f"executable code after M30 on line {line_number}") |
| grouped: dict[str, list[float]] = {} |
| for letter, value in parsed: |
| grouped.setdefault(letter, []).append(value) |
| if any(letter not in "NGMTSFXYZIJRQHDPO" for letter in grouped): |
| raise EvaluationError(f"unsupported word on line {line_number}") |
| for letter in "NXYZIJRQHDSTPO": |
| if len(grouped.get(letter, [])) > 1: |
| raise EvaluationError(f"duplicate {letter} on line {line_number}") |
| if "N" in grouped: |
| exact_int(grouped["N"][0], "N", line_number) |
| if "O" in grouped and exact_int(grouped["O"][0], "O", line_number) <= 0: |
| raise EvaluationError(f"invalid O number on line {line_number}") |
| gcodes = grouped.get("G", []) |
| mcodes = [exact_int(value, "M", line_number) for value in grouped.get("M", [])] |
| if any(not any(close(code_value, allowed, 1e-7) for allowed in ALLOWED_G) for code_value in gcodes): |
| raise EvaluationError(f"unsupported G code on line {line_number}") |
| if any(code_value not in ALLOWED_M for code_value in mcodes): |
| raise EvaluationError(f"unsupported M code on line {line_number}") |
| if sum(any(close(code_value, mode, 1e-7) for code_value in gcodes) for mode in (20.0, 21.0)) > 1: |
| raise EvaluationError("conflicting unit modes") |
| if sum(any(close(code_value, mode, 1e-7) for code_value in gcodes) for mode in (90.0, 91.0)) > 1: |
| raise EvaluationError("conflicting distance modes") |
| if sum(any(close(code_value, mode, 1e-7) for code_value in gcodes) for mode in (0.0, 1.0, 2.0, 3.0)) > 1: |
| raise EvaluationError("conflicting motion modes") |
| if sum(any(close(code_value, mode, 1e-7) for code_value in gcodes) for mode in (80.0, 81.0, 82.0, 83.0)) > 1: |
| raise EvaluationError("conflicting canned-cycle modes") |
| if sum(any(close(code_value, mode, 1e-7) for code_value in gcodes) for mode in (98.0, 99.0)) > 1: |
| raise EvaluationError("conflicting retract modes") |
| if sum(any(close(code_value, mode, 1e-7) for code_value in gcodes) for mode in (40.0, 41.0, 42.0)) > 1: |
| raise EvaluationError("conflicting cutter-compensation modes") |
| if 30 in mcodes: |
| if set(grouped) - {"N", "M"} or mcodes != [30]: |
| raise EvaluationError("M30 block contains hidden executable words") |
| if cutter_comp: |
| raise EvaluationError("M30 reached with cutter compensation active") |
| terminated = True |
| continue |
|
|
| g28 = any(close(code_value, 28.0, 1e-7) for code_value in gcodes) |
| g53 = any(close(code_value, 53.0, 1e-7) for code_value in gcodes) |
| if g28: |
| if any(any(close(code_value, mode, 1e-7) for mode in (0, 1, 2, 3, 81, 82, 83)) for code_value in gcodes): |
| raise EvaluationError("G28 cannot hide cutting motion") |
| if any(abs(value) > 1e-8 for letter in "XYZ" for value in grouped.get(letter, [])): |
| raise EvaluationError("only zero-intermediate G28 is accepted") |
|
|
| for code_value in gcodes: |
| if close(code_value, 20.0, 1e-7): units = 25.4 |
| elif close(code_value, 21.0, 1e-7): units = 1.0 |
| elif close(code_value, 90.0, 1e-7): absolute = True |
| elif close(code_value, 91.0, 1e-7): absolute = False |
| elif any(close(code_value, mode, 1e-7) for mode in (0, 1, 2, 3)): |
| motion = int(round(code_value)); cycle = None |
| elif any(close(code_value, mode, 1e-7) for mode in (81, 82, 83)): |
| cycle = int(round(code_value)) |
| elif close(code_value, 80.0, 1e-7): cycle = None |
| elif close(code_value, 98.0, 1e-7): retract_mode = 98 |
| elif close(code_value, 99.0, 1e-7): retract_mode = 99 |
| elif close(code_value, 43.0, 1e-7): length_comp = True |
| elif close(code_value, 49.0, 1e-7): length_comp = False; h_offset = None |
| elif close(code_value, 40.0, 1e-7): cutter_comp = 0; d_offset = None |
| elif close(code_value, 41.0, 1e-7): cutter_comp = 41 |
| elif close(code_value, 42.0, 1e-7): cutter_comp = 42 |
| elif any(close(code_value, value, 1e-7) for value in (54, 55, 56, 57, 58, 59)): wcs = f"G{int(round(code_value))}" |
| elif close(code_value, 54.1, 1e-7): |
| p_value = grouped.get("P", [None])[-1] |
| if p_value is None or exact_int(p_value, "P", line_number) <= 0: |
| raise EvaluationError("G54.1 requires positive P") |
| wcs = f"G54.1 P{exact_int(p_value, 'P', line_number)}" |
|
|
| if g28 and absolute is not False: |
| raise EvaluationError("G28 requires G91 zero-intermediate return") |
| arc_mode = cycle is None and motion in (2, 3) |
| if ("I" in grouped or "J" in grouped) and not arc_mode: |
| raise EvaluationError("I/J is valid only for G2/G3") |
| if "R" in grouped and cycle is None and not arc_mode: |
| raise EvaluationError("R is valid only for G2/G3 or a canned cycle") |
| if "Q" in grouped and cycle != 83: |
| raise EvaluationError("Q is valid only for G83") |
| if "P" in grouped and not any(close(code_value, 54.1, 1e-7) for code_value in gcodes): |
| raise EvaluationError("P is valid only with G54.1") |
| if "D" in grouped: |
| if cutter_comp not in (41, 42) or exact_int(grouped["D"][-1], "D", line_number) <= 0: |
| raise EvaluationError("D offset requires active cutter compensation") |
| d_offset = exact_int(grouped["D"][-1], "D", line_number) |
|
|
| if "T" in grouped: |
| pending_tool = exact_int(grouped["T"][-1], "T", line_number) |
| if pending_tool not in TOOLS: |
| raise EvaluationError(f"unexpected tool T{pending_tool}") |
| if 6 in mcodes: |
| if pending_tool is None: |
| raise EvaluationError("M6 without T") |
| if cutter_comp: |
| raise EvaluationError("tool change with cutter compensation active") |
| active_tool = pending_tool |
| tool_changes.append(active_tool) |
| spindle_on = False |
| length_comp = False |
| h_offset = None |
| d_offset = None |
| if "S" in grouped: |
| spindle = grouped["S"][-1] |
| if spindle <= 0: |
| raise EvaluationError("spindle speed must be positive") |
| if 3 in mcodes or 4 in mcodes: |
| spindle_on = True |
| if 5 in mcodes: |
| spindle_on = False |
| if "F" in grouped: |
| if units is None: |
| raise EvaluationError("feed before units") |
| feed = grouped["F"][-1] * units |
| if feed <= 0: |
| raise EvaluationError("feed must be positive") |
| if "H" in grouped: |
| h_offset = exact_int(grouped["H"][-1], "H", line_number) |
| if h_offset <= 0: |
| raise EvaluationError("H must be positive") |
|
|
| axes = any(letter in grouped for letter in "XYZ") |
| full_circle = cycle is None and motion in (2, 3) and not axes and ("I" in grouped or "J" in grouped) |
| if not axes and not full_circle: |
| continue |
| if units is None or absolute is None: |
| raise EvaluationError("axis motion before units and distance mode") |
| if g28: |
| if "Z" in grouped: |
| position_known = False |
| continue |
| if g53: |
| if motion not in (0, None) or cycle is not None: |
| raise EvaluationError("G53 is allowed only for non-cutting machine motion") |
| if "Z" in grouped: |
| position_known = False |
| continue |
|
|
| scale = units |
| if cycle is not None: |
| if not absolute: |
| raise EvaluationError("canned cycles require G90") |
| if "Z" in grouped: cycle_z = grouped["Z"][-1] * scale |
| if "R" in grouped: cycle_r = grouped["R"][-1] * scale |
| if "Q" in grouped: cycle_q = grouped["Q"][-1] * scale |
| x_value = grouped.get("X", [current.x / scale])[-1] * scale |
| y_value = grouped.get("Y", [current.y / scale])[-1] * scale |
| launches = any(any(close(code_value, mode, 1e-7) for mode in (81, 82, 83)) for code_value in gcodes) or "X" in grouped or "Y" in grouped |
| if launches: |
| if cycle_z is None or cycle_r is None: |
| raise EvaluationError("incomplete canned cycle") |
| if cycle == 83 and (cycle_q is None or cycle_q <= 0): |
| raise EvaluationError("G83 requires positive Q") |
| retract_z = max(current.z, cycle_r) if retract_mode == 98 else cycle_r |
| cycles.append(DrillEvent(x_value, y_value, cycle_z, current.z, retract_z, active_tool, spindle_on, spindle, feed, wcs, length_comp, h_offset, line_number)) |
| if len(cycles) > MAX_SEGMENTS: |
| raise EvaluationError("canned-cycle event limit exceeded") |
| current = Point(x_value, y_value, retract_z) |
| position_known = True |
| continue |
| if motion is None: |
| raise EvaluationError("axis words before explicit motion mode") |
|
|
| def axis(letter: str, old: float) -> float: |
| if letter not in grouped: |
| return old |
| value = grouped[letter][-1] * scale |
| return value if absolute else old + value |
|
|
| end = Point(axis("X", current.x), axis("Y", current.y), axis("Z", current.z)) |
| if not position_known: |
| current = end |
| if "Z" in grouped: |
| position_known = True |
| continue |
| samples = line_samples(current, end) if motion in (0, 1) else arc_samples(current, end, grouped, scale, motion == 2) |
| segments.append(Segment(current, end, samples, motion, active_tool, spindle_on, spindle, feed, wcs, length_comp, h_offset, cutter_comp, d_offset, line_number)) |
| sample_count += len(samples) |
| if len(segments) > MAX_SEGMENTS or sample_count > MAX_SAMPLES: |
| raise EvaluationError("toolpath sampling resource limit exceeded") |
| current = end |
|
|
| if not terminated: |
| raise EvaluationError("M30 is required") |
| return Program(segments, cycles, tool_changes, True) |
|
|
|
|
| def explicit_drills(program: Program, direction: int) -> list[DrillEvent]: |
| events: list[DrillEvent] = [] |
| plunge: Segment | None = None |
| approach: float | None = None |
|
|
| def finish(retract: float | None) -> None: |
| nonlocal plunge |
| if plunge is None: |
| return |
| events.append(DrillEvent(plunge.end.x, plunge.end.y, plunge.end.z, approach if approach is not None else plunge.start.z, retract, plunge.tool, plunge.spindle_on, plunge.spindle, plunge.feed, plunge.wcs, plunge.length_comp, plunge.h_offset, plunge.line)) |
| plunge = None |
|
|
| for segment in program.segments: |
| if plunge is not None: |
| same_axis = math.hypot(segment.end.x - plunge.end.x, segment.end.y - plunge.end.y) <= 0.05 |
| if segment.motion == 0 and same_axis and direction * (segment.end.z - plunge.end.z) < -0.5: |
| finish(segment.end.z) |
| approach = segment.end.z |
| continue |
| if segment.motion == 1 and same_axis and direction * (segment.end.z - plunge.end.z) > 0.05: |
| plunge = segment |
| continue |
| if not same_axis: |
| finish(None) |
| if segment.motion == 0: |
| approach = segment.end.z |
| elif segment.motion == 1 and math.hypot(segment.end.x - segment.start.x, segment.end.y - segment.start.y) <= 0.05 and direction * (segment.end.z - segment.start.z) > 0.05: |
| plunge = segment |
| finish(None) |
| return events |
|
|
|
|
| def cutting_state(segment: Segment, tool: int) -> None: |
| contract = TOOLS[tool] |
| if segment.tool != tool or not segment.spindle_on or segment.spindle is None or not close(segment.spindle, contract["spindle"], STATE_TOL): |
| raise EvaluationError(f"T{tool} cutting has the wrong spindle state") |
| if segment.feed is None or segment.feed <= 0 or segment.wcs is None or not segment.length_comp or segment.h_offset != tool: |
| raise EvaluationError(f"T{tool} cutting lacks feed/WCS/matching H offset") |
| xy_length = math.hypot(segment.end.x - segment.start.x, segment.end.y - segment.start.y) |
| if (segment.motion in (2, 3) or xy_length > 0.1) and not close(segment.feed, contract["feed"], STATE_TOL): |
| raise EvaluationError(f"T{tool} XY cutting uses the wrong feed") |
| if xy_length <= 0.1 and segment.feed > contract["feed"] + STATE_TOL: |
| raise EvaluationError(f"T{tool} plunge feed exceeds the supplied feed") |
|
|
|
|
| def drill_state(event: DrillEvent) -> None: |
| contract = TOOLS[2] |
| if event.tool != 2 or not event.spindle_on or event.spindle is None or not close(event.spindle, contract["spindle"], STATE_TOL): |
| raise EvaluationError("T2 drill has the wrong spindle state") |
| if event.feed is None or not close(event.feed, contract["feed"], STATE_TOL) or event.wcs is None or not event.length_comp or event.h_offset != 2: |
| raise EvaluationError("T2 drill lacks the supplied feed/WCS/H2") |
|
|
|
|
| def source_guard(source: str) -> Program: |
| if len(source.encode("utf-8")) > MAX_BYTES or len(source.splitlines()) > MAX_LINES: |
| raise EvaluationError("NC file exceeds evaluator resource limits") |
| comments(source) |
| return parse_program(source) |
|
|
|
|
| def spatial_coverage(targets: list[tuple[float, float]], points: list[Point], radius: float) -> float: |
| quantum = 0.25 |
| cell = max(radius, 1.0) |
| unique = {(round(point.x / quantum), round(point.y / quantum)) for point in points} |
| bins: dict[tuple[int, int], list[tuple[float, float]]] = {} |
| for qx, qy in unique: |
| x, y = qx * quantum, qy * quantum |
| bins.setdefault((math.floor(x / cell), math.floor(y / cell)), []).append((x, y)) |
| covered = 0 |
| for x, y in targets: |
| bx, by = math.floor(x / cell), math.floor(y / cell) |
| candidates = (point for dx in (-1, 0, 1) for dy in (-1, 0, 1) for point in bins.get((bx + dx, by + dy), ())) |
| if any(math.hypot(px - x, py - y) <= radius + quantum * 0.75 for px, py in candidates): |
| covered += 1 |
| return covered / len(targets) if targets else 0.0 |
|
|
|
|
| def pocket_frame(program: Program, top_z: float) -> dict[str, float | int]: |
| floor_z = top_z - 11.0 |
| depth = lambda z: top_z - z |
| cutting = [segment for segment in program.segments if segment.tool == 1 and segment.motion in (1, 2, 3) and max(depth(segment.start.z), depth(segment.end.z)) > 0.1] |
| if not cutting: |
| raise EvaluationError("missing A-side pocket cutting") |
| floor_points: list[Point] = [] |
| cutting_wcs = set() |
| for segment in cutting: |
| cutting_state(segment, 1) |
| if segment.cutter_comp: |
| raise EvaluationError("A-side rough pocket may not depend on controller cutter compensation") |
| cutting_wcs.add(segment.wcs) |
| for point in segment.samples: |
| point_depth = depth(point.z) |
| if point_depth <= 0.1: |
| continue |
| if point_depth > 11.0 + DEPTH_TOL or abs(point.x) > 20.35 or abs(point.y) > 9.35: |
| raise EvaluationError("T1 cuts outside or below the A-side pocket") |
| if abs(point.z - floor_z) <= DEPTH_TOL: |
| floor_points.append(point) |
| if len(cutting_wcs) != 1 or None in cutting_wcs or len(floor_points) < 80: |
| raise EvaluationError("A-side pocket lacks one valid setup or enough full-depth cutting") |
| targets = [(float(x), float(y)) for x in range(-25, 26) for y in range(-14, 15)] |
| radius = TOOLS[1]["diameter"] / 2 + 0.4 |
| coverage = spatial_coverage(targets, floor_points, radius) |
| if coverage < 0.983: |
| raise EvaluationError("A-side pocket floor is undercovered") |
| for segment in program.segments: |
| if segment.tool != 1 or segment.motion != 0: |
| continue |
| xy_length = math.hypot(segment.end.x - segment.start.x, segment.end.y - segment.start.y) |
| if xy_length > 0.1 and max(depth(segment.start.z), depth(segment.end.z)) > -1.0: |
| raise EvaluationError("unsafe low lateral rapid in A-side pocket") |
| if xy_length <= 0.1 and depth(segment.end.z) >= 11.0 - DEPTH_TOL: |
| raise EvaluationError("A-side rapid reaches the final floor") |
| first_cut = min(segment.line for segment in cutting) |
| last_cut = max(segment.line for segment in cutting) |
| if depth(cutting[0].start.z) > -1.0: |
| raise EvaluationError("A-side pocket has no safe initial approach") |
| if not any(segment.tool == 1 and segment.motion == 0 and segment.line > last_cut and depth(segment.end.z) <= -1.0 for segment in program.segments): |
| raise EvaluationError("A-side pocket has no safe final retract") |
| return {"frame_top_z_mm": top_z, "floor_z_mm": floor_z, "pocket_coverage": round(coverage, 6), "floor_samples": len(floor_points), "first_cut_line": first_cut} |
|
|
|
|
| def validate_a_source(source: str) -> dict[str, float | int]: |
| program = source_guard(source) |
| if program.tool_changes != [1]: |
| raise EvaluationError("A output must change exactly to T1") |
| return pocket_frame(program, 0.0) |
|
|
|
|
| def counterbore_targets(center: tuple[float, float], spacing: float = 0.5) -> list[tuple[float, float]]: |
| cx, cy = center |
| steps = int(math.ceil(5.5 / spacing)) |
| return [(cx + ix * spacing, cy + iy * spacing) for ix in range(-steps, steps + 1) for iy in range(-steps, steps + 1) if math.hypot(ix * spacing, iy * spacing) <= 5.5 + 1e-9] |
|
|
|
|
| def b_frame(program: Program, direction: int) -> dict[str, float | int]: |
| depth = lambda z: direction * z |
| drill_events = [event for event in [*program.cycles, *explicit_drills(program, direction)] if event.tool == 2] |
| if len(drill_events) != 4: |
| raise EvaluationError("B output requires exactly four T2 drilling events") |
| for event in drill_events: |
| drill_state(event) |
| if not any(math.hypot(event.x - x, event.y - y) <= 0.35 for x, y in B_HOLES): |
| raise EvaluationError("T2 drilled an unexpected center") |
| if not close(depth(event.bottom_z), 8.0, DEPTH_TOL): |
| raise EvaluationError("T2 hole depth is not 8 mm") |
| if event.approach_z is None or event.retract_z is None or depth(event.approach_z) > -1.0 or depth(event.retract_z) > -1.0: |
| raise EvaluationError("unsafe T2 approach or retract") |
| for hole in B_HOLES: |
| if sum(math.hypot(event.x - hole[0], event.y - hole[1]) <= 0.35 for event in drill_events) != 1: |
| raise EvaluationError("missing or duplicate T2 hole") |
|
|
| floor_points: dict[tuple[float, float], list[Point]] = {hole: [] for hole in B_HOLES} |
| t3_cutting = [segment for segment in program.segments if segment.tool == 3 and segment.motion in (1, 2, 3) and max(depth(segment.start.z), depth(segment.end.z)) > 0.1] |
| if not t3_cutting: |
| raise EvaluationError("missing T3 counterbore cutting") |
| cutting_wcs = {event.wcs for event in drill_events} |
| for segment in t3_cutting: |
| cutting_state(segment, 3) |
| if segment.cutter_comp: |
| if segment.d_offset not in {3, 23}: |
| raise EvaluationError("T3 cutter compensation is not bound to the T3 wear register") |
| if segment.motion in (2, 3) and not ((segment.motion == 3 and segment.cutter_comp == 41) or (segment.motion == 2 and segment.cutter_comp == 42)): |
| raise EvaluationError("T3 arc direction conflicts with cutter-compensation side") |
| cutting_wcs.add(segment.wcs) |
| for point in segment.samples: |
| point_depth = depth(point.z) |
| if point_depth <= 0.1: |
| continue |
| nearest = min(B_HOLES, key=lambda hole: math.hypot(point.x - hole[0], point.y - hole[1])) |
| radial = math.hypot(point.x - nearest[0], point.y - nearest[1]) |
| if radial > 1.85 or point_depth > 4.0 + DEPTH_TOL: |
| raise EvaluationError("T3 cuts outside or below a D11 counterbore") |
| if abs(point_depth - 4.0) <= DEPTH_TOL: |
| floor_points[nearest].append(point) |
| if len(cutting_wcs) != 1 or None in cutting_wcs: |
| raise EvaluationError("B tools do not share one valid setup") |
| coverages = [] |
| tool_radius = TOOLS[3]["diameter"] / 2 + 0.15 |
| for hole in B_HOLES: |
| points = floor_points[hole] |
| if len(points) < 8: |
| raise EvaluationError("counterbore lacks full-depth T3 motion") |
| targets = counterbore_targets(hole) |
| coverage = spatial_coverage(targets, points, tool_radius) |
| if coverage < 0.985: |
| raise EvaluationError("D11 counterbore floor is undercovered") |
| coverages.append(coverage) |
|
|
| for segment in program.segments: |
| xy_length = math.hypot(segment.end.x - segment.start.x, segment.end.y - segment.start.y) |
| if segment.tool == 2 and segment.motion in (1, 2, 3) and max(depth(segment.start.z), depth(segment.end.z)) > 0.1 and xy_length > 0.1: |
| raise EvaluationError("T2 performs lateral subsurface cutting") |
| if segment.tool in (2, 3) and segment.motion == 0: |
| if xy_length > 0.1 and max(depth(segment.start.z), depth(segment.end.z)) > -1.0: |
| raise EvaluationError("unsafe low lateral rapid in B setup") |
| limit = 8.0 if segment.tool == 2 else 4.0 |
| if xy_length <= 0.1 and depth(segment.end.z) >= limit - DEPTH_TOL: |
| raise EvaluationError("B-side rapid reaches a final floor") |
| last_t3 = max(segment.line for segment in t3_cutting) |
| if depth(t3_cutting[0].start.z) > -1.0: |
| raise EvaluationError("T3 has no safe initial approach") |
| if not any(segment.tool == 3 and segment.motion == 0 and segment.line > last_t3 and depth(segment.end.z) <= -1.0 for segment in program.segments): |
| raise EvaluationError("T3 has no safe final retract") |
| return {"direction": direction, "pilot_depth_mm": 8.0, "counterbore_depth_mm": 4.0, "minimum_counterbore_coverage": round(min(coverages), 6)} |
|
|
|
|
| def validate_b_source(source: str) -> dict[str, float | int]: |
| program = source_guard(source) |
| if len(program.tool_changes) != 2 or set(program.tool_changes) != {2, 3}: |
| raise EvaluationError("B output must change exactly once to T2 and T3") |
| return b_frame(program, -1) |
|
|
|
|
| def evaluate_pair(a_source: str, b_source: str) -> bool: |
| try: |
| validate_a_source(a_source) |
| validate_b_source(b_source) |
| return True |
| except (EvaluationError, ValueError, OverflowError, MemoryError): |
| return False |
|
|
|
|
| def validate_outputs(target: Path) -> dict[str, object]: |
| for name, expected in FORMAL_INPUT_SHA256.items(): |
| path = target / name |
| if not path.is_file() or sha256(path) != expected: |
| raise EvaluationError(f"formal input hash mismatch: {name}") |
| outputs = {A_NC_NAME: target / A_NC_NAME, B_NC_NAME: target / B_NC_NAME} |
| for name, path in outputs.items(): |
| if not path.is_file() or path.stat().st_size < 200 or path.stat().st_size > MAX_BYTES: |
| raise EvaluationError(f"missing, empty, or excessive {name}") |
| a_source = outputs[A_NC_NAME].read_text(encoding="utf-8", errors="strict") |
| b_source = outputs[B_NC_NAME].read_text(encoding="utf-8", errors="strict") |
| return {"A": validate_a_source(a_source), "B": validate_b_source(b_source)} |
|
|
|
|
| def main() -> bool: |
| try: |
| validate_outputs(TARGET) |
| return True |
| except Exception: |
| return False |
|
|
|
|
| if __name__ == "__main__": |
| print("True" if main() else "False") |
| raise SystemExit(0) |
|
|
