pywarper 0.1.0__py3-none-any.whl

pywarper/arbor.py

@@ -0,0 +1,282 @@
+import time
+
+import numpy as np
+from numpy.linalg import lstsq
+
+
+def local_ls_registration(
+    nodes: np.ndarray,
+    top_input_pos: np.ndarray,
+    bot_input_pos: np.ndarray,
+    top_output_pos: np.ndarray,
+    bot_output_pos: np.ndarray,
+    window: float = 5.0,
+    max_order: int = 2
+) -> np.ndarray:
+    """
+    Applies a local least-squares polynomial transformation to each node based on nearby
+    surface correspondences from the top and bottom “bands” (layers).
+
+    Parameters
+    ----------
+    nodes : np.ndarray
+        (N, 3) array of [x, y, z] positions to be transformed.
+    top_input_pos : np.ndarray
+        (M, 3) array of [x, y, z] coordinates for the top band (original space).
+    bot_input_pos : np.ndarray
+        (M, 3) array of [x, y, z] coordinates for the bottom band (original space).
+    top_output_pos : np.ndarray
+        (M, 3) array of mapped [x, y, z] coordinates for the top band (flattened space).
+    bot_output_pos : np.ndarray
+        (M, 3) array of mapped [x, y, z] coordinates for the bottom band (flattened space).
+    window : float, default=5.0
+        Neighborhood radius (in pixels/units) for local polynomial fitting.
+    max_order : int, default=2
+        Maximum total polynomial order for the local transformation model.
+        For example, 2 indicates quadratic terms.
+
+    Returns
+    -------
+    np.ndarray
+        (N, 3) array of transformed [x, y, z] positions, the result of applying
+        the local least-squares fits to each node.
+
+    Notes
+    -----
+    The function constructs a polynomial basis (constant, linear, up to max_order
+    in both x and y), plus terms modulated by z. A least-squares system is solved
+    locally for each node, using points in the top and bottom surfaces within
+    the specified window. If insufficient points are found, the node remains
+    unchanged.
+    """
+    transformed_nodes = np.zeros_like(nodes)
+    
+    # Combine top/bottom input positions with outputs once
+    top_in_xy = top_input_pos[:, :2]
+    bot_in_xy = bot_input_pos[:, :2]
+
+    for k, (x, y, z) in enumerate(nodes):
+        lx, ux = x - window, x + window
+        ly, uy = y - window, y + window
+
+        # Find indices once (reuse masks)
+        top_mask = ((top_in_xy[:, 0] >= lx) & (top_in_xy[:, 0] <= ux) &
+                    (top_in_xy[:, 1] >= ly) & (top_in_xy[:, 1] <= uy))
+        bot_mask = ((bot_in_xy[:, 0] >= lx) & (bot_in_xy[:, 0] <= ux) &
+                    (bot_in_xy[:, 1] >= ly) & (bot_in_xy[:, 1] <= uy))
+
+        in_top, out_top = top_input_pos[top_mask], top_output_pos[top_mask]
+        in_bot, out_bot = bot_input_pos[bot_mask], bot_output_pos[bot_mask]
+
+        this_in = np.vstack([in_top, in_bot])
+        this_out = np.vstack([out_top, out_bot])
+
+        if len(this_in) < 12:
+            transformed_nodes[k] = nodes[k]
+            continue
+
+        # Center coordinates (in-place avoided)
+        x_shift, y_shift = np.mean(this_in[:, :2], axis=0)
+        this_in_centered = this_in.copy()
+        this_out_centered = this_out.copy()
+
+        this_in_centered[:, 0] -= x_shift
+        this_out_centered[:, 0] -= x_shift
+        this_in_centered[:, 1] -= y_shift
+        this_out_centered[:, 1] -= y_shift
+
+        # Efficient polynomial basis creation
+        xin, yin, zin = this_in_centered.T
+        basis_cols = []
+
+        # Constant term
+        basis_cols.append(np.ones_like(xin))
+
+        # Linear terms
+        basis_cols.extend([xin, yin])
+
+        # Higher-order terms
+        for order in range(2, max_order + 1):
+            for ox in range(order + 1):
+                oy = order - ox
+                basis_cols.append((xin ** ox) * (yin ** oy))
+
+        # Stack basis columns once
+        base_terms = np.vstack(basis_cols).T  # shape: (n_points, n_terms)
+
+        # Z-modulated terms
+        z_modulated = base_terms * zin[:, np.newaxis]
+
+        # Combined X matrix
+        X = np.hstack([base_terms, z_modulated])
+
+        # Solve linear system efficiently
+        T, _, _, _ = lstsq(X, this_out_centered, rcond=None)
+
+        # Build basis for current node (single-step, no insertions)
+        node_xy = np.array([x - x_shift, y - y_shift])
+        nx, ny = node_xy
+        basis_eval = [1.0, nx, ny]
+
+        for order in range(2, max_order + 1):
+            for ox in range(order + 1):
+                oy = order - ox
+                basis_eval.append((nx ** ox) * (ny ** oy))
+
+        basis_eval = np.array(basis_eval)
+        z_modulated_eval = z * basis_eval
+
+        final_input = np.concatenate([basis_eval, z_modulated_eval])
+        new_pos = final_input @ T
+
+        new_pos[0] += x_shift
+        new_pos[1] += y_shift
+        transformed_nodes[k] = new_pos
+
+    return transformed_nodes
+
+def warp_arbor(
+    nodes: np.ndarray,
+    edges: np.ndarray,
+    radii: np.ndarray,
+    surface_mapping: dict,
+    conformal_jump: int = 1,
+    verbose: bool = False
+) -> dict:
+    """
+    Applies a local surface flattening (warp) to a neuronal arbor using the results
+    of previously computed surface mappings.
+
+    Parameters
+    ----------
+    nodes : np.ndarray
+        (N, 3) array of [x, y, z] coordinates for the arbor to be warped.
+    edges : np.ndarray
+        (E, 2) array of indices defining connectivity between nodes.
+    radii : np.ndarray
+        (N,) array of radii corresponding to each node.
+    surface_mapping : dict
+        Dictionary containing keys:
+          - "mapped_min_positions" : np.ndarray
+              (X*Y, 2) mapped coordinates for one surface band (e.g., "min" band).
+          - "mapped_max_positions" : np.ndarray
+              (X*Y, 2) mapped coordinates for the other surface band (e.g., "max" band).
+          - "thisVZminmesh" : np.ndarray
+              (X, Y) mesh representing the first surface (“min” band) in 3D space.
+          - "thisVZmaxmesh" : np.ndarray
+              (X, Y) mesh representing the second surface (“max” band) in 3D space.
+          - "thisx" : np.ndarray
+              1D array of x-indices (possibly downsampled) used during mapping.
+          - "thisy" : np.ndarray
+              1D array of y-indices (possibly downsampled) used during mapping.
+    conformal_jump : int, default=1
+        Step size used in the conformal mapping (downsampling factor).
+    verbose : bool, default=False
+        If True, prints timing and progress information.
+
+    Returns
+    -------
+    dict
+        Dictionary containing:
+          - "nodes": np.ndarray
+              (N, 3) warped [x, y, z] coordinates after applying local registration.
+          - "edges": np.ndarray
+              (E, 2) connectivity array (passed through unchanged).
+          - "radii": np.ndarray
+              (N,) radii array (passed through unchanged).
+          - "medVZmin": float
+              Median z-value of the “min” surface mesh within the region of interest.
+          - "medVZmax": float
+              Median z-value of the “max” surface mesh within the region of interest.
+
+    Notes
+    -----
+    1. The function extracts a subregion of the surfaces according to thisx/thisy and
+       conformal_jump, matching the flattening step used in the mapping.
+    2. Each node in `nodes` is then warped via local least-squares registration
+       (`local_ls_registration`), referencing top (min) and bottom (max) surfaces.
+    3. The median z-values (medVZmin, medVZmax) are recorded, which often serve as
+       reference planes in further analyses.
+    """
+
+    # Unpack mappings and surfaces
+    mapped_min = surface_mapping["mapped_min_positions"]
+    mapped_max = surface_mapping["mapped_max_positions"]
+    VZmin = surface_mapping["thisVZminmesh"]
+    VZmax = surface_mapping["thisVZmaxmesh"]
+    thisx = surface_mapping["thisx"] + 1 
+    thisy = surface_mapping["thisy"] + 1 
+    # this is one ugly hack: thisx and thisy are 1-based in MATLAB
+    # but 0-based in Python; the rest of the code is to produce exact
+    # same results as MATLAB given the SAME input, that means thisx and 
+    # thisy needs to be 1-based, but we need to shift it back to 0-based 
+    # when slicing
+    
+    # Convert MATLAB 1-based inclusive ranges to Python slices
+    # If thisx/thisy are consecutive integer indices:
+    # x_vals = np.arange(thisx[0], thisx[-1] + 1)  # matches [thisx(1):thisx(end)] in MATLAB
+    # y_vals = np.arange(thisy[0], thisy[-1] + 1)  # matches [thisy(1):thisy(end)] in MATLAB
+    x_vals = np.arange(thisx[0], thisx[-1] + 1, conformal_jump)
+    y_vals = np.arange(thisy[0], thisy[-1] + 1, conformal_jump)
+
+    # Create a meshgrid shaped like MATLAB's [tmpymesh, tmpxmesh] = meshgrid(yRange, xRange).
+    # This means we want shape (len(x_vals), len(y_vals)) for each array, with row=“x”, col=“y”:
+    tmpxmesh, tmpymesh = np.meshgrid(x_vals, y_vals, indexing="ij")
+    # tmpxmesh.shape == tmpymesh.shape == (len(x_vals), len(y_vals))
+
+    # Extract the corresponding subregion of the surfaces so it also has shape (len(x_vals), len(y_vals)).
+    # In MATLAB: tmpminmesh = thisVZminmesh(xRange, yRange)
+    tmp_min = VZmin[x_vals[:, None]-1, y_vals-1]  # shape (len(x_vals), len(y_vals))
+    tmp_max = VZmax[x_vals[:, None]-1, y_vals-1]  # shape (len(x_vals), len(y_vals))
+
+    # Now flatten in column-major order (like MATLAB’s A(:)) to line up with tmpxmesh(:), etc.
+    top_input_pos = np.column_stack([
+        tmpxmesh.ravel(order="F"),
+        tmpymesh.ravel(order="F"),
+        tmp_min.ravel(order="F")
+    ])
+
+    bot_input_pos = np.column_stack([
+        tmpxmesh.ravel(order="F"),
+        tmpymesh.ravel(order="F"),
+        tmp_max.ravel(order="F")
+    ])
+
+    # Finally, the “mapped” output is unaffected by the flattening order mismatch,
+    # but we keep it consistent with MATLAB’s final step:
+    top_output_pos = np.column_stack([
+        mapped_min[:, 0],
+        mapped_min[:, 1],
+        np.median(tmp_min) * np.ones(mapped_min.shape[0])
+    ])
+
+    bot_output_pos = np.column_stack([
+        mapped_max[:, 0],
+        mapped_max[:, 1],
+        np.median(tmp_max) * np.ones(mapped_max.shape[0])
+    ])
+
+    # return top_input_pos, bot_input_pos, top_output_pos, bot_output_pos
+
+    # Apply local least-squares registration to each node
+    if verbose:
+        print("Warping nodes...")
+        start_time = time.time()
+    warped_nodes = local_ls_registration(nodes, top_input_pos, bot_input_pos, top_output_pos, bot_output_pos)
+    if verbose:
+        print(f"Nodes warped in {time.time() - start_time:.2f} seconds.")
+
+    # Compute median Z-planes
+    med_VZmin = np.median(tmp_min)
+    med_VZmax = np.median(tmp_max)
+
+    # Build output dictionary
+    warped_arbor = {
+        'nodes': warped_nodes,
+        'edges': edges,
+        'radii': radii,
+        'medVZmin': med_VZmin,
+        'medVZmax': med_VZmax,
+    }
+
+    return warped_arbor

pywarper/surface.py

@@ -0,0 +1,693 @@
+import time
+from typing import Optional
+
+import numpy as np
+from pygridfit import GridFit
+from scipy.interpolate import RegularGridInterpolator
+from scipy.signal import convolve2d
+from scipy.sparse import coo_matrix, hstack, vstack
+from scipy.sparse.linalg import spsolve
+
+try:
+    from sksparse.cholmod import cholesky
+    HAS_CHOLMOD = True
+except ImportError:
+    HAS_CHOLMOD = False
+    print("[Info] scikit-sparse not found. Falling back to scipy.sparse.linalg.spsolve.")
+
+
+def fit_surface(
+    x: np.ndarray,
+    y: np.ndarray,
+    z: np.ndarray,
+    xmax: Optional[int] = None,
+    ymax: Optional[int] = None,
+    smoothness: int = 1,
+    extend: str = "warning",
+    interp: str = "triangle",
+    regularizer: str = "gradient",
+    solver: str = "normal",
+    maxiter: Optional[int] = None,
+    autoscale: str = "on",
+    xscale: float = 1.0,
+    yscale: float = 1.0,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Fits a surface to scattered data points (x, y, z) using grid-based interpolation
+    and smoothing. Internally uses a GridFit-based approach to produce a 2D surface.
+
+    Parameters
+    ----------
+    x : np.ndarray
+        The x-coordinates of input data points.
+    y : np.ndarray
+        The y-coordinates of input data points.
+    z : np.ndarray
+        The z-values at each (x, y) coordinate.
+    xmax : int, optional
+        Maximum value along the x-axis used to define the interpolation grid.
+        If None, the max value from x is used.
+    ymax : int, optional
+        Maximum value along the y-axis used to define the interpolation grid.
+        If None, the max value from y is used.
+    smoothness : int, default=1
+        Amount of smoothing applied during fitting.
+    extend : str, default="warning"
+        Determines how to handle extrapolation outside data boundaries.
+        Possible values include "warning", "fill", etc. (see GridFit docs).
+    interp : str, default="triangle"
+        Type of interpolation to apply (e.g., "triangle", "bilinear").
+    regularizer : str, default="gradient"
+        Regularization method used in the solver (e.g., "gradient", "laplacian").
+    solver : str, default="normal"
+        Solver backend (e.g., "normal" for normal equations).
+    maxiter : int, optional
+        Maximum number of solver iterations. If None, defaults to solver-based value.
+    autoscale : str, default="on"
+        Autoscaling setting for the solver.
+    xscale : float, default=1.0
+        Additional scaling factor applied to the x-dimension during fitting.
+    yscale : float, default=1.0
+        Additional scaling factor applied to the y-dimension during fitting.
+
+    Returns
+    -------
+    zmesh : np.ndarray
+        2D array of interpolated z-values over the fitted surface.
+    xmesh : np.ndarray
+        2D array of x-coordinates corresponding to zmesh.
+    ymesh : np.ndarray
+        2D array of y-coordinates corresponding to zmesh.
+    """
+    if xmax is None:
+        xmax = np.max(x).astype(float)
+    if ymax is None:
+        ymax = np.max(y).astype(float)
+
+    xnodes = np.hstack([np.arange(1., xmax, 3), np.array([xmax])])
+    ynodes = np.hstack([np.arange(1., ymax, 3), np.array([ymax])])
+    # xnodes = np.arange(0, xmax+skip, skip)
+    # ynodes = np.arange(0, ymax+skip, skip)
+
+    gf = GridFit(x, y, z, xnodes, ynodes, 
+                    smoothness=smoothness,
+                    extend=extend,
+                    interp=interp,
+                    regularizer=regularizer,
+                    solver=solver,
+                    maxiter=maxiter,
+                    autoscale=autoscale,
+                    xscale=xscale,
+                    yscale=yscale,
+        ).fit()
+    zgrid = gf.zgrid
+
+    zmesh, xmesh, ymesh = resample_zgrid(
+        xnodes, ynodes, zgrid, xmax, ymax
+    )
+
+    return zmesh, xmesh, ymesh
+
+def resample_zgrid(
+    xnodes: np.ndarray,
+    ynodes: np.ndarray,
+    zgrid: np.ndarray,
+    xMax: int,
+    yMax: int
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Resamples a 2D grid (zgrid) at integer coordinates up to xMax and yMax.
+    Uses a linear RegularGridInterpolator under the hood.
+
+    Parameters
+    ----------
+    xnodes : np.ndarray
+        Sorted 1D array of x-coordinates defining the original grid.
+    ynodes : np.ndarray
+        Sorted 1D array of y-coordinates defining the original grid.
+    zgrid : np.ndarray
+        2D array of shape (len(ynodes), len(xnodes)), representing z-values
+        on a regular grid with axes (y, x).
+    xMax : int
+        The maximum x-coordinate (inclusive) for the resampling.
+    yMax : int
+        The maximum y-coordinate (inclusive) for the resampling.
+
+    Returns
+    -------
+    vzmesh : np.ndarray
+        2D array of shape (xMax, yMax), containing interpolated z-values at
+        integer (x, y) positions.
+    xi : np.ndarray
+        2D array of shape (xMax, yMax), representing the x-coordinates used for
+        interpolation.
+    yi : np.ndarray
+        2D array of shape (xMax, yMax), representing the y-coordinates used for
+        interpolation.
+
+    Notes
+    -----
+    In Python, arrays are typically indexed as (row, column) which maps to
+    (y, x) in a 2D sense. This function transposes the meshgrid from
+    `np.meshgrid(..., indexing='xy')` to match the MATLAB style of indexing.
+    """
+
+    # 0) Check that xMax, yMax are integers.
+    #    If not, round to nearest integer.
+    xMax = int(xMax)
+    yMax = int(yMax)
+
+    # 1) Build the interpolator, 
+    #    specifying x= xnodes (ascending), y= ynodes (ascending).
+    #    Note that in Python, the first axis in zgrid is y, second is x.
+    #    So pass (ynodes, xnodes) in that order:
+    rgi = RegularGridInterpolator(
+        (ynodes, xnodes),  # (y-axis, x-axis)
+        zgrid, 
+        method="linear", 
+        bounds_error=False, 
+        fill_value=np.nan  # or e.g. zgrid.mean()
+    )
+
+    # 2) Make xi, yi as in MATLAB, 
+    #    then do xi=xi', yi=yi' => shape (xMax, yMax).
+    xi_m, yi_m = np.meshgrid(
+        np.arange(1, xMax+1), 
+        np.arange(1, yMax+1), 
+        indexing='xy'
+    )
+    xi = xi_m.T  # shape (xMax, yMax)
+    yi = yi_m.T  # shape (xMax, yMax)
+
+    # 3) Flatten the coordinate arrays to shape (N, 2) for RGI.
+    XYi = np.column_stack((yi.ravel(), xi.ravel()))
+    # We must pass (y, x) in that order since RGI is (y-axis, x-axis).
+
+    # 4) Interpolate.
+    vmesh_flat = rgi(XYi)  # 1D array, length xMax*yMax
+
+    # 5) Reshape to (xMax, yMax).
+    vzmesh = vmesh_flat.reshape((xMax, yMax))
+
+    return vzmesh, xi, yi
+
+
+def calculate_diag_length(    
+    xpos: np.ndarray,
+    ypos: np.ndarray,
+    VZmesh: np.ndarray
+) -> tuple[float, float]:
+    """
+    Computes the 3D length along the main diagonal and skew diagonal of the
+    surface given by VZmesh, where xpos and ypos define the coordinate axes.
+
+    Parameters
+    ----------
+    xpos : np.ndarray
+        1D array of x-coordinates (length M).
+    ypos : np.ndarray
+        1D array of y-coordinates (length N).
+    VZmesh : np.ndarray
+        2D array of shape (M, N), representing z-values at the grid points
+        formed by xpos and ypos.
+
+    Returns
+    -------
+    main_diag_dist : float
+        The summed 3D distance along the main diagonal of the surface.
+    skew_diag_dist : float
+        The summed 3D distance along the skew (reverse) diagonal of the surface.
+
+    Notes
+    -----
+    The function interpolates coordinates along whichever dimension is larger,
+    then sums Euclidean distances in 3D for each diagonal path.
+    """
+    M, N = VZmesh.shape  # M = len(xpos), N = len(ypos)
+
+    # Build interpolators over the regular (xpos,ypos) grid
+    interp_x = RegularGridInterpolator((xpos, ypos), 
+                                       np.meshgrid(xpos, ypos, indexing='ij')[0],
+                                       method='linear')
+    interp_y = RegularGridInterpolator((xpos, ypos), 
+                                       np.meshgrid(xpos, ypos, indexing='ij')[1],
+                                       method='linear')
+    interp_z = RegularGridInterpolator((xpos, ypos), VZmesh, 
+                                       method='linear')
+
+    main_diag_dist = 0.0
+    skew_diag_dist = 0.0
+
+    # if N >= M, we step N times in x, and use the full range of ypos in y
+    if N >= M:
+        # Build vectors for diagonal queries, matching the MATLAB approach
+        x_diag = np.linspace(xpos[0], xpos[-1], N)  # length N
+        y_main_diag = np.array(ypos)               # also length N
+        y_skew_diag = y_main_diag[::-1]
+
+        # Evaluate on main diagonal
+        pts_main = np.column_stack((x_diag, y_main_diag))  # shape (N,2)
+        x_knots_main = interp_x(pts_main)
+        y_knots_main = interp_y(pts_main)
+        z_knots_main = interp_z(pts_main)
+
+        # Evaluate on skew diagonal
+        pts_skew = np.column_stack((x_diag, y_skew_diag))
+        x_knots_skew = interp_x(pts_skew)
+        y_knots_skew = interp_y(pts_skew)
+        z_knots_skew = interp_z(pts_skew)
+
+        # Accumulate distances
+        for kk in range(N - 1):
+            dx_main = x_knots_main[kk] - x_knots_main[kk + 1]
+            dy_main = y_knots_main[kk] - y_knots_main[kk + 1]
+            dz_main = z_knots_main[kk] - z_knots_main[kk + 1]
+            main_diag_dist += np.sqrt(dx_main**2 + dy_main**2 + dz_main**2)
+
+            dx_skew = x_knots_skew[kk] - x_knots_skew[kk + 1]
+            dy_skew = y_knots_skew[kk] - y_knots_skew[kk + 1]
+            dz_skew = z_knots_skew[kk] - z_knots_skew[kk + 1]
+            skew_diag_dist += np.sqrt(dx_skew**2 + dy_skew**2 + dz_skew**2)
+
+    else:
+        # M > N
+        y_diag = np.linspace(ypos[0], ypos[-1], M)  # length M
+        x_main_diag = np.array(xpos)               # also length M
+        x_skew_diag = x_main_diag[::-1]
+
+        # Evaluate on main diagonal
+        pts_main = np.column_stack((x_main_diag, y_diag))  # shape (M,2)
+        x_knots_main = interp_x(pts_main)
+        y_knots_main = interp_y(pts_main)
+        z_knots_main = interp_z(pts_main)
+
+        # Evaluate on skew diagonal
+        pts_skew = np.column_stack((x_skew_diag, y_diag))
+        x_knots_skew = interp_x(pts_skew)
+        y_knots_skew = interp_y(pts_skew)
+        z_knots_skew = interp_z(pts_skew)
+
+        # Accumulate distances
+        for kk in range(M - 1):
+            dx_main = x_knots_main[kk] - x_knots_main[kk + 1]
+            dy_main = y_knots_main[kk] - y_knots_main[kk + 1]
+            dz_main = z_knots_main[kk] - z_knots_main[kk + 1]
+            main_diag_dist += np.sqrt(dx_main**2 + dy_main**2 + dz_main**2)
+
+            dx_skew = x_knots_skew[kk] - x_knots_skew[kk + 1]
+            dy_skew = y_knots_skew[kk] - y_knots_skew[kk + 1]
+            dz_skew = z_knots_skew[kk] - z_knots_skew[kk + 1]
+            skew_diag_dist += np.sqrt(dx_skew**2 + dy_skew**2 + dz_skew**2)
+
+    return main_diag_dist, skew_diag_dist
+
+
+def assign_local_coordinates(triangle: np.ndarray) -> tuple[complex, complex, complex, float]:
+    """
+    Assigns local complex coordinates (w1, w2, w3) to the three vertices of a
+    triangle in 3D space, used for conformal mapping calculations.
+
+    Parameters
+    ----------
+    triangle : np.ndarray
+        Array of shape (3, 3), where each row corresponds to a vertex in (x, y, z).
+        The three vertices define one triangular face.
+
+    Returns
+    -------
+    w1 : complex
+        Complex representation of the local coordinate for vertex 1.
+    w2 : complex
+        Complex representation of the local coordinate for vertex 2.
+    w3 : complex
+        Complex representation of the local coordinate for vertex 3.
+    zeta : float
+        A normalization factor based on the triangle’s geometry, typically used
+        to scale further computations (e.g., for quasi-conformal maps).
+
+    Notes
+    -----
+    Each vertex is measured relative to the first vertex, establishing a local
+    coordinate system. The calculations ensure an appropriate scale and orientation
+    for the subsequent mapping steps.
+    """    
+    d12 = np.linalg.norm(triangle[0] - triangle[1])
+    d13 = np.linalg.norm(triangle[0] - triangle[2])
+    d23 = np.linalg.norm(triangle[1] - triangle[2])
+    y3 = ((-d12)**2 + d13**2 - d23**2) / (2 * -d12)
+    x3 = np.sqrt(np.maximum(0, d13**2 - y3**2))
+    w2 = -x3 - 1j * y3
+    w1 = x3 + 1j * (y3 + d12)
+    w3 = 1j * (-d12)
+    zeta = np.abs(np.real(1j * (np.conj(w2) * w1 - np.conj(w1) * w2)))
+    return w1, w2, w3, zeta
+
+def conformal_map_indep_fixed_diagonals(
+    mainDiagDist: float,
+    skewDiagDist: float,
+    xpos: np.ndarray,
+    ypos: np.ndarray,
+    VZmesh: np.ndarray
+) -> np.ndarray:
+    """
+    Creates a quasi-conformal 2D mapping of the surface in VZmesh. 
+    Diagonal constraints are fixed using mainDiagDist and skewDiagDist 
+    for consistent scaling.
+
+    Parameters
+    ----------
+    mainDiagDist : float
+        Target distance along the main diagonal for the mapped surface.
+    skewDiagDist : float
+        Target distance along the skew (reverse) diagonal for the mapped surface.
+    xpos : np.ndarray
+        1D array of x-coordinates (length M).
+    ypos : np.ndarray
+        1D array of y-coordinates (length N).
+    VZmesh : np.ndarray
+        2D array of shape (M, N), representing z-values for each (x, y).
+
+    Returns
+    -------
+    mappedPositions : np.ndarray
+        2D array of shape (M*N, 2). Each row corresponds to the (x, y) position
+        in the conformal map for the corresponding vertex in the original mesh.
+
+    Notes
+    -----
+    The mapping is generated by splitting each cell of the grid into two triangles,
+    constructing a sparse system to enforce approximate conformality, and then
+    solving for new vertex positions subject to diagonally fixed boundaries.
+    The final 2D layout merges two separate diagonal constraints.
+    """    
+    M, N = VZmesh.shape
+    xpos_new = xpos + 1
+    ypos_new = ypos + 1
+    vertexCount:int = M * N
+    triangleCount = (2 * M - 2) * (N - 1)
+
+    # Efficient triangulation construction
+    col1 = np.kron([1, 1], np.arange(M - 1)).reshape(-1, 1)
+    temp1 = np.kron([1, M + 1], np.ones(M - 1)).reshape(-1, 1)
+    temp2 = np.kron([M + 1, M], np.ones(M - 1)).reshape(-1, 1)
+    one_column = np.hstack([col1, col1 + temp1, col1 + temp2]).astype(int)
+
+    # Corrected broadcasting logic
+    one_column_tiled = np.tile(one_column, (N - 1, 1))
+    offsets = (np.repeat(np.arange(N - 1), 2 * M - 2) * M).reshape(-1, 1)
+    triangulation = (one_column_tiled + offsets).astype(int)
+
+    # Precompute arrays
+    row_indices = np.repeat(np.arange(triangleCount), 3)
+    col_indices = triangulation.flatten()
+
+    Mreal_data = np.zeros(triangleCount * 3)
+    Mimag_data = np.zeros(triangleCount * 3)
+
+    # Loop once to fill the data
+    for tri_idx in range(triangleCount):
+        vertices = triangulation[tri_idx]
+        coords = np.column_stack((
+            xpos_new[vertices % M],
+            ypos_new[vertices // M],
+            VZmesh[vertices % M, vertices // M]
+        ))
+        w1, w2, w3, zeta = assign_local_coordinates(coords)
+        denom = np.sqrt(zeta / 2)
+        ws = [w1, w2, w3]
+
+        idx = slice(tri_idx * 3, (tri_idx + 1) * 3)
+        Mreal_data[idx] = np.real(ws) / denom
+        Mimag_data[idx] = np.imag(ws) / denom
+
+    # Build sparse matrices in one step
+    Mreal_csr = coo_matrix((Mreal_data, (row_indices, col_indices)), shape=(triangleCount, vertexCount)).tocsr()
+    Mimag_csr = coo_matrix((Mimag_data, (row_indices, col_indices)), shape=(triangleCount, vertexCount)).tocsr()
+
+    def solve_mapping(fixed_pts, fixed_vals, free_pts):
+        A = vstack([
+            hstack([Mreal_csr[:, free_pts], -Mimag_csr[:, free_pts]]),
+            hstack([Mimag_csr[:, free_pts], Mreal_csr[:, free_pts]])
+        ])
+
+        b_real = Mreal_csr[:, fixed_pts] @ fixed_vals[:, 0] - Mimag_csr[:, fixed_pts] @ fixed_vals[:, 1]
+        b_imag = Mimag_csr[:, fixed_pts] @ fixed_vals[:, 0] + Mreal_csr[:, fixed_pts] @ fixed_vals[:, 1]
+        b = -np.concatenate([b_real, b_imag])
+
+        AtA = (A.T @ A).tocsc()
+        Atb = A.T @ b
+
+        if HAS_CHOLMOD:
+            sol = cholesky(AtA)(Atb)
+        else:
+            sol = spsolve(AtA, Atb)
+
+        num_free = len(free_pts)
+        mapped = np.zeros((vertexCount, 2))
+        mapped[fixed_pts] = fixed_vals
+        mapped[free_pts, 0] = sol[:num_free]
+        mapped[free_pts, 1] = sol[num_free:]
+        return mapped
+
+    diag_scale = M / np.sqrt(M**2 + N**2)
+    main_diag_fixed_pts = [0, vertexCount - 1]
+    main_diag_fixed_vals = np.array([
+        [xpos_new[0], ypos_new[0]],
+        [xpos_new[0] + mainDiagDist * diag_scale, ypos_new[0] + mainDiagDist * diag_scale * N / M]
+    ])
+    main_diag_free_pts = np.setdiff1d(np.arange(vertexCount), main_diag_fixed_pts)
+    mapped_main = solve_mapping(main_diag_fixed_pts, main_diag_fixed_vals, main_diag_free_pts)
+
+    skew_diag_fixed_pts = [M - 1, vertexCount - M]
+    skew_diag_fixed_vals = np.array([
+        [xpos_new[0] + skewDiagDist * diag_scale, ypos_new[0]],
+        [xpos_new[0], ypos_new[0] + skewDiagDist * diag_scale * N / M]
+    ])
+    skew_diag_free_pts = np.setdiff1d(np.arange(vertexCount), skew_diag_fixed_pts)
+    mapped_skew = solve_mapping(skew_diag_fixed_pts, skew_diag_fixed_vals, skew_diag_free_pts)
+
+    # Final averaged result
+    mappedPositions = (mapped_main + mapped_skew) / 2
+    return mappedPositions
+
+def align_mapped_surface(    
+    thisVZminmesh: np.ndarray,
+    thisVZmaxmesh: np.ndarray,
+    mappedMinPositions: np.ndarray,
+    mappedMaxPositions: np.ndarray,
+    xborders: list[int],
+    yborders: list[int],
+    conformal_jump: int = 1,
+    patch_size: int = 21
+) -> np.ndarray:
+    """
+    Shifts the second mapped surface (mappedMaxPositions) so that its local
+    gradients align best with those of the first (mappedMinPositions).
+
+    Parameters
+    ----------
+    thisVZminmesh : np.ndarray
+        2D array of shape (X, Y), representing the first (minimum) surface.
+    thisVZmaxmesh : np.ndarray
+        2D array of shape (X, Y), representing the second (maximum) surface.
+    mappedMinPositions : np.ndarray
+        2D array of shape (X*Y, 2), the conformally mapped coordinates 
+        corresponding to the min surface.
+    mappedMaxPositions : np.ndarray
+        2D array of shape (X*Y, 2), the conformally mapped coordinates 
+        corresponding to the max surface.
+    xborders : list of int
+        [x_min, x_max] bounding indices used to focus the alignment region.
+    yborders : list of int
+        [y_min, y_max] bounding indices used to focus the alignment region.
+    conformal_jump : int, default=1
+        Subsampling step in x and y dimensions for alignment calculations.
+    patch_size : int, default=21
+        Size of the local 2D window used for minimizing gradient differences.
+
+    Returns
+    -------
+    mappedMaxPositions : np.ndarray
+        Updated 2D array of shape (X*Y, 2) for the max surface, 
+        after alignment to the min surface.
+
+    Notes
+    -----
+    This step finds an offset (shift in x and y) that best aligns local slope
+    features from the two surfaces, by comparing gradients in a restricted region 
+    and choosing the position with minimal combined gradient magnitude.
+    """
+    patch_size = int(np.ceil(patch_size / conformal_jump))
+
+    # Pad surfaces to preserve shape after differencing
+    pad_val_min = 10 * np.max(thisVZminmesh)
+    pad_val_max = 10 * np.max(thisVZmaxmesh)
+
+    VZminmesh_padded = np.pad(thisVZminmesh, ((0, 1), (0, 1)), constant_values=pad_val_min)
+    VZmaxmesh_padded = np.pad(thisVZmaxmesh, ((0, 1), (0, 1)), constant_values=pad_val_max)
+
+    # Gradient differences (dx + i*dy)
+    dmin_dx = np.diff(VZminmesh_padded, axis=0)[:, :-1]
+    dmin_dy = np.diff(VZminmesh_padded, axis=1)[:-1, :]
+    dMinSurface = np.abs(dmin_dx + 1j * dmin_dy)
+
+    dmax_dx = np.diff(VZmaxmesh_padded, axis=0)[:, :-1]
+    dmax_dy = np.diff(VZmaxmesh_padded, axis=1)[:-1, :]
+    dMaxSurface = np.abs(dmax_dx + 1j * dmax_dy)
+
+    # Region of interest
+    x1, x2 = xborders
+    y1, y2 = yborders
+
+    dMinSurface_roi = dMinSurface[x1:x2+1:conformal_jump, y1:y2+1:conformal_jump]
+    dMaxSurface_roi = dMaxSurface[x1:x2+1:conformal_jump, y1:y2+1:conformal_jump]
+
+    combined_slope = dMinSurface_roi + dMaxSurface_roi
+
+    # Patch cost = sum of local gradients over patch
+    kernel = np.ones((patch_size, patch_size))
+    patch_costs = convolve2d(combined_slope, kernel, mode='valid')
+
+    # # Map back to flattened index in 2D mesh
+    # row, col are 0-based from Python
+    # Convert them to 1-based to mimic MATLAB
+    min_index = np.argmin(patch_costs)
+    row0, col0 = np.unravel_index(min_index, patch_costs.shape)
+    # (row0, col0) is 0-based, which correspond to x,y in MATLAB if the array shape is (num_x, num_y).
+
+    # Now replicate the step:
+    #   row = round(row + (patchSize - 1)/2)
+    #   col = round(col + (patchSize - 1)/2)
+    row_center_0b = int(round(row0 + (patch_size - 1) / 2))
+    col_center_0b = int(round(col0 + (patch_size - 1) / 2))
+
+    # Now we want the same linear index that MATLAB would get from
+    # sub2ind([num_x, num_y], row_center, col_center),
+    # except sub2ind is 1-based. In 0-based form, that is:
+    #   linearInd = col_center_0b * num_x + row_center_0b
+    flat_index = col_center_0b * dMinSurface_roi.shape[0] + row_center_0b
+
+    # Then do the shift
+    shift_x = mappedMaxPositions[flat_index, 0] - mappedMinPositions[flat_index, 0]
+    shift_y = mappedMaxPositions[flat_index, 1] - mappedMinPositions[flat_index, 1]
+
+    mappedMaxPositions[:, 0] -= shift_x
+    mappedMaxPositions[:, 1] -= shift_y
+
+    return mappedMaxPositions
+
+
+def warp_surface(
+    thisvzminmesh: np.ndarray,
+    thisvzmaxmesh: np.ndarray,
+    arbor_boundaries: tuple[int, int, int, int],
+    conformal_jump: int = 1,
+    verbose: bool = False
+) -> dict:
+    """
+    Generates a conformal warp of two Starburst Amacrine Cell (SAC) surfaces 
+    (min and max) and aligns them. This function is a higher-level wrapper 
+    that uses diagonal distance calculations, conformal mapping, and alignment.
+
+    Parameters
+    ----------
+    thisvzminmesh : np.ndarray
+        2D array of shape (X, Y), representing the “minimum” / ON SAC surface.
+    thisvzmaxmesh : np.ndarray
+        2D array of shape (X, Y), representing the “maximum” / OFF SAC surface.
+    arbor_boundaries : tuple of int
+        (xmin, xmax, ymin, ymax) specifying the region of interest 
+        over which to warp the surfaces.
+    conformal_jump : int, default=1
+        Subsampling step for reducing the resolution during mapping 
+        (e.g., conformal_jump=2 uses every other pixel).
+    verbose : bool, default=False
+        Whether to print timing and debug information.
+
+    Returns
+    -------
+    dict
+        Dictionary containing:
+        - "mapped_min_positions": np.ndarray
+            Mapped coordinates for the min surface.
+        - "mapped_max_positions": np.ndarray
+            Mapped coordinates for the max surface (aligned to min).
+        - "main_diag_dist": float
+            Average main diagonal distance used during conformal mapping.
+        - "skew_diag_dist": float
+            Average skew diagonal distance used during conformal mapping.
+        - "thisx": np.ndarray
+            Subsampled x indices used for mapping.
+        - "thisy": np.ndarray
+            Subsampled y indices used for mapping.
+        - "thisVZminmesh": np.ndarray
+            Original min surface data used in mapping (subsampled).
+        - "thisVZmaxmesh": np.ndarray
+            Original max surface data used in mapping (subsampled).
+
+    Notes
+    -----
+    This routine is tailored to Starburst Amacrine Cell layers but can be 
+    generalized to other layered surfaces. It:
+    1. Subsamples the surfaces by conformal_jump.
+    2. Calculates average diagonal distances from each surface.
+    3. Performs two independent conformal mappings (min and max).
+    4. Aligns the “max” mapping to “min” based on local gradient differences.
+    5. Returns a dictionary of intermediate results for further inspection.
+    """
+    if verbose:
+        print("Warping surface...")
+    xmin, xmax, ymin, ymax = arbor_boundaries
+
+    thisx = np.round(np.arange(np.maximum(xmin-2, 0), np.minimum(xmax+1, thisvzmaxmesh.shape[0]), conformal_jump)).astype(int)
+    thisy = np.round(np.arange(np.maximum(ymin-2, 0), np.minimum(ymax+1, thisvzmaxmesh.shape[1]), conformal_jump)).astype(int)
+
+    thisminmesh = thisvzminmesh[thisx[:, None], thisy]
+    thismaxmesh = thisvzmaxmesh[thisx[:, None], thisy]
+    # calculate the traveling distances on the diagonals of the two SAC surfaces 
+    start_time = time.time()
+    main_diag_dist_min, skew_diag_dist_min = calculate_diag_length(thisx, thisy, thisminmesh)
+    main_diag_dist_max, skew_diag_dist_max = calculate_diag_length(thisx, thisy, thismaxmesh)
+
+    main_diag_dist = np.mean([main_diag_dist_min, main_diag_dist_max])
+    skew_diag_dist = np.mean([skew_diag_dist_min, skew_diag_dist_max])
+
+    # quasi-conformally map individual SAC surfaces to planes
+    if verbose:
+        print("Mapping min position (On SAC layer)...")    
+        start_time = time.time()
+    mapped_min_positions = conformal_map_indep_fixed_diagonals(
+        main_diag_dist, skew_diag_dist, thisx, thisy, thisminmesh
+    )
+    if verbose:
+        print(f"Mapping min position completed in {time.time() - start_time:.2f} seconds.")
+
+    if verbose:
+        print("Mapping max position (Off SAC layer)...")
+        start_time = time.time()
+    mapped_max_positions = conformal_map_indep_fixed_diagonals(
+        main_diag_dist, skew_diag_dist, thisx, thisy, thismaxmesh
+    )
+    if verbose:
+        print(f"Mapping max position completed in {time.time() - start_time:.2f} seconds.")
+
+    xborders = [thisx.min(), thisx.max()]
+    yborders = [thisy.min(), thisy.max()]
+
+    # align the mapped max surface to the mapped min surface
+    mapped_max_positions = align_mapped_surface(
+        thisvzminmesh, thisvzmaxmesh,
+        mapped_min_positions, mapped_max_positions,
+        xborders, yborders, conformal_jump
+    )
+
+    return {
+        "mapped_min_positions": mapped_min_positions,
+        "mapped_max_positions": mapped_max_positions,
+        "main_diag_dist": main_diag_dist,
+        "skew_diag_dist": skew_diag_dist,
+        "thisx": thisx,
+        "thisy": thisy,
+        "thisVZminmesh": thisvzminmesh,
+        "thisVZmaxmesh": thisvzmaxmesh,
+    }

pywarper/utils.py

@@ -0,0 +1,118 @@
+import numpy as np
+import pandas as pd
+
+# import scipy.spatial
+
+def read_arbor_trace(
+    datapath: str,
+    downsample_factor: int = 1
+) -> tuple[pd.DataFrame, np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Reads a neuronal arbor trace from an SWC file and optionally downsamples the data.
+
+    Parameters
+    ----------
+    datapath : str
+        Path to the SWC file to read.
+    downsample_factor : int, default=1
+        If greater than 1, every n-th row is selected (in row order) to reduce
+        the total number of points in the returned data.
+
+    Returns
+    -------
+    df : pd.DataFrame
+        A DataFrame containing all columns read from the SWC file:
+        'n', 'type', 'x', 'y', 'z', 'radius', 'parent'.
+    coords : np.ndarray
+        An (N, 3) array of node coordinates [x, y, z].
+    edges : np.ndarray
+        An (N, 2) array where each row is [node_id, parent_id].
+        Note that ids and parents may be updated if downsample_factor > 1.
+    radii : np.ndarray
+        An (N,) array of radii corresponding to each node.
+
+    Notes
+    -----
+    1. Comment lines in the SWC file (prefixed by '#') are automatically skipped.
+    2. The downsampled data is re-indexed so that the 'parent' field reflects
+       the new node numbering.
+    """
+    # Read the SWC file into a DataFrame
+    df = pd.read_csv(datapath, comment='#',
+                     names=['n', 'type', 'x', 'y', 'z', 'radius', 'parent'],
+                     index_col=False, sep=r'\s+')
+
+    if downsample_factor > 1:
+        # Downsample the DataFrame by selecting every nth point
+        downsampled_df = df.iloc[::downsample_factor].copy()
+
+        # Update the indices
+        id_map = {old_id: new_id for new_id, old_id in enumerate(downsampled_df['n'], start=1)}
+        downsampled_df['n'] = downsampled_df['n'].map(id_map)
+        downsampled_df['parent'] = downsampled_df['parent'].map(lambda x: id_map.get(x, -1))
+
+        df = downsampled_df
+
+    return df, df[["x", "y", "z"]].values, df[["n", "parent"]].values, df["radius"].values
+
+
+# def read_arbor_trace(datapath):
+
+#     df = pd.read_csv(datapath, comment='#',
+#                       names=['n', 'type', 'x', 'y', 'z', 'radius', 'parent'], index_col=False, sep=r'\s+')
+
+#     return df, df[["x", "y", "z"]].values, df[["n", "parent"]].values, df["radius"].values
+
+# def summarize_z_at_sampled_xy(x, y, z, grid_spacing=10, radius=5, percentiles=[10, 25, 50, 75, 90]):
+#     """
+#     Sample a sparse subset of original (x, y) points and compute z summary stats
+#     over a local neighborhood (radius).
+
+#     Parameters:
+#         x, y, z (np.ndarray): Original point cloud arrays (N,)
+#         grid_spacing (float): Sampling interval for (x, y) grid
+#         radius (float): Radius around each sample point to summarize z values
+#         percentiles (list): Percentiles to compute for z
+
+#     Returns:
+#         x_samp, y_samp: Sampled locations (M,)
+#         z_mean: mean Z value around each (x, y)
+#         z_stats: dict of z_pXX arrays (same length as x_samp)
+#     """
+#     # Build spatial tree on original points
+#     xy = np.column_stack((x, y))
+#     tree = scipy.spatial.cKDTree(xy)
+
+#     # Generate sparse sampling grid
+#     x_grid = np.arange(x.min(), x.max(), grid_spacing)
+#     y_grid = np.arange(y.min(), y.max(), grid_spacing)
+
+#     xx, yy = np.meshgrid(x_grid, y_grid)
+#     sample_points = np.column_stack((xx.ravel(), yy.ravel()))
+
+#     # For each sample point, find neighbors within radius
+#     neighbors = tree.query_ball_point(sample_points, r=radius)
+
+#     x_samp, y_samp = [], []
+#     z_mean = []
+#     z_percentiles = {f'z_p{p}': [] for p in percentiles}
+
+#     # Get max edges (float values)
+#     for (xi, yi), idxs in zip(sample_points, neighbors):
+#         if len(idxs) == 0:
+#             continue  # skip interior point with no neighbors
+#         else:
+#             z_vals = z[idxs]
+
+#         x_samp.append(xi)
+#         y_samp.append(yi)
+#         z_mean.append(np.mean(z_vals))
+#         for p in percentiles:
+#             z_percentiles[f'z_p{p}'].append(np.percentile(z_vals, p))
+
+#     return (
+#         np.array(x_samp),
+#         np.array(y_samp),
+#         np.array(z_mean),
+#         {k: np.array(v) for k, v in z_percentiles.items()}
+#     )

pywarper-0.1.0.dist-info/METADATA

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: pywarper
+Version: 0.1.0
+Summary: Conformal mapping-based warping of neuronal arbor morphologies.
+Requires-Python: >=3.9.0
+Requires-Dist: numpy>=2.0.2
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: pygridfit>=0.1.4
+Requires-Dist: scipy>=1.13.1
+Requires-Dist: watermark>=2.5.0
+Provides-Extra: dev
+Requires-Dist: maturin; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Provides-Extra: scikit-sparse
+Requires-Dist: pygridfit[scikit-sparse]>=0.1.4; extra == 'scikit-sparse'
+Requires-Dist: scikit-sparse>=0.4.15; extra == 'scikit-sparse'
+Description-Content-Type: text/markdown
+
+# pywarper
+
+`pywarper` is a Python package for conformal mapping-based warping of neuronal arbor morphologies, based on the [MATLAB implementations](https://github.com/uygarsumbul/rgc) (Sümbül, et al. 2014). 
+
+## Installation
+
+```bash
+git clone https://github.com/berenslab/pywarper.git
+pip install -e pywarper
+```
+
+By default, `pywarper` uses `scipy.sparse.linalg.spsolve` to solve sparse matrices, which can be slow. For faster performance, you can manually install [scikit-sparse](https://github.com/scikit-sparse/scikit-sparse), as it requires additional dependencies:
+
+```bash
+# mac
+brew install suite-sparse
+
+# debian
+sudo apt-get install libsuitesparse-dev
+
+pip install -e pywarper[scikit-sparse]
+```
+
+## Usage
+
+See the [example](https://github.com/berenslab/pywarper/blob/main/notebooks/example.ipynb) notebook for usage. 

pywarper-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+pywarper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pywarper/arbor.py,sha256=S1YONCF3kUC-vBugJ3bDeLM4gfC6WprqvcGVX9iy8WU,10776
+pywarper/surface.py,sha256=wjZges-TZrGSQMNIBUXMAhX6u4WP1t2HVsAljajzYdw,26408
+pywarper/utils.py,sha256=T_QZtRs3xGIubyVdTV-GIS-1_lpxNDZdAgTCAKZZtJ0,4265
+pywarper-0.1.0.dist-info/METADATA,sha256=aO3uUtv-ZyUbbiak-gY1iqu66erqGWknYwJ2GliRL2w,1509
+pywarper-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pywarper-0.1.0.dist-info/RECORD,,

pywarper-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any