task/single-software-execution/gui/solidcam/task-13/eval.py

from __future__ import annotations

import math
import os
import re
from dataclasses import dataclass, field
from pathlib import Path


DEFAULT_TARGET = r"C:\Users\User\Desktop"
TARGET = Path(os.environ.get("EVAL_TARGET_DIR", os.environ.get("OUTPUT_ROOT", DEFAULT_TARGET)))
OUTPUT_NAME = "task-13.nc"
WORD_RE = re.compile(r"([A-Z])\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+))", re.IGNORECASE)
COMMENT_RE = re.compile(r"\([^()]*\)")
LINEAR_TOL = 1.5
Z_TOL = 0.65


@dataclass
class Record:
    line: int
    section: int
    motion: int
    start: dict[str, float | None]
    end: dict[str, float | None]
    explicit: dict[str, float]
    tool: int
    wcs: str | None
    operation: str | None
    spindle_on: bool
    feed: float | None
    explicit_feed: float | None
    cutter_comp: int | None
    tool_diameter: float | None


@dataclass
class Section:
    tool: int
    tool_diameter: float | None
    records: list[Record] = field(default_factory=list)
    has_g43: bool = False


@dataclass
class Program:
    records: list[Record] = field(default_factory=list)
    sections: list[Section] = field(default_factory=list)
    units_seen: set[int] = field(default_factory=set)
    axes_seen: set[str] = field(default_factory=set)
    m_codes_seen: set[int] = field(default_factory=set)
    m30_lines: list[int] = field(default_factory=list)
    code_lines: list[str] = field(default_factory=list)


@dataclass
class Rectangle:
    z: float
    section: int
    center: tuple[float, float]
    axis: tuple[float, float]
    normal: tuple[float, float]
    long_dim: float
    short_dim: float
    compensated: bool
    tool_diameter: float | None


@dataclass
class FacePattern:
    z: float
    tracks: int
    along_span: float
    cross_span: float
    tool_diameter: float | None


def close(left: float, right: float, tolerance: float = LINEAR_TOL) -> bool:
    return abs(float(left) - float(right)) <= tolerance


def code_only(raw: str) -> str:
    return COMMENT_RE.sub(" ", raw.upper()).split(";", 1)[0]


def operation_from_comments(raw: str, current: str | None) -> str | None:
    for comment in COMMENT_RE.findall(raw.upper()):
        if re.search(r"\b(?:CONTOUR|PROFILE)\b", comment):
            current = "profile"
        elif re.search(r"\bFACE(?:\s+MILL(?:ING)?)?\b", comment):
            current = "face"
    return current


def diameter_from_comments(raw: str) -> float | None:
    for comment in COMMENT_RE.findall(raw.upper()):
        metric = re.search(r"\b(\d+(?:\.\d+)?)\s*MM\b", comment)
        if metric:
            candidate = float(metric.group(1))
            return candidate if 1.0 <= candidate <= 100.0 else None
        inch = re.search(r"\b(\d+(?:\.\d+)?)\s*(?:IN|INCH)\b", comment)
        if inch:
            candidate = float(inch.group(1)) * 25.4
            return candidate if 1.0 <= candidate <= 100.0 else None
        body = comment[1:-1].strip()
        fraction = re.search(r"^(\d{1,2})\s*/\s*(\d{1,2})\s+(?:EM|END\s+MILL)\b", body)
        if fraction:
            numerator, denominator = map(int, fraction.groups())
            if (
                denominator in {2, 4, 8, 16, 32, 64}
                and 0 < numerator < denominator
                and math.gcd(numerator, denominator) == 1
            ):
                candidate = numerator / denominator * 25.4
                return candidate if 1.0 <= candidate <= 100.0 else None
    return None


def parse_program(source: str) -> Program:
    program = Program()
    position: dict[str, float | None] = {"x": None, "y": None, "z": None}
    unit_scale: float | None = None
    absolute = True
    wcs: str | None = None
    operation: str | None = None
    pending_tool_diameter: float | None = None
    pending_tool_diameter_line: int | None = None
    pending_tool: int | None = None
    current_tool: int | None = None
    section_index: int | None = None
    modal_motion: int | None = None
    spindle_on = False
    modal_feed: float | None = None
    cutter_comp: int | None = None

    for line_number, raw in enumerate(source.splitlines()):
        operation = operation_from_comments(raw, operation)
        diameter_hint = diameter_from_comments(raw)
        if diameter_hint is not None:
            pending_tool_diameter = diameter_hint
            pending_tool_diameter_line = line_number
        code = code_only(raw)
        program.code_lines.append(code)
        words = [(letter.upper(), float(value)) for letter, value in WORD_RE.findall(code)]
        if not words:
            continue
        g_codes = [int(round(value)) for letter, value in words if letter == "G"]
        m_codes = [int(round(value)) for letter, value in words if letter == "M"]
        program.m_codes_seen.update(m_codes)
        if 20 in g_codes:
            unit_scale = 25.4
            program.units_seen.add(20)
        if 21 in g_codes:
            unit_scale = 1.0
            program.units_seen.add(21)
        if 90 in g_codes:
            absolute = True
        if 91 in g_codes:
            absolute = False
        for value in g_codes:
            if 54 <= value <= 59:
                wcs = f"G{value}"
        for letter, value in words:
            if letter == "T":
                pending_tool = int(round(value))
            if letter in {"X", "Y", "Z", "A", "B", "C", "U", "V", "W"}:
                program.axes_seen.add(letter)
        if 6 in m_codes:
            if pending_tool is None or pending_tool <= 0:
                raise ValueError("M6 without a valid tool")
            current_tool = pending_tool
            recent_diameter = (
                pending_tool_diameter
                if pending_tool_diameter_line is not None and line_number - pending_tool_diameter_line <= 3
                else None
            )
            program.sections.append(Section(current_tool, recent_diameter))
            section_index = len(program.sections) - 1
            pending_tool_diameter = None
            pending_tool_diameter_line = None
            spindle_on = False
            cutter_comp = None
        if 3 in m_codes or 4 in m_codes:
            spindle_on = True
        if 5 in m_codes:
            spindle_on = False
        if 30 in m_codes:
            program.m30_lines.append(line_number)
        if 43 in g_codes and section_index is not None:
            program.sections[section_index].has_g43 = True
        if 40 in g_codes:
            cutter_comp = None
        if 41 in g_codes or 42 in g_codes:
            cutter_comp = 41 if 41 in g_codes else 42
        if 80 in g_codes:
            modal_motion = None
        explicit_motion = next((value for value in g_codes if value in {0, 1, 2, 3}), None)
        if explicit_motion is not None:
            modal_motion = explicit_motion

        converted: dict[str, float] = {}
        if unit_scale is not None:
            converted = {
                letter.lower(): value * unit_scale
                for letter, value in words
                if letter in {"X", "Y", "Z", "I", "J", "K", "R"}
            }
            feeds = [value * unit_scale for letter, value in words if letter == "F"]
            if feeds:
                modal_feed = feeds[-1]
        explicit_feed = feeds[-1] if unit_scale is not None and feeds else None
        machine_coordinate = 53 in g_codes or 28 in g_codes or 30 in g_codes
        start = dict(position)
        if not machine_coordinate and unit_scale is not None:
            for axis in ("x", "y", "z"):
                if axis not in converted:
                    continue
                if absolute:
                    position[axis] = converted[axis]
                elif position[axis] is not None:
                    position[axis] += converted[axis]
                else:
                    raise ValueError("incremental motion before a known work position")
        if machine_coordinate or current_tool is None or section_index is None or modal_motion is None:
            continue
        if not any(axis in converted for axis in ("x", "y", "z")) and not (
            modal_motion in {2, 3} and any(axis in converted for axis in ("i", "j", "r"))
        ):
            continue
        record = Record(
            line_number,
            section_index,
            modal_motion,
            start,
            dict(position),
            converted,
            current_tool,
            wcs,
            operation,
            spindle_on,
            modal_feed,
            explicit_feed,
            cutter_comp,
            program.sections[section_index].tool_diameter,
        )
        program.records.append(record)
        program.sections[section_index].records.append(record)
    return program


def point(record: Record, which: str = "end") -> tuple[float, float] | None:
    state = record.start if which == "start" else record.end
    if state["x"] is None or state["y"] is None:
        return None
    return float(state["x"]), float(state["y"])


def xy_length(record: Record) -> float:
    start, end = point(record, "start"), point(record)
    return 0.0 if start is None or end is None else math.dist(start, end)


def is_xy_cut(record: Record) -> bool:
    return record.motion in {1, 2, 3} and (
        xy_length(record) > 1.0e-6
        or (record.motion in {2, 3} and any(axis in record.explicit for axis in ("i", "j", "r")))
    )


def project(value: tuple[float, float], axis: tuple[float, float]) -> float:
    return value[0] * axis[0] + value[1] * axis[1]


def cluster_tracks(items: list[tuple[float, float, float]], tolerance: float = 1.2):
    clusters: list[dict[str, object]] = []
    for fixed, low, high in sorted(items):
        target = next((item for item in clusters if abs(float(item["fixed"]) - fixed) <= tolerance), None)
        if target is None:
            clusters.append({"fixed": fixed, "values": [fixed], "intervals": [(low, high)]})
        else:
            values = target["values"]
            intervals = target["intervals"]
            assert isinstance(values, list) and isinstance(intervals, list)
            values.append(fixed)
            intervals.append((low, high))
            target["fixed"] = sum(values) / len(values)
    return clusters


def covered_fraction(intervals: list[tuple[float, float]], low: float, high: float) -> float:
    clipped = sorted((max(low, a), min(high, b)) for a, b in intervals if min(high, b) > max(low, a))
    if not clipped or high <= low:
        return 0.0
    merged: list[list[float]] = []
    for left, right in clipped:
        if not merged or left > merged[-1][1] + 1.0:
            merged.append([left, right])
        else:
            merged[-1][1] = max(merged[-1][1], right)
    return sum(right - left for left, right in merged) / (high - low)


def rectangles_at_level(records: list[Record], z: float, section: int) -> list[Rectangle]:
    straight = [
        record
        for record in records
        if record.section == section
        and record.motion == 1
        and record.end["z"] is not None
        and close(float(record.end["z"]), z, 0.3)
        and xy_length(record) >= 8.0
    ]
    found: list[Rectangle] = []
    for seed in straight:
        start, end = point(seed, "start"), point(seed)
        assert start is not None and end is not None
        delta = (end[0] - start[0], end[1] - start[1])
        length = math.hypot(*delta)
        axis = (delta[0] / length, delta[1] / length)
        normal = (-axis[1], axis[0])
        along: list[tuple[float, float, float]] = []
        across: list[tuple[float, float, float]] = []
        for record in straight:
            left, right = point(record, "start"), point(record)
            assert left is not None and right is not None
            vector = (right[0] - left[0], right[1] - left[1])
            segment_length = math.hypot(*vector)
            if segment_length <= 1.0e-9:
                continue
            direction = (vector[0] / segment_length, vector[1] / segment_length)
            if abs(direction[0] * axis[0] + direction[1] * axis[1]) >= 0.995:
                values = sorted((project(left, axis), project(right, axis)))
                along.append(((project(left, normal) + project(right, normal)) / 2.0, *values))
            elif abs(direction[0] * normal[0] + direction[1] * normal[1]) >= 0.995:
                values = sorted((project(left, normal), project(right, normal)))
                across.append(((project(left, axis) + project(right, axis)) / 2.0, *values))
        u_tracks, v_tracks = cluster_tracks(along), cluster_tracks(across)
        for first_u_index, first_u in enumerate(u_tracks):
            for second_u in u_tracks[first_u_index + 1 :]:
                v_low, v_high = sorted((float(first_u["fixed"]), float(second_u["fixed"])))
                for first_v_index, first_v in enumerate(v_tracks):
                    for second_v in v_tracks[first_v_index + 1 :]:
                        u_low, u_high = sorted((float(first_v["fixed"]), float(second_v["fixed"])))
                        dimensions = sorted((u_high - u_low, v_high - v_low), reverse=True)
                        compensated = any(record.cutter_comp in {41, 42} for record in straight)
                        diameter = next((record.tool_diameter for record in straight if record.tool_diameter), None)
                        nominal_path = close(dimensions[0], 70.0, 3.0) and close(dimensions[1], 50.0, 3.0)
                        tool_center_offset_path = (
                            diameter is not None
                            and close(dimensions[0], 70.0 + diameter, 3.0)
                            and close(dimensions[1], 50.0 + diameter, 3.0)
                        )
                        if not (nominal_path or tool_center_offset_path):
                            continue
                        edge_items = (first_u, second_u, first_v, second_v)
                        spans = (
                            covered_fraction(first_u["intervals"], u_low, u_high),
                            covered_fraction(second_u["intervals"], u_low, u_high),
                            covered_fraction(first_v["intervals"], v_low, v_high),
                            covered_fraction(second_v["intervals"], v_low, v_high),
                        )
                        if min(spans) < 0.72:
                            continue
                        center_u, center_v = (u_low + u_high) / 2.0, (v_low + v_high) / 2.0
                        center = (
                            center_u * axis[0] + center_v * normal[0],
                            center_u * axis[1] + center_v * normal[1],
                        )
                        long_axis, short_axis = axis, normal
                        if u_high - u_low < v_high - v_low:
                            long_axis, short_axis = normal, (-axis[0], -axis[1])
                        found.append(
                            Rectangle(
                                z,
                                section,
                                center,
                                long_axis,
                                short_axis,
                                dimensions[0],
                                dimensions[1],
                                compensated,
                                diameter,
                            )
                        )
    unique: list[Rectangle] = []
    for item in found:
        if not any(
            close(item.long_dim, old.long_dim, 0.8)
            and close(item.short_dim, old.short_dim, 0.8)
            and math.dist(item.center, old.center) <= 1.0
            for old in unique
        ):
            unique.append(item)
    return unique


def find_profile(records: list[Record]) -> Rectangle | None:
    candidates: list[Rectangle] = []
    sections = sorted({record.section for record in records})
    for section in sections:
        levels = sorted(
            {
                round(float(record.end["z"]), 2)
                for record in records
                if record.section == section and record.end["z"] is not None and is_xy_cut(record)
            }
        )
        for level in levels:
            candidates.extend(rectangles_at_level(records, level, section))
    return min(candidates, key=lambda item: item.z) if candidates else None


def local(value: tuple[float, float], rectangle: Rectangle) -> tuple[float, float]:
    delta = (value[0] - rectangle.center[0], value[1] - rectangle.center[1])
    return project(delta, rectangle.axis), project(delta, rectangle.normal)


def same_point(left: Record, right: Record, tolerance: float = 0.08) -> bool:
    left_point, right_point = point(left), point(right, "start")
    if left_point is None or right_point is None:
        return False
    left_z, right_z = left.end["z"], right.start["z"]
    return (
        math.dist(left_point, right_point) <= tolerance
        and left_z is not None
        and right_z is not None
        and close(float(left_z), float(right_z), tolerance)
    )


def segment_intersects_nominal_interior(
    start: tuple[float, float], end: tuple[float, float]
) -> bool:
    # Liang-Barsky against a slightly shrunken open 70 x 50 mm rectangle.
    xmin, xmax, ymin, ymax = -34.95, 34.95, -24.95, 24.95
    dx, dy = end[0] - start[0], end[1] - start[1]
    p = (-dx, dx, -dy, dy)
    q = (start[0] - xmin, xmax - start[0], start[1] - ymin, ymax - start[1])
    low, high = 0.0, 1.0
    for denominator, numerator in zip(p, q):
        if abs(denominator) <= 1.0e-12:
            if numerator < 0.0:
                return False
            continue
        ratio = numerator / denominator
        if denominator < 0.0:
            low = max(low, ratio)
        else:
            high = min(high, ratio)
        if low > high:
            return False
    return True


def valid_zero_feed_link(record: Record, records: list[Record], profile: Rectangle) -> bool:
    if record.motion != 1 or record.explicit_feed is None or abs(record.explicit_feed) > 1.0e-9:
        return False
    if record.start["z"] is None or record.end["z"] is None:
        return False
    if not close(float(record.start["z"]), float(record.end["z"]), 0.05):
        return False
    start, end = point(record, "start"), point(record)
    if start is None or end is None:
        return False
    try:
        index = records.index(record)
    except ValueError:
        return False
    neighbors = []
    if index > 0:
        neighbors.append((records[index - 1], same_point(records[index - 1], record)))
    if index + 1 < len(records):
        neighbors.append((records[index + 1], same_point(record, records[index + 1])))
    if not any(
        shared
        and neighbor.motion == 1
        and neighbor.feed is not None
        and neighbor.feed > 0
        and neighbor.end["z"] is not None
        and close(float(neighbor.end["z"]), float(record.end["z"]), 0.05)
        for neighbor, shared in neighbors
    ):
        return False
    return not segment_intersects_nominal_interior(local(start, profile), local(end, profile))


def face_patterns(records: list[Record], rectangle: Rectangle) -> list[FacePattern]:
    result: list[FacePattern] = []
    for section in sorted({record.section for record in records}):
        levels = sorted(
            {
                round(float(record.end["z"]), 2)
                for record in records
                if record.section == section and record.end["z"] is not None and is_xy_cut(record)
            }
        )
        for level in levels:
            level_records = [
                record
                for record in records
                if record.section == section
                and record.motion == 1
                and record.feed is not None
                and record.feed > 0
                and record.end["z"] is not None
                and close(float(record.end["z"]), level, 0.3)
                and xy_length(record) >= 8.0
            ]
            for direction, cross_direction, nominal_along, nominal_cross in (
                (rectangle.axis, rectangle.normal, 70.0, 50.0),
                (rectangle.normal, rectangle.axis, 50.0, 70.0),
            ):
                tracks: list[tuple[float, float, float]] = []
                for record in level_records:
                    start, end = point(record, "start"), point(record)
                    assert start is not None and end is not None
                    vector = (end[0] - start[0], end[1] - start[1])
                    length = math.hypot(*vector)
                    alignment = abs((vector[0] * direction[0] + vector[1] * direction[1]) / length)
                    if alignment < 0.995 or length < nominal_along * 0.72:
                        continue
                    along = sorted((project(start, direction), project(end, direction)))
                    cross = (project(start, cross_direction) + project(end, cross_direction)) / 2.0
                    tracks.append((cross, along[0], along[1]))
                clustered = cluster_tracks(tracks)
                if not clustered:
                    continue
                cross_values = [float(item["fixed"]) for item in clustered]
                along_low = min(low for _, low, _ in tracks)
                along_high = max(high for _, _, high in tracks)
                center_cross = project(rectangle.center, cross_direction)
                center_along = project(rectangle.center, direction)
                cross_span = max(cross_values) - min(cross_values)
                tool_diameter = next((record.tool_diameter for record in level_records if record.tool_diameter), None)
                if tool_diameter is not None and not 3.0 <= tool_diameter <= 100.0:
                    continue
                radius = (tool_diameter or 0.0) / 2.0
                if along_high - along_low + 2.0 * radius < nominal_along - 2.0:
                    continue
                if not (
                    along_low - radius <= center_along - nominal_along / 2.0 + 2.0
                    and along_high + radius >= center_along + nominal_along / 2.0 - 2.0
                ):
                    continue
                if cross_span + 2.0 * radius < nominal_cross - 2.0:
                    continue
                if not (
                    min(cross_values) - radius <= center_cross - nominal_cross / 2.0 + 2.0
                    and max(cross_values) + radius >= center_cross + nominal_cross / 2.0 - 2.0
                ):
                    continue
                result.append(
                    FacePattern(float(level), len(clustered), along_high - along_low, cross_span, tool_diameter)
                )
    return result


def has_interior_deep_cut(records: list[Record], rectangle: Rectangle, face_z: float) -> bool:
    for record in records:
        if not is_xy_cut(record) or record.end["z"] is None or float(record.end["z"]) > face_z - 1.0:
            continue
        start, end = point(record, "start"), point(record)
        if start is None or end is None or xy_length(record) < 3.0:
            continue
        middle = ((start[0] + end[0]) / 2.0, (start[1] + end[1]) / 2.0)
        u, v = local(middle, rectangle)
        if abs(u) < 30.0 and abs(v) < 20.0:
            return True
    return False


def safe_rapids(program: Program, face_z: dict[str, float]) -> bool:
    for record in program.records:
        if record.motion != 0 or xy_length(record) <= 1.0e-6 or record.wcs not in face_z:
            continue
        heights = [float(value) for value in (record.start["z"], record.end["z"]) if value is not None]
        if heights and min(heights) < face_z[record.wcs] + 0.9:
            return False
    return True


def read_nc(path: Path) -> str | None:
    try:
        if not path.is_file() or not 500 <= path.stat().st_size <= 2_000_000:
            return None
        data = path.read_bytes()
        if b"\x00" in data:
            return None
        source = data.decode("latin-1")
        printable = sum(ch in "\t\r\n" or 32 <= ord(ch) <= 126 for ch in source)
        return source if printable / max(1, len(source)) >= 0.98 else None
    except Exception:
        return None


def validate_nc(path: Path) -> bool:
    source = read_nc(path)
    if source is None:
        return False
    try:
        program = parse_program(source)
    except Exception:
        return False
    if len(program.units_seen) != 1 or program.axes_seen & {"A", "B", "C", "U", "V", "W"}:
        return False
    if not {6, 30} <= program.m_codes_seen or not ({3, 4} & program.m_codes_seen):
        return False
    if len(program.m30_lines) != 1 or any(WORD_RE.search(line) for line in program.code_lines[program.m30_lines[0] + 1 :]):
        return False
    xy_cuts = [record for record in program.records if is_xy_cut(record)]
    if len(xy_cuts) < 20 or {record.wcs for record in xy_cuts} != {"G54", "G55"}:
        return False
    if any(record.operation not in {"face", "profile"} for record in xy_cuts):
        return False
    if any(not record.spindle_on for record in xy_cuts):
        return False
    used_sections = {record.section for record in xy_cuts}
    if any(not program.sections[index].has_g43 for index in used_sections):
        return False

    profiles: dict[str, Rectangle] = {}
    faces: dict[str, FacePattern] = {}
    for wcs in ("G54", "G55"):
        profile_records = [record for record in xy_cuts if record.wcs == wcs and record.operation == "profile"]
        face_records = [record for record in xy_cuts if record.wcs == wcs and record.operation == "face"]
        profile = find_profile(profile_records)
        if profile is None:
            return False
        for record in profile_records:
            if record.feed is None or record.feed <= 0:
                return False
        for record in face_records:
            if record.feed is not None and record.feed > 0:
                continue
            if not valid_zero_feed_link(record, face_records, profile):
                return False
        candidates = [
            item
            for item in face_patterns(face_records, profile)
            if 11.0 <= item.z - profile.z <= 14.5
        ]
        if not candidates:
            return False
        face = max(candidates, key=lambda item: (item.tracks, item.along_span))
        if has_interior_deep_cut(profile_records, profile, face.z):
            return False
        profiles[wcs], faces[wcs] = profile, face

    first_profile, second_profile = profiles["G54"], profiles["G55"]
    if not close(first_profile.long_dim, second_profile.long_dim, 2.0):
        return False
    if not close(first_profile.short_dim, second_profile.short_dim, 2.0):
        return False
    first_depth = faces["G54"].z - first_profile.z
    second_depth = faces["G55"].z - second_profile.z
    if not close(first_depth, second_depth, 1.5):
        return False
    if abs(faces["G54"].tracks - faces["G55"].tracks) > 1:
        return False
    if not close(faces["G54"].along_span, faces["G55"].along_span, 3.0):
        return False
    diameters = (faces["G54"].tool_diameter, faces["G55"].tool_diameter)
    if None not in diameters and not close(float(diameters[0]), float(diameters[1]), 0.5):
        return False
    if not safe_rapids(program, {name: faces[name].z for name in faces}):
        return False
    return True


def evaluate() -> bool:
    return validate_nc(TARGET / OUTPUT_NAME)


if __name__ == "__main__":
    try:
        result = evaluate()
    except Exception:
        result = False
    print("True" if result else "False")