figpack-spike-sorting 0.1.0__py3-none-any.whl

figpack_spike_sorting/views/SpikeAmplitudesItem.py

@@ -0,0 +1,38 @@
+"""
+SpikeAmplitudesItem for figpack - represents spike amplitudes for a single unit
+"""
+
+from typing import Union
+
+import numpy as np
+
+
+class SpikeAmplitudesItem:
+    """
+    Represents spike amplitudes for a single unit
+    """
+
+    def __init__(
+        self,
+        *,
+        unit_id: Union[str, int],
+        spike_times_sec: np.ndarray,
+        spike_amplitudes: np.ndarray,
+    ):
+        """
+        Initialize a SpikeAmplitudesItem
+
+        Args:
+            unit_id: Identifier for the unit
+            spike_times_sec: 1D numpy array of spike times in seconds
+            spike_amplitudes: 1D numpy array of spike amplitudes
+        """
+        assert spike_times_sec.ndim == 1, "Spike times must be 1-dimensional"
+        assert spike_amplitudes.ndim == 1, "Spike amplitudes must be 1-dimensional"
+        assert len(spike_times_sec) == len(
+            spike_amplitudes
+        ), "Spike times and amplitudes must have the same length"
+
+        self.unit_id = unit_id
+        self.spike_times_sec = np.array(spike_times_sec, dtype=np.float32)
+        self.spike_amplitudes = np.array(spike_amplitudes, dtype=np.float32)

figpack_spike_sorting/views/UnitLocations.py

@@ -0,0 +1,78 @@
+"""
+AverageWaveforms view for figpack - displays multiple average waveforms
+"""
+
+from typing import List, Union
+
+import numpy as np
+
+import figpack
+from ..spike_sorting_extension import spike_sorting_extension
+
+
+class UnitLocationsItem:
+    def __init__(self, *, unit_id: Union[str, int], x: float, y: float):
+        """
+        Initialize a UnitLocationsItem
+
+        Args:
+            unit_id: Identifier for the unit
+            x: X-coordinate of the unit location
+            y: Y-coordinate of the unit location
+        """
+        self.unit_id = unit_id
+        self.x = x
+        self.y = y
+
+
+class UnitLocations(figpack.ExtensionView):
+    """
+    A view that displays the locations of units in a 2D space
+    """
+
+    def __init__(
+        self,
+        *,
+        units: List[UnitLocationsItem],
+        channel_locations: dict,
+        disable_auto_rotate: bool = False,
+    ):
+        """
+        Initialize a UnitLocations view
+
+        Args:
+            units: List of UnitLocationsItem objects
+            channel_locations: Dictionary mapping channel IDs to their locations
+        """
+        super().__init__(
+            extension=spike_sorting_extension, view_type="spike_sorting.UnitLocations"
+        )
+        self.units = units
+        self.channel_locations = channel_locations
+        self.disable_auto_rotate = disable_auto_rotate
+
+    def _write_to_zarr_group(self, group: figpack.Group) -> None:
+        """
+        Write the UnitLocations data to a Zarr group
+
+        Args:
+            group: Zarr group to write data into
+        """
+        super()._write_to_zarr_group(group)
+
+        channel_locations = {}
+        for channel_id, loc in self.channel_locations.items():
+            channel_locations[str(channel_id)] = (
+                loc.tolist() if isinstance(loc, np.ndarray) else loc
+            )
+
+        group.attrs["unit_ids"] = [str(unit.unit_id) for unit in self.units]
+        group.attrs["channel_locations"] = channel_locations
+        group.attrs["disable_auto_rotate"] = self.disable_auto_rotate
+
+        x_coords = np.array([unit.x for unit in self.units], dtype=np.float32)
+        y_coords = np.array([unit.y for unit in self.units], dtype=np.float32)
+
+        coords = np.vstack((x_coords, y_coords)).T  # Shape (num_units, 2)
+
+        group.create_dataset("coords", data=coords)

figpack_spike_sorting/views/UnitMetricsGraph.py

@@ -0,0 +1,129 @@
+"""
+UnitMetricsGraph view for figpack - displays unit metrics in a graph format
+"""
+
+from typing import List, Optional, Union, Dict
+import json
+
+import numpy as np
+
+import figpack
+from ..spike_sorting_extension import spike_sorting_extension
+
+
+class UnitMetricsGraphMetric:
+    """
+    Defines a metric with key, label, and data type
+    """
+
+    def __init__(
+        self,
+        *,
+        key: str,
+        label: str,
+        dtype: str,
+    ):
+        """
+        Initialize a UnitMetricsGraphMetric
+
+        Args:
+            key: Unique identifier for the metric
+            label: Human-readable label for display
+            dtype: Data type of the metric ("int", "float", etc.)
+        """
+        self.key = key
+        self.label = label
+        self.dtype = dtype
+
+    def to_dict(self) -> Dict:
+        """Convert to dictionary for serialization"""
+        return {
+            "key": self.key,
+            "label": self.label,
+            "dtype": self.dtype,
+        }
+
+
+class UnitMetricsGraphUnit:
+    """
+    Represents a unit with its metric values
+    """
+
+    def __init__(
+        self,
+        *,
+        unit_id: Union[str, int],
+        values: Dict[str, Union[int, float]],
+    ):
+        """
+        Initialize a UnitMetricsGraphUnit
+
+        Args:
+            unit_id: Identifier for the unit
+            values: Dictionary mapping metric keys to their values
+        """
+        self.unit_id = unit_id
+        self.values = values
+
+    def to_dict(self) -> Dict:
+        """Convert to dictionary for serialization"""
+        return {
+            "unit_id": str(self.unit_id),
+            "values": self.values,
+        }
+
+
+class UnitMetricsGraph(figpack.ExtensionView):
+    """
+    A view that displays unit metrics in a graph format
+    """
+
+    def __init__(
+        self,
+        *,
+        units: List[UnitMetricsGraphUnit],
+        metrics: List[UnitMetricsGraphMetric],
+        height: Optional[int] = None,
+    ):
+        """
+        Initialize a UnitMetricsGraph view
+
+        Args:
+            units: List of UnitMetricsGraphUnit objects containing the data
+            metrics: List of UnitMetricsGraphMetric objects defining the metrics
+            height: Height of the view in pixels
+        """
+        super().__init__(
+            extension=spike_sorting_extension,
+            view_type="spike_sorting.UnitMetricsGraph",
+        )
+        self.units = units
+        self.metrics = metrics
+        self.height = height
+
+    def _write_to_zarr_group(self, group: figpack.Group) -> None:
+        """
+        Write the UnitMetricsGraph data to a Zarr group
+
+        Args:
+            group: Zarr group to write data into
+        """
+        super()._write_to_zarr_group(group)
+
+        # Set view properties
+        if self.height is not None:
+            group.attrs["height"] = self.height
+
+        # Store metrics metadata
+        metrics_metadata = [metric.to_dict() for metric in self.metrics]
+        group.attrs["metrics"] = metrics_metadata
+
+        # Store units data in a zarr array
+        units_data = [unit.to_dict() for unit in self.units]
+        units_json = json.dumps(units_data).encode("utf-8")
+        units_array = np.frombuffer(units_json, dtype=np.uint8)
+        group.create_dataset(
+            "units_data",
+            data=units_array,
+        )
+        group.attrs["units_data_size"] = len(units_json)

figpack_spike_sorting/views/UnitSimilarityScore.py

@@ -0,0 +1,40 @@
+"""
+UnitSimilarityScore for spike sorting views
+"""
+
+from typing import Union
+
+
+class UnitSimilarityScore:
+    """
+    Represents a similarity score between two units
+    """
+
+    def __init__(
+        self,
+        *,
+        unit_id1: Union[str, int],
+        unit_id2: Union[str, int],
+        similarity: float,
+    ):
+        """
+        Initialize a UnitSimilarityScore
+
+        Args:
+            unit_id1: Identifier for the first unit
+            unit_id2: Identifier for the second unit
+            similarity: Similarity score between the units (typically 0-1)
+        """
+        self.unit_id1 = unit_id1
+        self.unit_id2 = unit_id2
+        self.similarity = similarity
+
+    def to_dict(self):
+        """
+        Convert the similarity score to a dictionary representation
+        """
+        return {
+            "unitId1": self.unit_id1,
+            "unitId2": self.unit_id2,
+            "similarity": self.similarity,
+        }

figpack_spike_sorting/views/UnitsTable.py

@@ -0,0 +1,83 @@
+"""
+UnitsTable view for figpack - displays a table of units with their properties
+"""
+
+from typing import List, Optional
+import json
+
+import numpy as np
+
+import figpack
+from ..spike_sorting_extension import spike_sorting_extension
+from .UnitSimilarityScore import UnitSimilarityScore
+from .UnitsTableColumn import UnitsTableColumn
+from .UnitsTableRow import UnitsTableRow
+
+
+class UnitsTable(figpack.ExtensionView):
+    """
+    A view that displays a table of units with their properties and optional similarity scores
+    """
+
+    def __init__(
+        self,
+        *,
+        columns: List[UnitsTableColumn],
+        rows: List[UnitsTableRow],
+        similarity_scores: Optional[List[UnitSimilarityScore]] = None,
+        height: Optional[int] = 600,
+    ):
+        """
+        Initialize a UnitsTable view
+
+        Args:
+            columns: List of UnitsTableColumn objects defining the table structure
+            rows: List of UnitsTableRow objects containing the data
+            similarity_scores: Optional list of UnitSimilarityScore objects
+            height: Height of the view in pixels
+        """
+        super().__init__(
+            extension=spike_sorting_extension, view_type="spike_sorting.UnitsTable"
+        )
+        self.columns = columns
+        self.rows = rows
+        self.similarity_scores = similarity_scores or []
+        self.height = height
+
+    def _write_to_zarr_group(self, group: figpack.Group) -> None:
+        """
+        Write the UnitsTable data to a Zarr group
+
+        Args:
+            group: Zarr group to write data into
+        """
+        super()._write_to_zarr_group(group)
+
+        # Set view properties
+        if self.height is not None:
+            group.attrs["height"] = self.height
+
+        # Store columns metadata
+        columns_metadata = [col.to_dict() for col in self.columns]
+        group.attrs["columns"] = columns_metadata
+
+        # Store rows data in a zarr array
+        rows_data = [row.to_dict() for row in self.rows]
+        rows_json = json.dumps(rows_data).encode("utf-8")
+        rows_array = np.frombuffer(rows_json, dtype=np.uint8)
+        group.create_dataset(
+            "rows_data",
+            data=rows_array,
+        )
+        group.attrs["rows_data_size"] = len(rows_json)
+
+        # Store similarity scores in a zarr array
+        if self.similarity_scores:
+            scores_data = [score.to_dict() for score in self.similarity_scores]
+            scores_json = json.dumps(scores_data).encode("utf-8")
+            scores_array = np.frombuffer(scores_json, dtype=np.uint8)
+            group.create_dataset(
+                "similarity_scores_data",
+                data=scores_array,
+            )
+            group.attrs["similarity_scores_data_size"] = len(scores_json)

figpack_spike_sorting/views/UnitsTableColumn.py

@@ -0,0 +1,40 @@
+"""
+UnitsTableColumn for spike sorting views
+"""
+
+from typing import Literal
+
+
+class UnitsTableColumn:
+    """
+    Represents a column in a units table
+    """
+
+    def __init__(
+        self,
+        *,
+        key: str,
+        label: str,
+        dtype: Literal["int", "float", "str", "bool"],
+    ):
+        """
+        Initialize a UnitsTableColumn
+
+        Args:
+            key: The key used to access values in the row data
+            label: Display label for the column
+            dtype: Data type of the column values
+        """
+        self.key = key
+        self.label = label
+        self.dtype = dtype
+
+    def to_dict(self):
+        """
+        Convert the column to a dictionary representation
+        """
+        return {
+            "key": self.key,
+            "label": self.label,
+            "dtype": self.dtype,
+        }

figpack_spike_sorting/views/UnitsTableRow.py

@@ -0,0 +1,36 @@
+"""
+UnitsTableRow for spike sorting views
+"""
+
+from typing import Any, Dict, Union
+
+
+class UnitsTableRow:
+    """
+    Represents a row in a units table
+    """
+
+    def __init__(
+        self,
+        *,
+        unit_id: Union[str, int],
+        values: Dict[str, Any],
+    ):
+        """
+        Initialize a UnitsTableRow
+
+        Args:
+            unit_id: Identifier for the unit
+            values: Dictionary of column key to value mappings
+        """
+        self.unit_id = unit_id
+        self.values = values
+
+    def to_dict(self):
+        """
+        Convert the row to a dictionary representation
+        """
+        return {
+            "unitId": self.unit_id,
+            "values": self.values,
+        }

figpack_spike_sorting/views/__init__.py

@@ -0,0 +1,43 @@
+"""
+Spike sorting views for figpack
+"""
+
+from .Autocorrelograms import Autocorrelograms
+from .AutocorrelogramItem import AutocorrelogramItem
+from .UnitsTableRow import UnitsTableRow
+from .UnitsTableColumn import UnitsTableColumn
+from .UnitsTable import UnitsTable
+from .UnitSimilarityScore import UnitSimilarityScore
+from .AverageWaveforms import AverageWaveforms, AverageWaveformItem
+from .CrossCorrelograms import CrossCorrelograms, CrossCorrelogramItem
+from .RasterPlot import RasterPlot
+from .RasterPlotItem import RasterPlotItem
+from .SpikeAmplitudes import SpikeAmplitudes, SpikeAmplitudesItem
+from .UnitLocations import UnitLocations, UnitLocationsItem
+from .UnitMetricsGraph import (
+    UnitMetricsGraph,
+    UnitMetricsGraphMetric,
+    UnitMetricsGraphUnit,
+)
+
+__all__ = [
+    "Autocorrelograms",
+    "AutocorrelogramItem",
+    "UnitsTableRow",
+    "UnitsTableColumn",
+    "UnitsTable",
+    "UnitSimilarityScore",
+    "AverageWaveforms",
+    "AverageWaveformItem",
+    "CrossCorrelograms",
+    "CrossCorrelogramItem",
+    "RasterPlot",
+    "RasterPlotItem",
+    "SpikeAmplitudes",
+    "SpikeAmplitudesItem",
+    "UnitLocations",
+    "UnitLocationsItem",
+    "UnitMetricsGraph",
+    "UnitMetricsGraphMetric",
+    "UnitMetricsGraphUnit",
+]

figpack_spike_sorting-0.1.0.dist-info/METADATA

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: figpack_spike_sorting
+Version: 0.1.0
+Summary: Spike Sorting specific extension for figpack
+Home-page: https://github.com/flatironinstitute/figpack
+Author: figpack contributors
+Author-email: 
+Keywords: visualization neuroscience electrophysiology
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: figpack>=0.2.16
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# figpack_spike_sorting
+
+Spike Sorting visualization extension for figpack.
+
+## Build
+
+```bash
+npm install
+npm run build
+pip install -e .
+```

figpack_spike_sorting-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+figpack_spike_sorting/__init__.py,sha256=Ei6xjF8UqHyp0e7rpf-L8DuYcflEMmhiyFzqLug0cRk,77
+figpack_spike_sorting/figpack_spike_sorting.js,sha256=h0H8sTZNmwOkBT-Zd9669GcZHz14HS6jCgFsFYQiuX0,776423
+figpack_spike_sorting/spike_sorting_extension.py,sha256=ugpk8hDsO4RmyQRNjfhB4Pw5p10FmhQeu3koBynSPHU,755
+figpack_spike_sorting/views/AutocorrelogramItem.py,sha256=qHmvIdHpbfVA_utPb5N2oP3hSP2cGnlT8VLaxOXV4UM,738
+figpack_spike_sorting/views/Autocorrelograms.py,sha256=zNeYM7tVXhBCaN-OWtMaIUJZUdAKh6tEidQTZ1E7N8A,3744
+figpack_spike_sorting/views/AverageWaveforms.py,sha256=tHYeURvJFyKpxpPpMc12jeQBxm9iGFzHos2G92Z0kIk,5220
+figpack_spike_sorting/views/CrossCorrelogramItem.py,sha256=uSd0i2hupteuILi_aKp7bYPYpL_PdC3CUDRMOEKUEM0,880
+figpack_spike_sorting/views/CrossCorrelograms.py,sha256=begMIpv5KG6ycH5fS85SPpXxmjZZHoIYGNcH8qBw0S0,4492
+figpack_spike_sorting/views/RasterPlot.py,sha256=MyLes4QpYs28C3IPq48-lo9_NU6cYVhO8QErgcZsy_4,9910
+figpack_spike_sorting/views/RasterPlotItem.py,sha256=iW7fuDEjSfvf5YMIwrF_6cmKvD76oCigOUMHtGgBsPI,638
+figpack_spike_sorting/views/SpikeAmplitudes.py,sha256=dH5Dpgiys8WwdhESesxnuGQsZjKDMbs8eSL1YklnsL8,13178
+figpack_spike_sorting/views/SpikeAmplitudesItem.py,sha256=j5Na-diY-vRUAPu0t0VkyFCSKFnQ_f5HT077mB3Cy8c,1134
+figpack_spike_sorting/views/UnitLocations.py,sha256=N7YRAqvtShkVcNPnLu4gIIy2HqgGco5MJRr7YLoTaL0,2338
+figpack_spike_sorting/views/UnitMetricsGraph.py,sha256=TOxqrBHrJLiOcD4-JdvgYXZYdUOm3D4nMMUayPfOAMk,3375
+figpack_spike_sorting/views/UnitSimilarityScore.py,sha256=cJA9MkETos9qHhV1tqgA7SfNEaPo-duXYCE76hSFGnA,948
+figpack_spike_sorting/views/UnitsTable.py,sha256=dNWBcdN9aSmTdNF1fNZKXLcPwweLzbYnWGhxR9q9BZI,2760
+figpack_spike_sorting/views/UnitsTableColumn.py,sha256=zBnuoeILTuiVLDvtcOxqa37E5WlbR12rlwNJUeWXxY4,847
+figpack_spike_sorting/views/UnitsTableRow.py,sha256=rEb2hMTA_pl2fTW1nOvnGir0ysfNx4uww3aekZzfWjk,720
+figpack_spike_sorting/views/__init__.py,sha256=32LVR983RlvbGblG2akBJuj4ZEIvVgqmap5OoJAAALA,1248
+figpack_spike_sorting-0.1.0.dist-info/METADATA,sha256=14vVVeTQBDe0umcZHzEu3e4iaXtowK9w2N5mUA4JogQ,1218
+figpack_spike_sorting-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+figpack_spike_sorting-0.1.0.dist-info/top_level.txt,sha256=CAkWrQc1wGK5laYDkT2GBjGgAuNwWNXKodTQlTcpxus,22
+figpack_spike_sorting-0.1.0.dist-info/RECORD,,

figpack_spike_sorting-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

figpack_spike_sorting-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+figpack_spike_sorting