emerge 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

emerge/_emerge/geo/pcb_tools/dxf.py

@@ -0,0 +1,361 @@
+
+import re
+from typing import Any
+from ..pcb import PCB, RouteException
+from ...material import Material, PEC
+from ...cs import GCS, CoordinateSystem
+from loguru import logger
+from math import hypot
+
+try: 
+    import ezdxf
+    from ezdxf.recover import readfile as recover_readfile
+    from ezdxf.path import make_path, from_hatch
+except ImportError as e:
+    logger.error('Cannot find the required ezdxf library. Install using: pip install ezdxf')
+    raise e
+
+INSUNITS_TO_NAME = {
+    0: "unitless",
+    1: "inch",
+    2: "foot",
+    3: "mile",
+    4: "millimeter",
+    5: "centimeter",
+    6: "meter",
+    7: "kilometer",
+    8: "microinch",
+    9: "mil",          # thousandth of an inch
+    10: "yard",
+    11: "angstrom",
+    12: "nanometer",
+    13: "micrometer",
+    14: "decimeter",
+    15: "decameter",
+    16: "hectometer",
+    17: "gigameter",
+    18: "astronomical unit",
+    19: "light year",
+    20: "parsec",
+}
+
+# scale factor: drawing units -> millimeters
+INSUNITS_TO_MM = {
+    0: 1.0,           # unitless; treat as mm by convention
+    1: 25.4,
+    2: 304.8,
+    3: 1609344.0,
+    4: 1.0,
+    5: 10.0,
+    6: 1000.0,
+    7: 1_000_000.0,
+    8: 25.4e-6,
+    9: 0.0254,
+    10: 914.4,
+    11: 1e-7,
+    12: 1e-6,
+    13: 1e-3,
+    14: 100.0,
+    15: 10_000.0,
+    16: 100_000.0,
+    17: 1e12,
+    18: 1.495978707e14,     # AU in mm
+    19: 9.460730472e18,     # ly in mm
+    20: 3.085677581e19,     # pc in mm
+}
+
+def cluster_values(values, tol):
+    """Return [(center, count), ...] clustering sorted values by tolerance."""
+    if not values:
+        return []
+    values = sorted(values)
+    clusters = [[values[0]]]
+    for v in values[1:]:
+        if abs(v - clusters[-1][-1]) <= tol:
+            clusters[-1].append(v)
+        else:
+            clusters.append([v])
+    out = []
+    for c in clusters:
+        out.append((sum(c)/len(c), len(c)))
+    return out
+
+STACKUP_TOKENS = [
+    r"fr-?4", r"rogers ?\d+", r"core", r"prepreg", r"dielectric",
+    r"cu(?:\W|$)|copper", r"\b1\.?6\s*mm\b", r"\b0\.?8\s*mm\b",
+    r"\b[12]\s*oz\b", r"\b35\s*µ?m\b", r"\b70\s*µ?m\b",
+    r"stack[- ]?up", r"layer\s*\d+", r"pcb", r"thickness",
+]
+
+def inspect_pcb_from_dxf(
+    filename: str,
+    flatten_tol: float = 0.25,    # curve flattening tolerance (drawing units)
+    z_tol: float | None = None,   # cluster tolerance for Z (drawing units); default auto
+    layer_filter: str | None = None,
+):
+    """
+    Returns a dict with:
+      {
+        'units': {'code': int, 'name': str, 'to_mm': float},
+        'z_levels': [{'z': float, 'count': int}],           # in drawing units
+        'thickness_units': 'same as units',
+        'thickness': float,                                  # in drawing units
+        'thickness_mm': float,                               # convenience
+        'notes': {'materials': [...], 'raw_text_hits': [...]}
+      }
+    """
+    doc, auditor = recover_readfile(filename)
+    msp = doc.modelspace()
+
+    # Units
+    code = int(doc.header.get("$INSUNITS", 0))
+    unit_name = INSUNITS_TO_NAME.get(code, f"unknown({code})")
+    to_mm = INSUNITS_TO_MM.get(code, 1.0)
+
+    # Gather geometry Zs (WCS), also consider entity.dxf.elevation as fallback
+    z_values = []
+
+    def on_layer(e) -> bool:
+        return layer_filter is None or e.dxf.layer == layer_filter
+
+    for e in msp:
+        if not on_layer(e):
+            continue
+        dxtype = e.dxftype()
+        paths = []
+        try:
+            if dxtype in ("HATCH", "MPOLYGON"):
+                paths = list(from_hatch(e))
+            else:
+                paths = [make_path(e)]
+        except TypeError:
+            # skip unsupported entity types
+            pass
+        except Exception:
+            pass
+
+        for p in paths:
+            subs = p.sub_paths() if getattr(p, "has_sub_paths", False) and p.has_sub_paths else [p]
+            for sp in subs:
+                try:
+                    verts = list(sp.flattening(distance=flatten_tol))
+                except Exception:
+                    continue
+                for v in verts:
+                    # v may be Vec2 or Vec3; handle both
+                    z = getattr(v, "z", None)
+                    if z is None:
+                        # fallback to entity elevation if available
+                        z = float(getattr(e.dxf, "elevation", 0.0))
+                    z_values.append(float(z))
+
+        # Entities with explicit THICKNESS (rare but possible)
+        thick = getattr(e.dxf, "thickness", None)
+        if thick not in (None, 0):
+            # If an entity is extruded, its "top" would be at elevation+thickness along normal.
+            # We can't reliably map OCS normal here; just record the magnitude as a hint.
+            pass
+
+    # Cluster Zs
+    auto_tol = (1e-6 if to_mm >= 1.0 else 1e-6 / to_mm)  # ~1 nm in mm space → tiny in most units
+    ztol = z_tol if z_tol is not None else auto_tol
+    z_clusters = cluster_values(z_values, tol=ztol)
+    z_levels = [{"z": z, "count": n} for z, n in z_clusters]
+
+    # Thickness from geometry (only meaningful if multiple distinct Zs)
+    if z_values:
+        zmin, zmax = min(z_values), max(z_values)
+        thickness = zmax - zmin
+    else:
+        zmin = zmax = thickness = 0.0
+
+    # Parse material/thickness hints from TEXT/MTEXT
+    material_hits = set()
+    raw_text_hits = []
+    token_re = re.compile("|".join(STACKUP_TOKENS), re.IGNORECASE)
+
+    for e in msp.query("TEXT MTEXT"):
+        try:
+            text = e.dxf.text if e.dxftype() == "TEXT" else e.text
+        except Exception:
+            continue
+        if not text:
+            continue
+        if token_re.search(text):
+            raw_text_hits.append(text.strip())
+            # simple keyword extraction
+            for kw in ["FR4", "Rogers", "core", "prepreg", "copper", "stackup", "thickness", "oz", "µm", "um", "mm"]:
+                if re.search(kw, text, re.IGNORECASE):
+                    material_hits.add(kw.upper())
+
+    return {
+        "units": {"code": code, "name": unit_name, "to_mm": to_mm},
+        "z_levels": z_levels,
+        "thickness_units": unit_name,
+        "thickness": thickness,
+        "thickness_mm": thickness * to_mm,
+        "notes": {
+            "materials": sorted(material_hits),
+            "raw_text_hits": raw_text_hits[:50],  # cap to keep output sane
+            "comment": (
+                "Single Z level detected; geometry alone cannot determine PCB thickness."
+                if len(z_levels) <= 1 else
+                "Thickness estimated from min/max Z across all geometry."
+            )
+        },
+    }
+
+def path_items_with_semantics(e, p, distance=0.25):
+    """Yield dicts describing each sub-path with geometry + semantics we can infer."""
+    subs = p.sub_paths() if getattr(p, "has_sub_paths", False) and p.has_sub_paths else [p]
+    for sp in subs:
+        verts = list(sp.flattening(distance=distance))
+        if len(verts) < 2:
+            continue
+
+        # geometry in XY (keep Z if you like)
+        pts = [(v.x, v.y) for v in verts]
+        is_closed = pts[0] == pts[-1]
+
+        item = {
+            "layer": e.dxf.layer,
+            "entity": e.dxftype(),
+            "handle": e.dxf.handle,
+            "is_closed": is_closed,
+            "points": pts if is_closed else None,       # polygon ring for closed shapes
+            "start": None,
+            "end": None,
+            "length": None,                             # centerline length for open paths
+            "width": None,                              # LWPOLYLINE width if available
+        }
+
+        if not is_closed:
+            item["start"] = pts[0]
+            item["end"]   = pts[-1]
+            # polyline centerline length
+            item["length"] = sum(
+                hypot(x2 - x1, y2 - y1) for (x1, y1), (x2, y2) in zip(pts, pts[1:])
+            )
+
+        # Preserve potential trace width info from LWPOLYLINE
+        if e.dxftype() == "LWPOLYLINE":
+            cw = getattr(e.dxf, "const_width", None)
+            if cw not in (None, 0):
+                item["width"] = float(cw)
+            else:
+                # per-vertex widths (rare but possible)
+                try:
+                    item["widths"] = [(v[0], v[1]) for v in zip(e.get_start_widths(), e.get_end_widths())]
+                except Exception:
+                    pass
+
+        yield item
+        
+def extract_polygons_with_meta(
+    filename: str,
+    layer: str | None = None,
+    distance: float = 0.25,
+    skip_open: bool = True,
+) -> dict[str, Any]:
+    """
+    Returns a list of dicts:
+      {
+        'ring': [(x, y), ...],         # closed ring
+        'layer': 'LayerName',
+        'z': 12.34,                    # representative height (median Z of ring)
+        'entity': 'LWPOLYLINE' | ...,
+        'handle': 'ABCD'
+      }
+    """
+    doc, auditor = recover_readfile(filename)
+    msp = doc.modelspace()
+
+    def on_layer(e) -> bool:
+        return layer is None or e.dxf.layer == layer
+
+    items = []
+
+    for e in msp:
+        if not on_layer(e):
+            continue
+
+        dxtype = e.dxftype()
+        paths = []
+        try:
+            if dxtype in ("HATCH", "MPOLYGON"):
+                paths = list(from_hatch(e))
+            else:
+                paths = [make_path(e)]
+        except TypeError:
+            continue
+        except Exception:
+            continue
+
+        for p in paths:
+            subs = p.sub_paths() if p.has_sub_paths else [p]
+            for sp in subs:
+                
+                verts = list(sp.flattening(distance=distance))  # Vec3 in WCS
+                if len(verts) < 2:
+                    continue
+
+                # ensure not closed
+                if (verts[0].x, verts[0].y) == (verts[-1].x, verts[-1].y):
+                    verts = verts[:-1]
+
+                # ring in XY (your original target), but also compute a Z for reference
+                ring_xy = [(v.x, v.y) for v in verts]
+                zs = sorted(v.z for v in verts)
+                z = zs[len(zs)//2] if zs else float(getattr(e.dxf, "elevation", 0.0))  # median Z
+
+                items.append({
+                    "ring": ring_xy,
+                    "layer": e.dxf.layer,
+                    "z": float(z),
+                    "entity": dxtype,
+                    "handle": e.dxf.handle,
+                })
+
+    return items
+
+
+def import_dxf(filename: str, 
+               material: Material, 
+               thickness: float | None = None,
+               unit: float | None = None,
+               cs: CoordinateSystem | None = GCS,
+               trace_material: Material = PEC) -> PCB:
+    
+    polies = extract_polygons_with_meta(filename)
+    prop = inspect_pcb_from_dxf(filename)
+    
+    if prop['units']['name'] == 'unitless':
+        if unit is None:
+            raise RouteException(f'Cannot generate PCB because the unit is not found in the DXF file or provided in the import_dxf function.')
+        pcb_unit = unit
+    else:
+        pcb_unit = 0.001 * prop['units']['to_mm']
+    
+    if prop['thickness'] == 0.0:
+        if thickness is None:
+            raise RouteException(f'Cannot generate PCB because no thickness is found int he DXF file and none is provided in the import_dxf function.')
+        pcb_thickness = thickness
+    else:
+        pcb_thickness = 0.001 * prop['thickness_mm'] / pcb_unit
+    
+    if cs is None:
+        cs = GCS
+    
+    zs = sorted(list(set([pol['z'] for pol in polies])))
+    pcb = PCB(pcb_thickness, pcb_unit, cs, material=material, trace_material=trace_material)
+    
+    for poly in polies:
+        xs, ys = zip(*poly['ring'])
+        z = poly['z']
+        zs.append(z)
+        xs = [x for x in xs]
+        ys = [y for y in ys]
+        
+        pcb.add_poly(xs, ys, z=z, name=poly['handle'])
+    return pcb
+    

emerge/_emerge/geo/polybased.py

@@ -24,66 +24,7 @@ from typing import Generator, Callable
 from ..selection import FaceSelection
 from typing import Literal
 from functools import reduce
-from numba import njit
 
-@njit(cache=True)
-def _subsample_coordinates(xs: np.ndarray, ys: np.ndarray, tolerance: float, xmin: float) -> tuple[np.ndarray, np.ndarray]:
-    """This function takes a set of x and y coordinates in a finely sampled set and returns a reduced
-    set of numbers that traces the input curve within a provided tolerance.
-
-    Args:
-        xs (np.ndarray): The set of X-coordinates
-        ys (np.ndarray): The set of Y-coordinates
-        tolerance (float): The maximum deviation of the curve in meters
-        xmin (float): The minimal distance to the next point.
-
-    Returns:
-        np.ndarray: The output X-coordinates
-        np.ndarray: The output Y-coordinates
-    """
-    N = xs.shape[0]
-    ids = np.zeros((N,), dtype=np.int32)
-    store_index = 1
-    start_index = 0
-    final_index = 0
-    for iteration in range(N):
-        i1 = start_index
-        done = 0
-        for i2 in range(i1+1,N):
-            x_true = xs[i1:i2+1]
-            y_true = ys[i1:i2+1]
-
-            x_f = np.linspace(xs[i1],xs[i2], i2-i1+1)
-            y_f = np.linspace(ys[i1],ys[i2], i2-i1+1)
-            error = np.max(np.sqrt((x_f-x_true)**2 + (y_f-y_true)**2))
-            ds = np.sqrt((xs[i2]-xs[i1])**2 + (ys[i2]-ys[i1])**2)
-            # If at the end
-            if i2==N-1: 
-                ids[store_index] = i2-1
-                final_index = store_index + 1
-                done = 1
-                break
-            # If not yet past the minimum distance, accumulate more
-            if ds < xmin:
-                continue
-            # If the end is less than a minimum distance
-            if np.sqrt((ys[-1]-ys[i2])**2 + (xs[-1]-xs[i2])**2) < xmin:
-                imid = i1 + (N-1-i1)//2
-                ids[store_index] = imid
-                ids[store_index+1] = N-1
-                final_index = store_index + 2
-                done = 1
-                break
-            if error < tolerance:
-                continue
-            else:
-                ids[store_index] = i2-1
-                start_index = i2
-                store_index = store_index + 1
-                break
-        if done==1:
-            break
-    return xs[ids[0:final_index]], ys[ids[0:final_index]]
 
 def _discretize_curve(xfunc: Callable, yfunc: Callable, 
                       t0: float, t1: float, xmin: float, tol: float=1e-4) -> tuple[np.ndarray, np.ndarray]:
@@ -100,6 +41,8 @@ def _discretize_curve(xfunc: Callable, yfunc: Callable,
     Returns:
         tuple[np.ndarray, np.ndarray]: _description_
     """
+    from ..mth.optimized import _subsample_coordinates
+    
     td = np.linspace(t0, t1, 10001)
     xs = xfunc(td)
     ys = yfunc(td)
@@ -219,8 +162,9 @@ class GeoPrism(GeoVolume):
                  volume_tag: int,
                  front_tag: int | None = None,
                  side_tags: list[int] | None = None,
-                 _axis: Axis | None = None):
-        super().__init__(volume_tag)
+                 _axis: Axis | None = None,
+                 name: str | None = None):
+        super().__init__(volume_tag, name=name)
         
         
         
@@ -420,7 +364,7 @@ class XYPolygon:
         wiretag = gmsh.model.occ.add_wire(lines)
         return ptags, lines, wiretag
         
-    def _finalize(self, cs: CoordinateSystem) -> GeoPolygon:
+    def _finalize(self, cs: CoordinateSystem, name: str | None = 'GeoPolygon') -> GeoPolygon:
         """Turns the XYPolygon object into a GeoPolygon that is embedded in 3D space.
 
         The polygon will be placed in the XY-plane of the provided coordinate center.
@@ -433,12 +377,12 @@ class XYPolygon:
         """
         ptags, lines, wiretag = self._make_wire(cs)
         surftag = gmsh.model.occ.add_plane_surface([wiretag,])
-        poly = GeoPolygon([surftag,])
+        poly = GeoPolygon([surftag,], name=name)
         poly.points = ptags
         poly.lines = lines
         return poly
     
-    def extrude(self, length: float, cs: CoordinateSystem | None = None) -> GeoPrism:
+    def extrude(self, length: float, cs: CoordinateSystem | None = None, name: str = 'Extrusion') -> GeoPrism:
         """Extrues the polygon along the Z-axis.
         The z-coordinates go from z1 to z2 (in meters). Then the extrusion
         is either provided by a maximum dz distance (in meters) or a number
@@ -458,9 +402,9 @@ class XYPolygon:
         volume = gmsh.model.occ.extrude(poly_fin.dimtags, zax[0], zax[1], zax[2])
         tags = [t for d,t in volume if d==3]
         surftags = [t for d,t in volume if d==2]
-        return GeoPrism(tags, surftags[0], surftags)
+        return GeoPrism(tags, surftags[0], surftags, name=name)
     
-    def geo(self, cs: CoordinateSystem | None = None) -> GeoPolygon:
+    def geo(self, cs: CoordinateSystem | None = None, name: str = 'GeoPolygon') -> GeoPolygon:
         """Returns a GeoPolygon object for the current polygon.
 
         Args:
@@ -475,7 +419,7 @@ class XYPolygon:
             cs = GCS
         return self._finalize(cs) 
     
-    def revolve(self, cs: CoordinateSystem, origin: tuple[float, float, float], axis: tuple[float, float,float], angle: float = 360.0) -> GeoPrism:
+    def revolve(self, cs: CoordinateSystem, origin: tuple[float, float, float], axis: tuple[float, float,float], angle: float = 360.0, name: str = 'Revolution') -> GeoPrism:
         """Applies a revolution to the XYPolygon along the provided rotation ais
 
         Args:
@@ -496,7 +440,7 @@ class XYPolygon:
         
         tags = [t for d,t in volume if d==3]
         poly_fin.remove()
-        return GeoPrism(tags, _axis=axis)
+        return GeoPrism(tags, _axis=axis, name=name)
 
     @staticmethod
     def circle(radius: float, 
@@ -588,7 +532,7 @@ class XYPolygon:
         self.extend(xs, ys)
         return self
     
-    def connect(self, other: XYPolygon) -> GeoVolume:
+    def connect(self, other: XYPolygon, name: str = 'Connection') -> GeoVolume:
         """Connect two XYPolygons with a defined coordinate system
 
         The coordinate system must be defined before this function can be used. To add a coordinate systme without
@@ -610,17 +554,19 @@ class XYPolygon:
         o1 = np.array(self._cs.in_global_cs(*self.center, 0)).flatten()
         o2 = np.array(other._cs.in_global_cs(*other.center, 0)).flatten()
         dts = gmsh.model.occ.addThruSections([w1, w2], True, parametrization="IsoParametric")
-        vol = GeoVolume([t for d,t in dts if d==3])
+        vol = GeoVolume([t for d,t in dts if d==3], name=name)
         
         vol._add_face_pointer('front',o1, self._cs.zax.np)
         vol._add_face_pointer('back', o2, other._cs.zax.np)
         return vol
             
 class Disc(GeoSurface):
+    _default_name: str = 'Disc'
     
     def __init__(self, origin: tuple[float, float, float],
                  radius: float,
-                 axis: tuple[float, float, float] = (0,0,1.0)):
+                 axis: tuple[float, float, float] = (0,0,1.0),
+                 name: str | None = None):
         """Creates a circular Disc surface.
 
         Args:
@@ -629,10 +575,12 @@ class Disc(GeoSurface):
             axis (tuple[float, float, float], optional): The disc normal axis. Defaults to (0,0,1.0).
         """
         disc = gmsh.model.occ.addDisk(*origin, radius, radius, zAxis=axis)
-        super().__init__(disc)
+        super().__init__(disc, name=name)
     
     
 class Curve(GeoEdge):
+    _default_name: str = 'Curve'
+    
     def __init__(self, 
                  xpts: np.ndarray, 
                  ypts: np.ndarray, 
@@ -640,7 +588,8 @@ class Curve(GeoEdge):
                  degree: int = 3,
                  weights: list[float] | None = None,
                  knots: list[float] | None = None,
-                 ctype: Literal['Spline','BSpline','Bezier'] = 'Spline'):
+                 ctype: Literal['Spline','BSpline','Bezier'] = 'Spline',
+                 name: str | None = None):
         """Generate a Spline/Bspline or Bezier curve based on a series of points
 
         This calls the different curve features in OpenCASCADE.
@@ -678,7 +627,7 @@ class Curve(GeoEdge):
         
         tags = gmsh.model.occ.addWire([tags,])
         gmsh.model.occ.remove([(0,tag) for tag in points])
-        super().__init__(tags)
+        super().__init__(tags, name=name)
     
         gmsh.model.occ.synchronize()
         p1 = gmsh.model.getValue(self.dim, self.tags[0], [0,])