| 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: |
| |
| 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") |
|
|
