ossify 0.2.5__tar.gz → 0.2.7__tar.gz

{ossify-0.2.5 → ossify-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: ossify
-Version: 0.2.5
+Version: 0.2.7
 Summary: Mesh and skeleton analysis
 Author-email: Casey Schneider-Mizell <caseysm@gmail.com>
 License-File: LICENSE

{ossify-0.2.5 → ossify-0.2.7}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 allow-direct-references = true
 [project]
 name = "ossify"
-version = "0.2.5"
+version = "0.2.7"
 description = "Mesh and skeleton analysis"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -95,7 +95,7 @@ default-groups = ["dev", "docs", "lint", "profile", "viz"]
 
 
 [tool.bumpversion]
-current_version = "0.2.5"
+current_version = "0.2.7"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 regex = false

{ossify-0.2.5 → ossify-0.2.7}/src/ossify/__init__.py

@@ -5,7 +5,7 @@ from .base import *
 from .file_io import *
 from .translate import *
 
-__version__ = "0.2.5"
+__version__ = "0.2.7"
 
 
 def __getattr__(name):

{ossify-0.2.5 → ossify-0.2.7}/src/ossify/algorithms.py

@@ -547,11 +547,17 @@ def _label_axon_synapse_flow(
     """feature an axon compartment by synapse betweenness. All parameters are as positional indices."""
     syn_btw = synapse_betweenness(skeleton, pre_syn_inds, post_syn_inds)
     high_vinds = np.flatnonzero(syn_btw == max(syn_btw))
-    close_vind = high_vinds[np.argmin(skeleton.distance_to_root(high_vinds))]
+    # Everything here is positional, so every lookup must say so: on a masked
+    # skeleton (the ntimes > 1 path runs inside a mask_context) vertex indices
+    # and positional indices are different spaces.
+    close_vind = high_vinds[
+        np.argmin(skeleton.distance_to_root(high_vinds, as_positional=True))
+    ]
     if extend_feature_to_segment:
         relseg = skeleton.segment_map[close_vind]
-        min_ind = np.argmin(skeleton.distance_to_root(skeleton.segments[relseg]))
-        axon_split_ind = skeleton.segments[relseg][min_ind]
+        seg = skeleton.segments_positional[relseg]
+        min_ind = np.argmin(skeleton.distance_to_root(seg, as_positional=True))
+        axon_split_ind = seg[min_ind]
     else:
         axon_split_ind = close_vind
     downstream_inds = skeleton.downstream_vertices(

{ossify-0.2.5 → ossify-0.2.7}/src/ossify/data_layers.py

@@ -459,18 +459,26 @@ class PointMixin(ABC):
         as_positional : bool
             Whether input vertices are positional indices (True) or vertex indices (False).
         vertex_index : Optional[np.ndarray], optional
-            Custom vertex index array to use for mapping. If None, uses self.vertex_index.
+            The index space the result is expressed in: positions are returned
+            relative to this array. If None, uses self.vertex_index. Passing a
+            different array (e.g. ``base_vertex_index``) maps this layer's
+            vertices into that other space.
 
         Returns
         -------
         Tuple[np.ndarray, bool]
             Tuple of (positional_indices, is_positional_flag).
         """
-        if vertex_index is None:
-            vertex_index = self.vertex_index
         if vertices is None:
-            vertices = np.arange(len(self.vertex_index))
-            as_positional = True
+            if vertex_index is None:
+                vertices = np.arange(len(self.vertex_index))
+                as_positional = True
+            else:
+                # "All of my vertices", but expressed in the caller's target
+                # index space -- going via vertex ids is the only way to cross
+                # between spaces, since positions do not correspond.
+                vertices = self.vertex_index
+                as_positional = False
         else:
             vertices = np.asarray(vertices)
             if np.issubdtype(vertices.dtype, np.bool_):
@@ -480,11 +488,15 @@ class PointMixin(ABC):
                     )
                 vertices = np.flatnonzero(vertices)
                 as_positional = True
+            elif vertices.size == 0:
+                # An empty list arrives as float64, and fastremap passes the
+                # dtype straight through, leaving a result that is not a legal
+                # index array. Give it an integer dtype up front.
+                vertices = vertices.astype(np.intp)
+        if vertex_index is None:
+            vertex_index = self.vertex_index
         if not as_positional:
-            if vertex_index is None:
-                vertex_index_map = self.vertex_index_map
-            else:
-                vertex_index_map = {v: i for i, v in enumerate(vertex_index)}
+            vertex_index_map = {v: i for i, v in enumerate(vertex_index)}
             # fastremap.remap rejects 0-d arrays, so a scalar vertex would crash
             # here. Remap on a 1-d view and restore the caller's shape, keeping
             # scalar-in -> scalar-out (as the positional path already does).
@@ -2164,6 +2176,56 @@ class SkeletonLayer(GraphLayer):
         """
         return np.asarray(self._base_properties["base_parent_array"])
 
+    def _vertices_to_base_positional(
+        self, vertices: Optional[np.ndarray], as_positional: bool
+    ) -> np.ndarray:
+        """Map a vertex selection on this (possibly masked) layer to positional
+        indices into the **base**, unmasked arrays.
+
+        ``base_csgraph``/``base_csgraph_binary`` span the original unmasked
+        skeleton, so anything used to index their dijkstra results must be in
+        base positional space -- not this layer's. The two only coincide when
+        unmasked. Conversion always goes via vertex ids, the one index space
+        the masked layer and the base snapshot share.
+
+        Parameters
+        ----------
+        vertices : Optional[np.ndarray]
+            Vertex indices, positional indices, or a boolean mask over this
+            layer's vertices. If None, every vertex of *this* layer is used, in
+            this layer's positional order, so the result lines up 1:1 with
+            ``self.vertices``.
+        as_positional : bool
+            Whether ``vertices`` are positional indices into this layer. A
+            boolean mask is implicitly positional whatever this says.
+
+        Returns
+        -------
+        np.ndarray
+            Positional indices into the base (unmasked) arrays. Scalar in,
+            scalar out.
+        """
+        if vertices is None:
+            vertices = self.vertex_index
+        else:
+            vertices = np.asarray(vertices)
+            if np.issubdtype(vertices.dtype, np.bool_):
+                if len(vertices) != self.n_vertices:
+                    raise ValueError(
+                        "If vertices is a boolean array, it must have the same length as the number of vertices."
+                    )
+                vertices = self.vertex_index[np.flatnonzero(vertices)]
+            else:
+                if vertices.size == 0:
+                    # An empty list is float64, which cannot index an array.
+                    vertices = vertices.astype(np.intp)
+                if as_positional:
+                    vertices = self.vertex_index[vertices]
+        base_positional, _ = self._vertices_to_positional(
+            vertices, as_positional=False, vertex_index=self.base_vertex_index
+        )
+        return base_positional
+
     def _reset_derived_properties(self) -> None:
         super()._reset_derived_properties()
         self._dag_cache = gf.DAGCache()
@@ -2366,35 +2428,30 @@ class SkeletonLayer(GraphLayer):
         Parameters
         ----------
         vertices : Optional[np.ndarray]
-            The vertices to get the distance from the root for. If None, all vertices are used.
+            The vertices to get the distance from the root for. If None, every
+            vertex of this layer is used, in this layer's positional order, so
+            the result lines up 1:1 with ``self.vertices``.
         as_positional : bool
             If True, the vertices are treated as positional indices. If False, they are treated as vertex features.
 
         Returns
         -------
         np.ndarray
-            The distance from the root for each vertex.
-        """
-        # Vertices must be positional but in the base space for the dijkstra
-        if as_positional:
-            if vertices is None:
-                vertices = self.vertex_index
-            else:
-                vertices = self.vertex_index[vertices]
-            as_positional = False
-        vertices, as_positional = self._vertices_to_positional(
-            vertices, as_positional, vertex_index=self.base_vertex_index
-        )
-        if self._dag_cache.distance_to_root is not None:
-            dtr = self._dag_cache.distance_to_root
-        else:
-            dtr = sparse.csgraph.dijkstra(
+            The distance from the root for each vertex. One value per requested
+            vertex of *this* layer, so on a masked skeleton ``distance_to_root()``
+            always equals ``distance_to_root(np.arange(n), as_positional=True)``
+            and ``distance_to_root(self.vertex_index)``.
+        """
+        # The dijkstra runs on the base graph, so the selection must be in base
+        # positional space -- which is not this layer's space when masked.
+        base_positional = self._vertices_to_base_positional(vertices, as_positional)
+        if self._dag_cache.base_distance_to_root is None:
+            self._dag_cache.base_distance_to_root = sparse.csgraph.dijkstra(
                 self.base_csgraph,
                 directed=False,
                 indices=self.base_root_positional,
-            )
-            self._dag_cache.distance_to_root = dtr.flatten()
-        return dtr[vertices]
+            ).flatten()
+        return self._dag_cache.base_distance_to_root[base_positional]
 
     def hops_to_root(
         self,
@@ -2406,26 +2463,29 @@ class SkeletonLayer(GraphLayer):
         Parameters
         ----------
         vertices : Optional[np.ndarray]
-            The vertices to get the distance from the root for. If None, all vertices are used.
+            The vertices to get the distance from the root for. If None, every
+            vertex of this layer is used, in this layer's positional order, so
+            the result lines up 1:1 with ``self.vertices``.
         as_positional : bool
             If True, the vertices are treated as positional indices. If False, they are treated as vertex features.
 
         Returns
         -------
         np.ndarray
-            The distance from the root for each vertex.
-        """
-        vertices, _ = self._vertices_to_positional(vertices, as_positional)
-        if self._dag_cache.hops_to_root is not None:
-            htr = self._dag_cache.hops_to_root
-        else:
-            htr = sparse.csgraph.dijkstra(
+            The hop count from the root for each vertex. One value per requested
+            vertex of *this* layer, so on a masked skeleton ``hops_to_root()``
+            always equals ``hops_to_root(np.arange(n), as_positional=True)`` and
+            ``hops_to_root(self.vertex_index)``.
+        """
+        # Same base-space contract as distance_to_root; see that method.
+        base_positional = self._vertices_to_base_positional(vertices, as_positional)
+        if self._dag_cache.base_hops_to_root is None:
+            self._dag_cache.base_hops_to_root = sparse.csgraph.dijkstra(
                 self.base_csgraph_binary,
                 directed=False,
                 indices=self.base_root_positional,
-            )
-            self._dag_cache.hops_to_root = htr
-        return htr[vertices]
+            ).flatten()
+        return self._dag_cache.base_hops_to_root[base_positional]
 
     def child_vertices(self, vertices=None, as_positional=False) -> dict:
         """Get mapping from vertices to their child nodes.
@@ -3327,8 +3387,9 @@ class PointCloudLayer(PointMixin):
         if self._cell.skeleton is None:
             raise ValueError("Cell does not have a Skeleton object.")
 
-        if vertices is None:
-            vertices = self.vertex_index
+        # Do not pre-fill ``vertices`` here: it would hand vertex ids to a call
+        # that may be reading them as positional indices. ``map_index_to_layer``
+        # already resolves None correctly for *both* index spaces.
         skel_idx = self.map_index_to_layer(
             layer=SKEL_LAYER_NAME, source_index=vertices, as_positional=as_positional
         )

{ossify-0.2.5 → ossify-0.2.7}/src/ossify/file_io.py

@@ -1,6 +1,7 @@
 import io
 import os
 import tarfile
+import warnings
 from enum import IntEnum
 from pathlib import Path
 from typing import TYPE_CHECKING, BinaryIO, Optional, Union
@@ -464,7 +465,16 @@ def load_dataframe(tinfo, tf) -> pd.DataFrame:
         Loaded DataFrame
     """
     df_buf = pa.BufferReader(tf.extractfile(tinfo).read())
-    return pd.read_feather(df_buf)
+    with warnings.catch_warnings():
+        # pandas' read_feather wraps pyarrow.feather.read_feather, which pyarrow
+        # >=24 deprecated in favor of pyarrow.ipc.open_file; this is purely an
+        # upstream implementation detail pandas hasn't addressed yet.
+        warnings.filterwarnings(
+            "ignore",
+            message=r"pyarrow\.feather\.read_feather is deprecated",
+            category=FutureWarning,
+        )
+        return pd.read_feather(df_buf)
 
 
 def load_array(tinfo, tf) -> np.ndarray:
@@ -1067,13 +1077,15 @@ def import_legacy_meshwork(
 
 def _process_pcg_skel_import(cell: Cell) -> Cell:
     if "compartment" in cell.annotations:
+        # ``map_annotations_to_feature`` already returns a frame whose column is
+        # named "compartment", so passing ``name`` here is redundant -- and
+        # ``add_feature`` warns that it ignores ``name`` for a DataFrame.
         cell.skeleton.add_feature(
             cell.skeleton.map_annotations_to_feature(
                 "compartment",
                 distance_threshold=0,
                 agg={"compartment": ("compartment", "mean")},
-            ),
-            "compartment",
+            )
         )
     if "segment_properties" in cell.annotations:
         features = cell.skeleton.map_annotations_to_feature(

{ossify-0.2.5 → ossify-0.2.7}/src/ossify/graph_functions.py

@@ -13,7 +13,14 @@ from .utils import build_csgraph, single_path_length
 class DAGCache:
     """
     Container for cached DAG properties to optimize repeated computations.
-    Cache values are always in positional indices.
+
+    Cache values are in positional indices of the layer that owns the cache,
+    **except** the two ``base_``-prefixed fields, which are in positional
+    indices of the original unmasked skeleton (``base_csgraph`` /
+    ``base_csgraph_binary``). On an unmasked layer the two spaces coincide; on
+    a masked one they do not, so never index a ``base_`` array with a
+    layer-positional index. Use
+    ``SkeletonLayer._vertices_to_base_positional`` to convert.
 
     Attributes
     ----------
@@ -37,9 +44,11 @@ class DAGCache:
     branch_points: Optional[np.ndarray] = None
     end_points: Optional[np.ndarray] = None
     segments: Optional[List[List[int]]] = None
-    distance_to_root: Optional[np.ndarray] = None
-    hops_to_root: Optional[np.ndarray] = None
+    segment_map: Optional[np.ndarray] = None
+    base_distance_to_root: Optional[np.ndarray] = None
+    base_hops_to_root: Optional[np.ndarray] = None
     cover_paths: Optional[List[List[int]]] = None
+    path_lengths: Optional[Dict[Tuple[int, int], float]] = None
     root: Optional[int] = None
 
     def __post_init__(self):
@@ -55,10 +64,12 @@ class DAGCache:
         self.branch_points = None
         self.end_points = None
         self.segments = None
+        self.segment_map = None
         self.root = None
-        self.distance_to_root = None
-        self.hops_to_root = None
+        self.base_distance_to_root = None
+        self.base_hops_to_root = None
         self.cover_paths = None
+        self.path_lengths = None
 
 
 def build_parent_node_array(vertices, edges) -> np.ndarray:

{ossify-0.2.5 → ossify-0.2.7}/src/ossify/plot.py

@@ -968,7 +968,7 @@ def plot_points(
     # which dominates small synapse markers).
     if "linewidths" not in scatter_kws:
         scatter_kws["linewidths"] = 0
-    if isinstance(palette, str):
+    if isinstance(palette, str) and colors is not None and not isinstance(colors, str):
         scatter_kws["cmap"] = palette
         if color_norm is not None:
             scatter_kws["vmin"], scatter_kws["vmax"] = color_norm
@@ -1514,6 +1514,53 @@ def plot_cell_multiview(
     return axes
 
 
+_MIN_PANEL_INCHES = 0.5
+
+
+def _pad_degenerate_axes(
+    bounds_min: np.ndarray,
+    bounds_max: np.ndarray,
+    fraction: float = 0.02,
+) -> Tuple[np.ndarray, np.ndarray, List[int]]:
+    """Expand any zero-extent axis so a flat cell is still renderable.
+
+    A cell that is perfectly flat along one axis -- a planar reconstruction, a
+    2D-derived skeleton stored with z=0, or a synthetic test skeleton -- has a
+    zero extent there. Panel sizes are derived from the extents, so a zero
+    extent yields a zero-size panel and an empty figure, and matplotlib warns
+    when asked to set identical axis limits. Padding the degenerate axis to a
+    small fraction of the largest extent keeps the panel a thin strip, which is
+    an honest depiction of flat data.
+
+    Parameters
+    ----------
+    bounds_min, bounds_max : np.ndarray
+        Per-axis data bounds.
+    fraction : float
+        Width to give a degenerate axis, as a fraction of the largest
+        non-degenerate extent. If every axis is degenerate (a single point),
+        one unit is used.
+
+    Returns
+    -------
+    Tuple[np.ndarray, np.ndarray, List[int]]
+        Padded ``(bounds_min, bounds_max)`` and the indices of the axes padded.
+    """
+    bounds_min = np.array(bounds_min, dtype=float)
+    bounds_max = np.array(bounds_max, dtype=float)
+    extents = bounds_max - bounds_min
+    degenerate = np.flatnonzero(extents <= 0)
+    if len(degenerate) == 0:
+        return bounds_min, bounds_max, []
+    largest = float(extents.max())
+    pad = fraction * largest if largest > 0 else 1.0
+    for i in degenerate:
+        center = (bounds_min[i] + bounds_max[i]) / 2
+        bounds_min[i] = center - pad / 2
+        bounds_max[i] = center + pad / 2
+    return bounds_min, bounds_max, [int(i) for i in degenerate]
+
+
 def single_panel_figure(
     data_bounds_min: np.ndarray,
     data_bounds_max: np.ndarray,
@@ -1548,8 +1595,12 @@ def single_panel_figure(
     >>> fig, ax = create_single_panel_figure(bounds_min, bounds_max, 10)
     >>> # Creates 10" x 5" figure with 10 units per inch
     """
-    data_bounds_min = np.asarray(data_bounds_min)
-    data_bounds_max = np.asarray(data_bounds_max)
+    # Pad a flat axis before deriving sizes, so the panel is not zero-sized and
+    # matplotlib is never asked for identical limits. The clamp below already
+    # reports degenerate input, so this does not warn separately.
+    data_bounds_min, data_bounds_max, _ = _pad_degenerate_axes(
+        data_bounds_min, data_bounds_max
+    )
 
     # Calculate data extents
     data_width = data_bounds_max[0] - data_bounds_min[0]
@@ -1562,7 +1613,7 @@ def single_panel_figure(
     # Clamp degenerate dimensions so the figure is still renderable and
     # compatible with peers in a lineup or panel. We warn — the data is
     # degenerate, and the caller likely wants to know.
-    _MIN_INCHES = 0.5
+    _MIN_INCHES = _MIN_PANEL_INCHES
     if fig_width < _MIN_INCHES or fig_height < _MIN_INCHES:
         warnings.warn(
             f"single_panel_figure received degenerate bounds "
@@ -1641,18 +1692,28 @@ def multi_panel_figure(
     >>> fig, axes_dict = create_multi_panel_figure(bounds_min, bounds_max, 10, "side_by_side")
     >>> xy_ax, zy_ax = axes_dict["xy"], axes_dict["zy"]
     """
-    data_bounds_min = np.asarray(data_bounds_min)
-    data_bounds_max = np.asarray(data_bounds_max)
+    data_bounds_min, data_bounds_max, degenerate = _pad_degenerate_axes(
+        data_bounds_min, data_bounds_max
+    )
+    if degenerate:
+        axis_names = ", ".join("xyz"[i] for i in degenerate)
+        warnings.warn(
+            f"multi_panel_figure received a degenerate {axis_names} extent "
+            f"(0 units); padding it so the panel remains visible. The cell is "
+            f"flat along {'these axes' if len(degenerate) > 1 else 'this axis'}.",
+            stacklevel=2,
+        )
 
     # Calculate data extents for each dimension
     x_extent = data_bounds_max[0] - data_bounds_min[0]
     y_extent = data_bounds_max[1] - data_bounds_min[1]
     z_extent = data_bounds_max[2] - data_bounds_min[2]
 
-    # Convert to sizes in inches
-    x_inches = x_extent / units_per_inch
-    y_inches = y_extent / units_per_inch
-    z_inches = z_extent / units_per_inch
+    # Convert to sizes in inches. Clamp as single_panel_figure does, so a panel
+    # of a thin or flat cell is still large enough to see.
+    x_inches = max(x_extent / units_per_inch, _MIN_PANEL_INCHES)
+    y_inches = max(y_extent / units_per_inch, _MIN_PANEL_INCHES)
+    z_inches = max(z_extent / units_per_inch, _MIN_PANEL_INCHES)
 
     if layout == "side_by_side":
         # xy | zy layout