README.md

@@ -172,7 +172,6 @@ my_pattern.place(abstract, ...)
 
 # or
 my_pattern.place(library << make_tree(...), ...)
-```
 
 
 ### Quickly add geometry, labels, or refs:
@@ -234,3 +233,5 @@ my_pattern.ref(_make_my_subpattern(), offset=..., ...)
 * Tests tests tests
 * check renderpather
 * pather and renderpather examples
+* context manager for retool
+* allow a specific mismatch when connecting ports

examples/tutorial/pather.py

@@ -265,12 +265,6 @@ def main() -> None:
     # when using pather.retool().
     pather.path_to('VCC', None, -50_000, out_ptype='m1wire')
 
-    # Now extend GND out to x=-50_000, using M2 for a portion of the path.
-    # We can use `pather.toolctx()` to temporarily retool, instead of calling `retool()` twice.
-    with pather.toolctx(M2_tool, keys=['GND']):
-        pather.path_to('GND', None, -40_000)
-    pather.path_to('GND', None, -50_000)
-
     # Save the pather's pattern into our library
     library['Pather_and_BasicTool'] = pather.pattern
 

masque/__init__.py

@@ -83,12 +83,10 @@ from .builder import (
 from .utils import (
     ports2data as ports2data,
     oneshot as oneshot,
-    R90 as R90,
-    R180 as R180,
     )
 
 
 __author__ = 'Jan Petykiewicz'
 
-__version__ = '3.3'
+__version__ = '3.2'
 version = __version__       # legacy

masque/builder/builder.py

@@ -2,7 +2,7 @@
 Simplified Pattern assembly (`Builder`)
 """
 from typing import Self
-from collections.abc import Iterable, Sequence, Mapping
+from collections.abc import Sequence, Mapping
 import copy
 import logging
 from functools import wraps
@@ -226,7 +226,6 @@ class Builder(PortList):
             inherit_name: bool = True,
             set_rotation: bool | None = None,
             append: bool = False,
-            ok_connections: Iterable[tuple[str, str]] = (),
             ) -> Self:
         """
         Wrapper around `Pattern.plug` which allows a string for `other`.
@@ -261,11 +260,6 @@ class Builder(PortList):
             append: If `True`, `other` is appended instead of being referenced.
                 Note that this does not flatten  `other`, so its refs will still
                 be refs (now inside `self`).
-            ok_connections: Set of "allowed" ptype combinations. Identical
-                ptypes are always allowed to connect, as is `'unk'` with
-                any other ptypte. Non-allowed ptype connections will emit a
-                warning. Order is ignored, i.e. `(a, b)` is equivalent to
-                `(b, a)`.
 
         Returns:
             self
@@ -299,7 +293,6 @@ class Builder(PortList):
             inherit_name=inherit_name,
             set_rotation=set_rotation,
             append=append,
-            ok_connections=ok_connections,
             )
         return self
 

masque/builder/pather.py

@@ -2,10 +2,9 @@
 Manual wire/waveguide routing (`Pather`)
 """
 from typing import Self
-from collections.abc import Sequence, MutableMapping, Mapping, Iterator
+from collections.abc import Sequence, MutableMapping, Mapping
 import copy
 import logging
-from contextlib import contextmanager
 from pprint import pformat
 
 import numpy
@@ -282,37 +281,6 @@ class Pather(Builder):
                 self.tools[key] = tool
         return self
 
-    @contextmanager
-    def toolctx(
-            self,
-            tool: Tool,
-            keys: str | Sequence[str | None] | None = None,
-            ) -> Iterator[Self]:
-        """
-          Context manager for temporarily `retool`-ing and reverting the `retool`
-        upon exiting the context.
-
-        Args:
-            tool: The new `Tool` to use for the given ports.
-            keys: Which ports the tool should apply to. `None` indicates the default tool,
-                used when there is no matching entry in `self.tools` for the port in question.
-
-        Returns:
-            self
-        """
-        if keys is None or isinstance(keys, str):
-            keys = [keys]
-        saved_tools = {kk: self.tools.get(kk, None) for kk in keys}      # If not in self.tools, save `None`
-        try:
-            yield self.retool(tool=tool, keys=keys)
-        finally:
-            for kk, tt in saved_tools.items():
-                if tt is None:
-                    # delete if present
-                    self.tools.pop(kk, None)
-                else:
-                    self.tools[kk] = tt
-
     def path(
             self,
             portspec: str,

masque/builder/utils.py

@@ -21,7 +21,7 @@ def ell(
         *,
         spacing: float | ArrayLike | None = None,
         set_rotation: float | None = None,
-        ) -> dict[str, numpy.float64]:
+        ) -> dict[str, float]:
     """
     Calculate extension for each port in order to build a 90-degree bend with the provided
     channel spacing:

masque/library.py

@@ -542,7 +542,7 @@ class ILibraryView(Mapping[str, 'Pattern'], metaclass=ABCMeta):
         Return:
             Topologically sorted list of pattern names.
         """
-        return cast(list[str], list(TopologicalSorter(self.child_graph()).static_order()))
+        return list(TopologicalSorter(self.child_graph()).static_order())
 
     def find_refs_local(
             self,
@@ -1068,22 +1068,20 @@ class ILibrary(ILibraryView, MutableMapping[str, 'Pattern'], metaclass=ABCMeta):
         Returns:
             A set containing the names of all deleted patterns
         """
-        parent_graph = self.parent_graph()
-        empty = {name for name, pat in self.items() if pat.is_empty()}
         trimmed = set()
-        while empty:
-            parents = set()
+        while empty := {name for name, pat in self.items() if pat.is_empty()}:
             for name in empty:
                 del self[name]
-                for parent in parent_graph[name]:
-                    del self[parent].refs[name]
-                parents |= parent_graph[name]
+
+            for pat in self.values():
+                for name in empty:
+                    # Second pass to skip looking at refs in empty patterns
+                    if name in pat.refs:
+                        del pat.refs[name]
 
             trimmed |= empty
             if not repeat:
                 break
-
-            empty = {parent for parent in parents if self[parent].is_empty()}
         return trimmed
 
     def delete(

masque/pattern.py

@@ -1225,7 +1225,6 @@ class Pattern(PortList, AnnotatableImpl, Mirrorable):
             inherit_name: bool = True,
             set_rotation: bool | None = None,
             append: bool = False,
-            ok_connections: Iterable[tuple[str, str]] = (),
             ) -> Self:
         """
         Instantiate or append a pattern into the current pattern, connecting
@@ -1271,11 +1270,6 @@ class Pattern(PortList, AnnotatableImpl, Mirrorable):
             append: If `True`, `other` is appended instead of being referenced.
                 Note that this does not flatten  `other`, so its refs will still
                 be refs (now inside `self`).
-            ok_connections: Set of "allowed" ptype combinations. Identical
-                ptypes are always allowed to connect, as is `'unk'` with
-                any other ptypte. Non-allowed ptype connections will emit a
-                warning. Order is ignored, i.e. `(a, b)` is equivalent to
-                `(b, a)`.
 
         Returns:
             self
@@ -1306,7 +1300,6 @@ class Pattern(PortList, AnnotatableImpl, Mirrorable):
             map_in,
             mirrored=mirrored,
             set_rotation=set_rotation,
-            ok_connections=ok_connections,
             )
 
         # get rid of plugged ports

masque/ports.py

@@ -419,7 +419,6 @@ class PortList(metaclass=ABCMeta):
             *,
             mirrored: bool = False,
             set_rotation: bool | None = None,
-            ok_connections: Iterable[tuple[str, str]] = (),
             ) -> tuple[NDArray[numpy.float64], float, NDArray[numpy.float64]]:
         """
         Given a device `other` and a mapping `map_in` specifying port connections,
@@ -436,11 +435,6 @@ class PortList(metaclass=ABCMeta):
                 port with `rotation=None`), `set_rotation` must be provided
                 to indicate how much `other` should be rotated. Otherwise,
                 `set_rotation` must remain `None`.
-            ok_connections: Set of "allowed" ptype combinations. Identical
-                ptypes are always allowed to connect, as is `'unk'` with
-                any other ptypte. Non-allowed ptype connections will emit a
-                warning. Order is ignored, i.e. `(a, b)` is equivalent to
-                `(b, a)`.
 
         Returns:
             - The (x, y) translation (performed last)
@@ -457,7 +451,6 @@ class PortList(metaclass=ABCMeta):
             map_in=map_in,
             mirrored=mirrored,
             set_rotation=set_rotation,
-            ok_connections=ok_connections,
             )
 
     @staticmethod
@@ -468,14 +461,13 @@ class PortList(metaclass=ABCMeta):
             *,
             mirrored: bool = False,
             set_rotation: bool | None = None,
-            ok_connections: Iterable[tuple[str, str]] = (),
             ) -> tuple[NDArray[numpy.float64], float, NDArray[numpy.float64]]:
         """
         Given two sets of ports (s_ports and o_ports) and a mapping `map_in`
           specifying port connections, find the transform which will correctly
           align the specified o_ports onto their respective s_ports.
 
-        Args:
+        Args:t
             s_ports: A list of stationary ports
             o_ports: A list of ports which are to be moved/mirrored.
             map_in: dict of `{'s_port': 'o_port'}` mappings, specifying
@@ -487,11 +479,6 @@ class PortList(metaclass=ABCMeta):
                 port with `rotation=None`), `set_rotation` must be provided
                 to indicate how much `o_ports` should be rotated. Otherwise,
                 `set_rotation` must remain `None`.
-            ok_connections: Set of "allowed" ptype combinations. Identical
-                ptypes are always allowed to connect, as is `'unk'` with
-                any other ptypte. Non-allowed ptype connections will emit a
-                warning. Order is ignored, i.e. `(a, b)` is equivalent to
-                `(b, a)`.
 
         Returns:
             - The (x, y) translation (performed last)
@@ -515,8 +502,7 @@ class PortList(metaclass=ABCMeta):
             o_offsets[:, 1] *= -1
             o_rotations *= -1
 
-        ok_pairs = {tuple(sorted(pair)) for pair in ok_connections if pair[0] != pair[1]}
-        type_conflicts = numpy.array([(st != ot) and ('unk' not in (st, ot)) and (tuple(sorted((st, ot))) not in ok_pairs)
+        type_conflicts = numpy.array([st != ot and 'unk' not in (st, ot)
                                       for st, ot in zip(s_types, o_types, strict=True)])
         if type_conflicts.any():
             msg = 'Ports have conflicting types:\n'
@@ -537,8 +523,8 @@ class PortList(metaclass=ABCMeta):
         if not numpy.allclose(rotations[:1], rotations):
             rot_deg = numpy.rad2deg(rotations)
             msg = 'Port orientations do not match:\n'
-            for nn, (kk, vv) in enumerate(map_in.items()):
-                msg += f'{kk} | {rot_deg[nn]:g} | {vv}\n'
+            for nn, (k, v) in enumerate(map_in.items()):
+                msg += f'{k} | {rot_deg[nn]:g} | {v}\n'
             raise PortError(msg)
 
         pivot = o_offsets[0].copy()
@@ -546,8 +532,8 @@ class PortList(metaclass=ABCMeta):
         translations = s_offsets - o_offsets
         if not numpy.allclose(translations[:1], translations):
             msg = 'Port translations do not match:\n'
-            for nn, (kk, vv) in enumerate(map_in.items()):
-                msg += f'{kk} | {translations[nn]} | {vv}\n'
+            for nn, (k, v) in enumerate(map_in.items()):
+                msg += f'{k} | {translations[nn]} | {v}\n'
             raise PortError(msg)
 
         return translations[0], rotations[0], o_offsets[0]

masque/shapes/arc.py

@@ -233,7 +233,7 @@ class Arc(Shape):
         r0, r1 = self.radii
 
         # Convert from polar angle to ellipse parameter (for [rx*cos(t), ry*sin(t)] representation)
-        a_ranges = cast(_array2x2_t, self._angles_to_parameters())
+        a_ranges = self._angles_to_parameters()
 
         # Approximate perimeter via numerical integration
 
@@ -244,31 +244,30 @@ class Arc(Shape):
         #t0 = ellipeinc(a0 - pi / 2, m)
         #perimeter2 = r0 * (t1 - t0)
 
-        def get_arclens(n_pts: int, a0: float, a1: float, dr: float) -> tuple[NDArray[numpy.float64], NDArray[numpy.float64]]:
+        def get_arclens(n_pts: int, a0: float, a1: float) -> tuple[NDArray[numpy.float64], NDArray[numpy.float64]]:
             """ Get `n_pts` arclengths """
-            tt, dt = numpy.linspace(a0, a1, n_pts, retstep=True)  # NOTE: could probably use an adaptive number of points
-            r0sin = (r0 + dr) * numpy.sin(tt)
-            r1cos = (r1 + dr) * numpy.cos(tt)
+            t, dt = numpy.linspace(a0, a1, n_pts, retstep=True)  # NOTE: could probably use an adaptive number of points
+            r0sin = r0 * numpy.sin(t)
+            r1cos = r1 * numpy.cos(t)
             arc_dl = numpy.sqrt(r0sin * r0sin + r1cos * r1cos)
-            #arc_lengths = numpy.diff(tt) * (arc_dl[1:] + arc_dl[:-1]) / 2
+            #arc_lengths = numpy.diff(t) * (arc_dl[1:] + arc_dl[:-1]) / 2
             arc_lengths = (arc_dl[1:] + arc_dl[:-1]) * numpy.abs(dt) / 2
-            return arc_lengths, tt
+            return arc_lengths, t
 
-        wh = self.width / 2.0
         if num_vertices is not None:
-            n_pts = numpy.ceil(max(self.radii + wh) / min(self.radii) * num_vertices * 100).astype(int)
-            perimeter_inner = get_arclens(n_pts, *a_ranges[0], dr=-wh)[0].sum()
-            perimeter_outer = get_arclens(n_pts, *a_ranges[1], dr= wh)[0].sum()
+            n_pts = numpy.ceil(max(self.radii) / min(self.radii) * num_vertices * 100).astype(int)
+            perimeter_inner = get_arclens(n_pts, *a_ranges[0])[0].sum()
+            perimeter_outer = get_arclens(n_pts, *a_ranges[1])[0].sum()
             implied_arclen = (perimeter_outer + perimeter_inner + self.width * 2) / num_vertices
             max_arclen = min(implied_arclen, max_arclen if max_arclen is not None else numpy.inf)
         assert max_arclen is not None
 
         def get_thetas(inner: bool) -> NDArray[numpy.float64]:
             """ Figure out the parameter values at which we should place vertices to meet the arclength constraint"""
-            dr = -wh if inner else wh
+            #dr = -self.width / 2.0 * (-1 if inner else 1)
 
-            n_pts = numpy.ceil(2 * pi * max(self.radii + dr) / max_arclen).astype(int)
-            arc_lengths, thetas = get_arclens(n_pts, *a_ranges[0 if inner else 1], dr=dr)
+            n_pts = numpy.ceil(2 * pi * max(self.radii) / max_arclen).astype(int)
+            arc_lengths, thetas = get_arclens(n_pts, *a_ranges[0 if inner else 1])
 
             keep = [0]
             removable = (numpy.cumsum(arc_lengths) <= max_arclen)
@@ -286,7 +285,7 @@ class Arc(Shape):
                 thetas = thetas[::-1]
             return thetas
 
-        thetas_inner: NDArray[numpy.float64]
+        wh = self.width / 2.0
         if wh in (r0, r1):
             thetas_inner = numpy.zeros(1)      # Don't generate multiple vertices if we're at the origin
         else:
@@ -321,11 +320,11 @@ class Arc(Shape):
 
         If the extrema are innaccessible due to arc constraints, check the arc endpoints instead.
         """
-        a_ranges = cast(_array2x2_t, self._angles_to_parameters())
+        a_ranges = self._angles_to_parameters()
 
         mins = []
         maxs = []
-        for aa, sgn in zip(a_ranges, (-1, +1), strict=True):
+        for a, sgn in zip(a_ranges, (-1, +1), strict=True):
             wh = sgn * self.width / 2
             rx = self.radius_x + wh
             ry = self.radius_y + wh
@@ -336,13 +335,13 @@ class Arc(Shape):
                 maxs.append([0, 0])
                 continue
 
-            a0, a1 = aa
+            a0, a1 = a
             a0_offset = a0 - (a0 % (2 * pi))
 
             sin_r = numpy.sin(self.rotation)
             cos_r = numpy.cos(self.rotation)
-            sin_a = numpy.sin(aa)
-            cos_a = numpy.cos(aa)
+            sin_a = numpy.sin(a)
+            cos_a = numpy.cos(a)
 
             # Cutoff angles
             xpt = (-self.rotation) % (2 * pi) + a0_offset
@@ -432,19 +431,19 @@ class Arc(Shape):
              [[x2, y2], [x3, y3]]],    would create this arc from its corresponding ellipse.
             ```
         """
-        a_ranges = cast(_array2x2_t, self._angles_to_parameters())
+        a_ranges = self._angles_to_parameters()
 
         mins = []
         maxs = []
-        for aa, sgn in zip(a_ranges, (-1, +1), strict=True):
+        for a, sgn in zip(a_ranges, (-1, +1), strict=True):
             wh = sgn * self.width / 2
             rx = self.radius_x + wh
             ry = self.radius_y + wh
 
             sin_r = numpy.sin(self.rotation)
             cos_r = numpy.cos(self.rotation)
-            sin_a = numpy.sin(aa)
-            cos_a = numpy.cos(aa)
+            sin_a = numpy.sin(a)
+            cos_a = numpy.cos(a)
 
             # arc endpoints
             xn, xp = sorted(rx * cos_r * cos_a - ry * sin_r * sin_a)
@@ -456,29 +455,26 @@ class Arc(Shape):
 
     def _angles_to_parameters(self) -> NDArray[numpy.float64]:
         """
-        Convert from polar angle to ellipse parameter (for [rx*cos(t), ry*sin(t)] representation)
-
         Returns:
             "Eccentric anomaly" parameter ranges for the inner and outer edges, in the form
                    `[[a_min_inner, a_max_inner], [a_min_outer, a_max_outer]]`
         """
-        aa = []
+        a = []
         for sgn in (-1, +1):
-            wh = sgn * self.width / 2.0
+            wh = sgn * self.width / 2
             rx = self.radius_x + wh
             ry = self.radius_y + wh
 
-            a0, a1 = (numpy.arctan2(rx * numpy.sin(ai), ry * numpy.cos(ai)) for ai in self.angles)
+            # create paremeter 'a' for parametrized ellipse
+            a0, a1 = (numpy.arctan2(rx * numpy.sin(a), ry * numpy.cos(a)) for a in self.angles)
             sign = numpy.sign(self.angles[1] - self.angles[0])
             if sign != numpy.sign(a1 - a0):
                 a1 += sign * 2 * pi
 
-            aa.append((a0, a1))
-        return numpy.array(aa, dtype=float)
+            a.append((a0, a1))
+        return numpy.array(a, dtype=float)
 
     def __repr__(self) -> str:
         angles = f' a°{numpy.rad2deg(self.angles)}'
         rotation = f' r°{numpy.rad2deg(self.rotation):g}' if self.rotation != 0 else ''
         return f'<Arc o{self.offset} r{self.radii}{angles} w{self.width:g}{rotation}>'
-
-_array2x2_t = tuple[tuple[float, float], tuple[float, float]]

masque/shapes/path.py

@@ -271,7 +271,7 @@ class Path(Shape):
         # TODO: Path.travel() needs testing
         direction = numpy.array([1, 0])
 
-        verts: list[NDArray[numpy.float64]] = [numpy.zeros(2)]
+        verts = [numpy.zeros(2)]
         for angle, distance in travel_pairs:
             direction = numpy.dot(rotation_matrix_2d(angle), direction.T).T
             verts.append(verts[-1] + direction * distance)
@@ -307,8 +307,8 @@ class Path(Shape):
         bs = v[1:-1] - v[:-2] + perp[1:] - perp[:-1]
         ds = v[1:-1] - v[:-2] - perp[1:] + perp[:-1]
 
-        rp = numpy.linalg.solve(As, bs[:, :, None])[:, 0]
-        rn = numpy.linalg.solve(As, ds[:, :, None])[:, 0]
+        rp = numpy.linalg.solve(As, bs)[:, 0, None]
+        rn = numpy.linalg.solve(As, ds)[:, 0, None]
 
         intersection_p = v[:-2] + rp * dv[:-1] + perp[:-1]
         intersection_n = v[:-2] + rn * dv[:-1] - perp[:-1]

masque/shapes/polygon.py

@@ -20,7 +20,7 @@ class Polygon(Shape):
     A polygon, consisting of a bunch of vertices (Nx2 ndarray) which specify an
        implicitly-closed boundary, and an offset.
 
-    Note that the setter for `Polygon.vertices` creates a copy of the
+    Note that the setter for `Polygon.vertices` may creates a copy of the
       passed vertex coordinates.
 
     A `normalized_form(...)` is available, but can be quite slow with lots of vertices.
@@ -379,9 +379,8 @@ class Polygon(Shape):
     def normalized_form(self, norm_value: float) -> normalized_shape_tuple:
         # Note: this function is going to be pretty slow for many-vertexed polygons, relative to
         #   other shapes
-        meanv = self.vertices.mean(axis=0)
-        zeroed_vertices = self.vertices - meanv
-        offset = meanv + self.offset
+        offset = self.vertices.mean(axis=0) + self.offset
+        zeroed_vertices = self.vertices - offset
 
         scale = zeroed_vertices.std()
         normed_vertices = zeroed_vertices / scale

masque/utils/__init__.py

@@ -25,8 +25,6 @@ from .transform import (
     normalize_mirror as normalize_mirror,
     rotate_offsets_around as rotate_offsets_around,
     apply_transforms as apply_transforms,
-    R90 as R90,
-    R180 as R180,
     )
 from .comparisons import (
     annotation2key as annotation2key,

masque/utils/curves.py

@@ -1,104 +0,0 @@
-import numpy
-from numpy.typing import ArrayLike, NDArray
-from numpy import pi
-
-try:
-    from numpy import trapezoid
-except ImportError:
-    from numpy import trapz as trapezoid
-
-
-def bezier(
-        nodes: ArrayLike,
-        tt: ArrayLike,
-        weights: ArrayLike | None = None,
-        ) -> NDArray[numpy.float64]:
-    """
-    Sample a Bezier curve with the provided control points at the parametrized positions `tt`.
-
-    Using the calculation method from arXiv:1803.06843, Chudy and Woźny.
-
-    Args:
-        nodes: `[[x0, y0], ...]` control points for the Bezier curve
-        tt: Parametrized positions at which to sample the curve (1D array with values in the interval [0, 1])
-        weights: Control point weights; if provided, length should be the same as number of control points.
-            Default 1 for all control points.
-
-    Returns:
-        `[[x0, y0], [x1, y1], ...]` corresponding to `[tt0, tt1, ...]`
-    """
-    nodes = numpy.asarray(nodes)
-    tt = numpy.asarray(tt)
-    nn = nodes.shape[0]
-    weights = numpy.ones(nn) if weights is None else numpy.asarray(weights)
-
-    with numpy.errstate(divide='ignore'):
-        umul = (tt / (1 - tt)).clip(max=1)
-        udiv = ((1 - tt) / tt).clip(max=1)
-
-    hh = numpy.ones((tt.size,))
-    qq = nodes[None, 0, :] * hh[:, None]
-    for kk in range(1, nn):
-        hh *= umul * (nn - kk) * weights[kk]
-        hh /= kk * udiv * weights[kk - 1] + hh
-        qq *= 1.0 - hh[:, None]
-        qq += hh[:, None] * nodes[None, kk, :]
-    return qq
-
-
-
-def euler_bend(
-        switchover_angle: float,
-        num_points: int = 200,
-        ) -> NDArray[numpy.float64]:
-    """
-    Generate a 90 degree Euler bend (AKA Clothoid bend or Cornu spiral).
-
-    Args:
-        switchover_angle: After this angle, the bend will transition into a circular arc
-            (and transition back to an Euler spiral on the far side). If this is set to
-            `>= pi / 4`, no circular arc will be added.
-        num_points: Number of points in the curve
-
-    Returns:
-        `[[x0, y0], ...]` for the curve
-    """
-    ll_max = numpy.sqrt(2 * switchover_angle)        # total length of (one) spiral portion
-    ll_tot = 2 * ll_max + (pi / 2 - 2 * switchover_angle)
-    num_points_spiral = numpy.floor(ll_max / ll_tot * num_points).astype(int)
-    num_points_arc = num_points - 2 * num_points_spiral
-
-    def gen_spiral(ll_max: float) -> NDArray[numpy.float64]:
-        xx = []
-        yy = []
-        for ll in numpy.linspace(0, ll_max, num_points_spiral):
-            qq = numpy.linspace(0, ll, 1000)        # integrate to current arclength
-            xx.append(trapezoid( numpy.cos(qq * qq / 2), qq))
-            yy.append(trapezoid(-numpy.sin(qq * qq / 2), qq))
-        xy_part = numpy.stack((xx, yy), axis=1)
-        return xy_part
-
-    xy_spiral = gen_spiral(ll_max)
-    xy_parts = [xy_spiral]
-
-    if switchover_angle < pi / 4:
-        # Build a circular segment to join the two euler portions
-        rmin = 1.0 / ll_max
-        half_angle = pi / 4 - switchover_angle
-        qq = numpy.linspace(half_angle * 2, 0, num_points_arc + 1) + switchover_angle
-        xc = rmin * numpy.cos(qq)
-        yc = rmin * numpy.sin(qq) + xy_spiral[-1, 1]
-        xc += xy_spiral[-1, 0] - xc[0]
-        yc += xy_spiral[-1, 1] - yc[0]
-        xy_parts.append(numpy.stack((xc[1:], yc[1:]), axis=1))
-
-    endpoint_xy = xy_parts[-1][-1, :]
-    second_spiral = xy_spiral[::-1, ::-1] + endpoint_xy - xy_spiral[-1, ::-1]
-
-    xy_parts.append(second_spiral)
-    xy = numpy.concatenate(xy_parts)
-
-    # Remove any 2x-duplicate points
-    xy = xy[(numpy.roll(xy, 1, axis=0) != xy).any(axis=1)]
-
-    return xy

masque/utils/transform.py

@@ -9,11 +9,6 @@ from numpy.typing import NDArray, ArrayLike
 from numpy import pi
 
 
-# Constants for shorthand rotations
-R90 = pi / 2
-R180 = pi
-
-
 @lru_cache
 def rotation_matrix_2d(theta: float) -> NDArray[numpy.float64]:
     """