| |
| """Metric-v4.1 representation normalisation. |
| |
| Some CAD exports encode an almost-straight outline edge as a huge-radius ARC. |
| At engineering-drawing tolerance that is the same geometry as its chord, but a |
| primitive-family matcher treats it as unrelated to a LINE. V4.1 flattens only |
| arcs whose sagitta is below 0.05 mm or 0.1% of the drawing diagonal, then uses |
| the otherwise unchanged and tested v4 implementation. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import math |
| from typing import Any |
|
|
| try: |
| from . import eval_geometric02 as EV2 |
| from . import eval_geometric04 as BASE |
| except ImportError: |
| import eval_geometric02 as EV2 |
| import eval_geometric04 as BASE |
|
|
|
|
| extract_entities = BASE.extract_entities |
| legacy_dimension_entities = BASE.legacy_dimension_entities |
| representation_quality = BASE.representation_quality |
| score_dimension_consistency = BASE.score_dimension_consistency |
| score_disk_semantics = BASE.score_disk_semantics |
|
|
|
|
| def _arc_chord(arc: tuple[Any, ...]) -> tuple[float, float, float, float, str]: |
| cx, cy, radius, start, end, layer = arc |
| start_rad = math.radians(float(start)) |
| end_rad = math.radians(float(end)) |
| return ( |
| float(cx) + float(radius) * math.cos(start_rad), |
| float(cy) + float(radius) * math.sin(start_rad), |
| float(cx) + float(radius) * math.cos(end_rad), |
| float(cy) + float(radius) * math.sin(end_rad), |
| str(layer), |
| ) |
|
|
|
|
| def _sagitta(arc: tuple[Any, ...]) -> float: |
| radius = abs(float(arc[2])) |
| span = math.radians(float((float(arc[4]) - float(arc[3])) % 360.0)) |
| return radius * (1.0 - math.cos(span / 2.0)) |
|
|
|
|
| def canonicalize_entities( |
| entities: dict[str, Any], |
| *, |
| abs_tol: float = BASE.CANONICAL_ABS_TOL, |
| rel_tol: float = BASE.CANONICAL_REL_TOL, |
| ) -> dict[str, Any]: |
| """Flatten visually straight arcs, then apply v4 collinear merging.""" |
|
|
| diagonal = max(BASE.EV2.bbox_diagonal(entities), 1.0) |
| flatten_tolerance = max(0.05, 0.001 * diagonal) |
| prepared = { |
| "lines": list(entities.get("lines", [])), |
| "circles": list(entities.get("circles", [])), |
| "arcs": [], |
| "dims": list(entities.get("dims", [])), |
| } |
| for arc in entities.get("arcs", []): |
| if _sagitta(arc) <= flatten_tolerance: |
| prepared["lines"].append(_arc_chord(arc)) |
| else: |
| prepared["arcs"].append(arc) |
| return BASE.canonicalize_entities( |
| prepared, |
| abs_tol=abs_tol, |
| rel_tol=rel_tol, |
| ) |
|
|
|
|
| __all__ = [ |
| "canonicalize_entities", |
| "extract_entities", |
| "legacy_dimension_entities", |
| "representation_quality", |
| "score_dimension_consistency", |
| "score_disk_semantics", |
| ] |
|
|
