siibra 1.0a14__py3-none-any.whl → 1.0.1a0__py3-none-any.whl

siibra/volumes/volume.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2023
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,10 +19,11 @@ from .providers import provider as _provider
 from .. import logger
 from ..retrieval import requests
 from ..core import space as _space, structure
-from ..locations import location, point, pointset, boundingbox
-from ..commons import resample_img_to_img, siibra_tqdm
-from ..exceptions import NoMapAvailableError, SpaceWarpingFailedError
+from ..locations import point, pointcloud, boundingbox
+from ..commons import resample_img_to_img, siibra_tqdm, affine_scaling, connected_components
+from ..exceptions import NoMapAvailableError, SpaceWarpingFailedError, EmptyPointCloudError
 
+from dataclasses import dataclass
 from nibabel import Nifti1Image
 import numpy as np
 from typing import List, Dict, Union, Set, TYPE_CHECKING
@@ -36,7 +37,62 @@ if TYPE_CHECKING:
     TypeDataset = EbrainsDataset
 
 
-class Volume(location.Location):
+@dataclass
+class ComponentSpatialProperties:
+    """
+    Centroid and nonzero volume of an image.
+    """
+    centroid: point.Point
+    volume: int
+
+    @staticmethod
+    def compute_from_image(
+        img: Nifti1Image,
+        space: Union[str, "_space.Space"],
+        split_components: bool = True
+
+    ) -> List["ComponentSpatialProperties"]:
+        """
+        Find the center of an image in its (non-zero) voxel space and and its
+        volume.
+
+        Parameters
+        ----------
+        img: Nifti1Image
+        space: str, Space
+        split_components: bool, default: True
+            If True, finds the spatial properties for each connected component
+            found by skimage.measure.label.
+        """
+        scale = affine_scaling(img.affine)
+        if split_components:
+            iter_components = lambda img: connected_components(
+                np.asanyarray(img.dataobj),
+                connectivity=None
+            )
+        else:
+            iter_components = lambda img: [(0, np.asanyarray(img.dataobj))]
+
+        spatial_props: List[ComponentSpatialProperties] = []
+        for _, component in iter_components(img):
+            nonzero: np.ndarray = np.c_[np.nonzero(component)]
+            spatial_props.append(
+                ComponentSpatialProperties(
+                    centroid=point.Point(
+                        np.dot(img.affine, np.r_[nonzero.mean(0), 1])[:3],
+                        space=space
+                    ),
+                    volume=nonzero.shape[0] * scale,
+                )
+            )
+
+        # sort by volume
+        spatial_props.sort(key=lambda cmp: cmp.volume, reverse=True)
+
+        return spatial_props
+
+
+class Volume(structure.BrainStructure):
     """
     A volume is a specific mesh or 3D array,
     which can be accessible via multiple providers in different formats.
@@ -77,12 +133,14 @@ class Volume(location.Location):
         name: str = "",
         variant: str = None,
         datasets: List['TypeDataset'] = [],
+        bbox: "boundingbox.BoundingBox" = None
     ):
         self._name = name
         self._space_spec = space_spec
         self.variant = variant
         self._providers: Dict[str, _provider.VolumeProvider] = {}
         self.datasets = datasets
+        self._boundingbox = bbox
         for provider in providers:
             srctype = provider.srctype
             assert srctype not in self._providers
@@ -142,6 +200,22 @@ class Volume(location.Location):
         RuntimeError
             If the volume provider does not have a bounding box calculator.
         """
+        if self._boundingbox is not None and len(fetch_kwargs) == 0:
+            return self._boundingbox
+
+        if not self.provides_image:
+            raise NotImplementedError("Bounding box calculation of meshes is not implemented yet.")
+
+        if clip:  # clippin requires fetching the image
+            img = self.fetch(**fetch_kwargs)
+            assert isinstance(img, Nifti1Image)
+            return boundingbox.from_array(
+                array=np.asanyarray(img.dataobj),
+                background=background,
+            ).transform(img.affine, space=self.space)
+
+        # if clipping is not required, providers migth have methods of creating
+        # bounding boxes without fetching the image
         fmt = fetch_kwargs.get("format")
         if (fmt is not None) and (fmt not in self.formats):
             raise ValueError(
@@ -151,15 +225,15 @@ class Volume(location.Location):
         providers = [self._providers[fmt]] if fmt else self._providers.values()
         for provider in providers:
             try:
+                assert clip is False
                 bbox = provider.get_boundingbox(
-                    clip=clip, background=background, **fetch_kwargs
+                    background=background, **fetch_kwargs
                 )
-                if bbox.space is None:  # provider does usually not know the space!
+                if bbox.space is None:  # provider do not know the space!
                     bbox._space_cached = self.space
                     bbox.minpoint._space_cached = self.space
                     bbox.maxpoint._space_cached = self.space
-            except NotImplementedError as e:
-                logger.info(e)
+            except NotImplementedError:
                 continue
             return bbox
         raise RuntimeError(f"No bounding box specified by any volume provider of {str(self)}")
@@ -214,7 +288,7 @@ class Volume(location.Location):
 
     def evaluate_points(
         self,
-        points: Union['point.Point', 'pointset.PointSet'],
+        points: Union['point.Point', 'pointcloud.PointCloud'],
         outside_value: Union[int, float] = 0,
         **fetch_kwargs
     ) -> np.ndarray:
@@ -233,7 +307,7 @@ class Volume(location.Location):
 
         Parameters
         ----------
-        points: PointSet
+        points: PointCloud
         outside_value: int, float. Default: 0
         fetch_kwargs: dict
             Any additional arguments are passed to the `fetch()` call for
@@ -253,9 +327,8 @@ class Volume(location.Location):
             raise NotImplementedError("Filtering of points by pure mesh volumes not yet implemented.")
 
         # make sure the points are in the same physical space as this volume
-        warped = (
-            pointset.from_points([points]) if isinstance(points, point.Point) else points
-        ).warp(self.space)
+        as_pointcloud = pointcloud.from_points([points]) if isinstance(points, point.Point) else points
+        warped = as_pointcloud.warp(self.space)
         assert warped is not None, SpaceWarpingFailedError
 
         # get the voxel array of this volume
@@ -282,57 +355,50 @@ class Volume(location.Location):
 
     def _points_inside(
         self,
-        points: Union['point.Point', 'pointset.PointSet'],
+        points: Union['point.Point', 'pointcloud.PointCloud'],
         keep_labels: bool = True,
         outside_value: Union[int, float] = 0,
         **fetch_kwargs
-    ) -> 'pointset.PointSet':
+    ) -> 'pointcloud.PointCloud':
         """
-        Reduce a pointset to the points which fall inside nonzero pixels of
+        Reduce a pointcloud to the points which fall inside nonzero pixels of
         this map.
 
 
         Paramaters
         ----------
-        points: PointSet
+        points: PointCloud
         keep_labels: bool
-            If False, the returned PointSet will be labeled with their indices
-            in the original PointSet.
+            If False, the returned PointCloud will be labeled with their indices
+            in the original PointCloud.
         fetch_kwargs: dict
             Any additional arguments are passed to the `fetch()` call for
             retrieving the image data.
 
         Returns
         -------
-        PointSet
-            A new PointSet containing only the points inside the volume.
+        PointCloud
+            A new PointCloud containing only the points inside the volume.
             Labels reflect the indices of the original points if `keep_labels`
             is False.
         """
-        ptset = pointset.from_points([points]) if isinstance(points, point.Point) else points
+        ptset = pointcloud.from_points([points]) if isinstance(points, point.Point) else points
         values = self.evaluate_points(ptset, outside_value=outside_value, **fetch_kwargs)
         inside = list(np.where(values != outside_value)[0])
-        return pointset.from_points(
+        return pointcloud.from_points(
             [ptset[i] for i in inside],
             newlabels=None if keep_labels else inside
         )
 
-    def union(self, other: location.Location):
-        if isinstance(other, Volume):
-            return merge([self, other])
-        else:
-            raise NotImplementedError(
-                f"There are no union method for {(self.__class__.__name__, other.__class__.__name__)}"
-            )
-
     def intersection(self, other: structure.BrainStructure, **fetch_kwargs) -> structure.BrainStructure:
         """
         Compute the intersection of a location with this volume. This will
         fetch actual image data. Any additional arguments are passed to fetch.
         """
-        if isinstance(other, (pointset.PointSet, point.Point)):
-            points_inside = self._points_inside(other, keep_labels=False, **fetch_kwargs)
-            if len(points_inside) == 0:
+        if isinstance(other, (pointcloud.PointCloud, point.Point)):
+            try:
+                points_inside = self._points_inside(other, keep_labels=False, **fetch_kwargs)
+            except EmptyPointCloudError:
                 return None  # BrainStructure.intersects checks for not None
             if isinstance(other, point.Point):  # preserve the type
                 return points_inside[0]
@@ -340,6 +406,8 @@ class Volume(location.Location):
         elif isinstance(other, boundingbox.BoundingBox):
             return self.get_boundingbox(clip=True, background=0.0, **fetch_kwargs).intersection(other)
         elif isinstance(other, Volume):
+            if self.space != other.space:
+                raise NotImplementedError("Cannot intersect volumes from different spaces. Try comparing their boudning boxes.")
             format = fetch_kwargs.pop('format', 'image')
             v1 = self.fetch(format=format, **fetch_kwargs)
             v2 = other.fetch(format=format, **fetch_kwargs)
@@ -361,15 +429,6 @@ class Volume(location.Location):
             except NoMapAvailableError:
                 return None
 
-    def transform(self, affine: np.ndarray, space=None):
-        raise NotImplementedError("Volume transformation is not yet implemented.")
-
-    def warp(self, space):
-        if self.space.matches(space):
-            return self
-        else:
-            raise SpaceWarpingFailedError('Warping of full volumes is not yet supported.')
-
     def fetch(
         self,
         format: str = None,
@@ -416,6 +475,20 @@ class Volume(location.Location):
                 f"volume are: {self.formats}"
             )
 
+        # ensure the voi is inside the template
+        voi = kwargs.get("voi", None)
+        if voi is not None and voi.space is not None:
+            assert isinstance(voi, boundingbox.BoundingBox)
+            tmplt_bbox = voi.space.get_template().get_boundingbox(clip=False)
+            intersection_bbox = voi.intersection(tmplt_bbox)
+            if intersection_bbox is None:
+                raise RuntimeError(f"voi provided ({voi}) lies out side the voxel space of the {voi.space.name} template.")
+            if intersection_bbox != voi:
+                logger.info(
+                    f"Since provided voi lies outside the template ({voi.space}) it is clipped as: {intersection_bbox}"
+                )
+                kwargs["voi"] = intersection_bbox
+
         result = None
         # try each possible format
         for fmt in possible_formats:
@@ -460,19 +533,37 @@ class Volume(location.Location):
 
         return self._FETCH_CACHE[fetch_hash]
 
-    def fetch_connected_components(self, **kwargs):
+    def fetch_connected_components(self, **fetch_kwargs):
         """
-        Provide an iterator over masks of connected components in the volume
+        Provide an generator over masks of connected components in the volume
         """
-        img = self.fetch(**kwargs)
-        from skimage import measure
-        imgdata = np.asanyarray(img.dataobj).squeeze()
-        components = measure.label(imgdata > 0)
-        component_labels = np.unique(components)
-        assert component_labels[0] == 0
-        return (
-            (label, Nifti1Image((components == label).astype('uint8'), img.affine))
-            for label in component_labels[1:]
+        img = self.fetch(**fetch_kwargs)
+        assert isinstance(img, Nifti1Image), NotImplementedError(
+            f"Connected components for type {type(img)} is not yet implemeneted."
+        )
+        for label, component in connected_components(np.asanyarray(img.dataobj)):
+            yield (
+                label,
+                Nifti1Image(component, img.affine)
+            )
+
+    def compute_spatial_props(self, split_components: bool = True, **fetch_kwargs) -> List[ComponentSpatialProperties]:
+        """
+        Find the center of this volume in its (non-zero) voxel space and and its
+        volume.
+
+        Parameters
+        ----------
+        split_components: bool, default: True
+            If True, finds the spatial properties for each connected component
+            found by skimage.measure.label.
+        """
+        assert self.provides_image, NotImplementedError("Spatial properties can currently on be calculated for images.")
+        img = self.fetch(format=fetch_kwargs.pop("format", "image"), **fetch_kwargs)
+        return ComponentSpatialProperties.compute_from_image(
+            img=img,
+            space=self.space,
+            split_components=split_components
         )
 
     def draw_samples(self, N: int, sample_size: int = 100, e: float = 1, sigma_mm=None, invert=False, **kwargs):
@@ -502,7 +593,7 @@ class Volume(location.Location):
             samples.extend(list(pts[inside, :][choice, :]))
             if len(samples) > N:
                 break
-        voxels = pointset.PointSet(
+        voxels = pointcloud.PointCloud(
             np.random.permutation(samples)[:N, :],
             space=None
         )
@@ -523,11 +614,96 @@ class Volume(location.Location):
         img = self.fetch(**kwargs)
         array = np.asanyarray(img.dataobj)
         voxels = skimage_feature.peak_local_max(array, min_distance=mindist)
-        points = pointset.PointSet(voxels, space=None, labels=list(range(len(voxels)))).transform(img.affine, space=self.space)
+        points = pointcloud.PointCloud(voxels, space=None, labels=list(range(len(voxels)))).transform(img.affine, space=self.space)
         points.sigma_mm = [sigma_mm for _ in points]
         return points
 
 
+class FilteredVolume(Volume):
+
+    def __init__(
+        self,
+        parent_volume: Volume,
+        label: int = None,
+        fragment: str = None,
+        threshold: float = None,
+    ):
+        """
+        A prescribed Volume to fetch specified label and fragment.
+        If threshold is defined, a mask of the values above the threshold.
+
+        Parameters
+        ----------
+        parent_volume : Volume
+        label : int, default: None
+            Get the mask of value equal to label.
+        fragment : str, default None
+            If a volume is fragmented, get a specified one.
+        threshold : float, default None
+            Provide a float value to threshold the image.
+        """
+        name = parent_volume.name
+        if label:
+            name += f" - label: {label}"
+        if fragment:
+            name += f" - fragment: {fragment}"
+        if threshold:
+            name += f" - threshold: {threshold}"
+        Volume.__init__(
+            self,
+            space_spec=parent_volume._space_spec,
+            providers=list(parent_volume._providers.values()),
+            name=name
+        )
+        self.fragment = fragment
+        self.label = label
+        self.threshold = threshold
+
+    def fetch(
+        self,
+        format: str = None,
+        **kwargs
+    ):
+        if "fragment" in kwargs:
+            assert kwargs.get("fragment") == self.fragment, f"This is a filtered volume that can only fetch fragment '{self.fragment}'."
+        else:
+            kwargs["fragment"] = self.fragment
+        if "label" in kwargs:
+            assert kwargs.get("label") == self.label, f"This is a filtered volume that can only fetch label '{self.label}' only."
+        else:
+            kwargs["label"] = self.label
+
+        result = super().fetch(format=format, **kwargs)
+
+        if self.threshold is not None:
+            assert self.label is None
+            if not isinstance(result, Nifti1Image):
+                raise NotImplementedError("Cannot threshold meshes.")
+            imgdata = np.asanyarray(result.dataobj)
+            return Nifti1Image(
+                dataobj=(imgdata > self.threshold).astype("uint8"),
+                affine=result.affine,
+                dtype="uint8"
+            )
+
+        return result
+
+    def get_boundingbox(
+        self,
+        clip: bool = True,
+        background: float = 0.0,
+        **fetch_kwargs
+    ) -> "boundingbox.BoundingBox":
+        # NOTE: since some providers enable different simpllified ways to create a
+        # bounding box without fetching the image, the correct kwargs must be
+        # forwarded since FilteredVolumes enforce their specs to be fetched.
+        return super().get_boundingbox(
+            clip=clip,
+            background=background,
+            **fetch_kwargs
+        )
+
+
 class Subvolume(Volume):
     """
     Wrapper class for exposing a z level of a 4D volume to be used like a 3D volume.
@@ -540,7 +716,8 @@ class Subvolume(Volume):
             providers=[
                 _provider.SubvolumeProvider(p, z=z)
                 for p in parent_volume._providers.values()
-            ]
+            ],
+            name=parent_volume.name + f" - z: {z}"
         )
 
 
@@ -588,8 +765,8 @@ def from_array(
     )
 
 
-def from_pointset(
-    points: pointset.PointSet,
+def from_pointcloud(
+    points: pointcloud.PointCloud,
     label: int = None,
     target: Volume = None,
     normalize=True,
@@ -601,7 +778,7 @@ def from_pointset(
 
     Parameters
     ----------
-    points: pointset.PointSet
+    points: pointcloud.PointCloud
     label: int, default: None
         If None, finds the KDE for all points. Otherwise, selects the points
         labelled with this integer value.
@@ -633,11 +810,11 @@ def from_pointset(
     )
     voxelcount_img[tuple(unique_coords.T)] = counts
 
-    # TODO: consider how to handle pointsets with varied sigma_mm
+    # TODO: consider how to handle pointclouds with varied sigma_mm
     sigmas = np.array(points.sigma_mm)[selection]
     bandwidth = np.mean(sigmas)
     if len(np.unique(sigmas)) > 1:
-        logger.warning(f"KDE of pointset uses average bandwith {bandwidth} instead of the points' individual sigmas.")
+        logger.warning(f"KDE of pointcloud uses average bandwith {bandwidth} instead of the points' individual sigmas.")
 
     filtered_arr = filters.gaussian(voxelcount_img, bandwidth)
     if normalize:
@@ -653,7 +830,7 @@ def from_pointset(
 
 def merge(volumes: List[Volume], labels: List[int] = [], **fetch_kwargs) -> Volume:
     """
-    Merge a list of volumes in the same space into a single volume.
+    Merge a list of nifti volumes in the same space into a single volume.
 
     Note
     ----
@@ -670,6 +847,10 @@ def merge(volumes: List[Volume], labels: List[int] = [], **fetch_kwargs) -> Volu
     -------
     Volume
     """
+    if len(volumes) == 1:
+        logger.debug("Only one volume supplied returning as is (kwargs are ignored).")
+        return volumes[0]
+
     assert len(volumes) > 1, "Need to supply at least two volumes to merge."
     if labels:
         assert len(volumes) == len(labels), "Need to supply as many labels as volumes."
@@ -677,8 +858,14 @@ def merge(volumes: List[Volume], labels: List[int] = [], **fetch_kwargs) -> Volu
     space = volumes[0].space
     assert all(v.space == space for v in volumes), "Cannot merge volumes from different spaces."
 
+    if len(labels) > 0:
+        dtype = 'int32'
+    elif FilteredVolume in {type(v) for v in volumes}:
+        dtype = 'uint8'
+    else:
+        dtype = volumes[0].fetch().dataobj.dtype
     template_img = space.get_template().fetch(**fetch_kwargs)
-    merged_array = np.zeros(template_img.shape, dtype='uint8')
+    merged_array = np.zeros(template_img.shape, dtype=dtype)
 
     for i, vol in siibra_tqdm(
         enumerate(volumes),

{siibra-1.0a14.dist-info → siibra-1.0.1a0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: siibra
-Version: 1.0a14
+Version: 1.0.1a0
 Summary: siibra - Software interfaces for interacting with brain atlases
 Home-page: https://github.com/FZJ-INM1-BDA/siibra-python
 Author: Big Data Analytics Group, Forschungszentrum Juelich, Institute of Neuroscience and Medicine (INM-1)
@@ -24,9 +24,9 @@ Requires-Dist: scikit-image
 Requires-Dist: requests
 Requires-Dist: neuroglancer-scripts
 Requires-Dist: nilearn
+Requires-Dist: typing-extensions; python_version < "3.8"
 Requires-Dist: filelock
-Requires-Dist: ebrains-drive >=0.6.0
-Requires-Dist: typing-extensions ; python_version < "3.8"
+Requires-Dist: ebrains-drive>=0.6.0
 
 |License| |PyPI version| |doi| |Python versions| |Documentation Status|
 
@@ -34,7 +34,7 @@ Requires-Dist: typing-extensions ; python_version < "3.8"
 siibra - Software interface for interacting with brain atlases
 ==============================================================
 
-Copyright 2020-2023, Forschungszentrum Jülich GmbH
+Copyright 2020-2024, Forschungszentrum Jülich GmbH
 
 *Authors: Big Data Analytics Group, Institute of Neuroscience and
 Medicine (INM-1), Forschungszentrum Jülich GmbH*
@@ -145,3 +145,16 @@ https://doi.org/10.5281/zenodo.7885728`.
    :target: https://siibra-python.readthedocs.io/en/latest/?badge=latest
 .. |doi| image:: https://zenodo.org/badge/DOI/10.5281/zenodo.7885728.svg
    :target: https://doi.org/10.5281/zenodo.7885728
+
+
+Versioning
+==========
+Given a version number MAJOR.MINOR.PATCH, increments imply:
+   - MAJOR: incompatible API changes
+   - MINOR: a functionality in a backward compatible manner is added
+   - PATCH: backward compatible bug fixes and new configuration added such as new maps or features
+
+Pre-release
+-----------
+For x.y.z, a full release,
+- `x.y.z-alpha.t` is the development prerelease. By changing `t`, different siibra-configurations are targeted.

siibra-1.0.1a0.dist-info/RECORD

@@ -0,0 +1,84 @@
+siibra/VERSION,sha256=obkBMWS4uPgy0Q8o6UWN0GqfjWFwM9_DzViNq5cAX98,14
+siibra/__init__.py,sha256=odym0KtWXn55LqBXZDRgXCzSd5daKXrC0D6lSeYi3po,4715
+siibra/commons.py,sha256=L0tEiZycG0GyDo-KxTeEs8abfTZC98VR_xsDRDdWWNQ,27561
+siibra/exceptions.py,sha256=ruU9IGFBqD52mXUryBF41uE6mDV3kabfSAzUunhCWR8,1319
+siibra/configuration/__init__.py,sha256=Kp00hs44rVSU5OPuZ26KFJpd6HXtMocEiLiZihdvav4,752
+siibra/configuration/configuration.py,sha256=um31WGN0Ozl-3v5bUYECkJEJ5GMrEnrJO3_syUXgzFc,7263
+siibra/configuration/factory.py,sha256=8PoPydqc_4csKF8f-E7Un1QnQ0yKDRgYyO1jbVhKeQU,22627
+siibra/core/__init__.py,sha256=907tEZ3HxZSZqqhv0md3Sk8t9iy0-aWtbuo1G1oxN_w,735
+siibra/core/assignment.py,sha256=9g2lLOj_ftuS623ZlVauTTLtJGAvDfE10wknJXJA7m4,3819
+siibra/core/atlas.py,sha256=BNp96YZ3s6f5MrnuEWL8OktFtM528Dj9Zv6e9FbOAyg,8549
+siibra/core/concept.py,sha256=cmWR2PFdWR3pdVa0NSOiPC-EWl0i_WBjyF3JjKt74gc,10889
+siibra/core/parcellation.py,sha256=AF7yODxdhZZymFNzQdaL2qzSDwkgsogPs74e603Zl_Q,14506
+siibra/core/region.py,sha256=6UDx31FmFYtFQJs5Z0fbpQ2yT9MCh4QCCANIa5GxTXQ,43423
+siibra/core/space.py,sha256=0v_7aERZcVNPJmbr_LbeLRkbJj8TGaTrbqnXzr-I5Jg,4586
+siibra/core/structure.py,sha256=eHvCRBZEDjTI8xc2UmSgt26ujgDxHTLai8NoGmeUU64,4497
+siibra/experimental/__init__.py,sha256=s4bEYpMO4Ox-Xlx3FdnRUNKYs0mTHz5Hu4VnfNXpgxU,791
+siibra/experimental/contour.py,sha256=uZOltesITk5t7EbohZtqA8gJRc3UuiqpJdJQhFP1gXo,2454
+siibra/experimental/cortical_profile_sampler.py,sha256=JsX0FCJqvozdhWuayYJ-r3kHNsgSUfA00O9D0X6D7Rg,2086
+siibra/experimental/patch.py,sha256=0VKVU7F7xMBr1hwtL-Z4K-_1XKw88WImPG4fWaiH5bw,3809
+siibra/experimental/plane3d.py,sha256=XgmNemO9peDRDtHE_8joqroGpjCKI5H_vzyIFXDh434,10853
+siibra/explorer/__init__.py,sha256=ZEBJlKs3r5tFWWoKvfrASb1M031FPwSVeysaktUnhbQ,781
+siibra/explorer/url.py,sha256=1UWJyt18gMKTXuixfO8P1Xa5SJDUUagollow67VYT20,7068
+siibra/explorer/util.py,sha256=lAy1pd-ym90H-BZx2X8GMT3qJIsRTgGCz6tW3t1duig,2083
+siibra/features/__init__.py,sha256=NMmDmfrzscV-RHHZMoyjlH_bYfjNhGDX72dQ6-JCYXg,3970
+siibra/features/anchor.py,sha256=FfeMfJxwApFE0iWo2RJj5_XFr0L5gF76V4ZxaPL2VUc,9130
+siibra/features/feature.py,sha256=ls1E7BjRdPOkbtwzU-d01lwTRA_33IlzB44-tL0tg2g,35194
+siibra/features/connectivity/__init__.py,sha256=A7fcXqlAtfFmuymfyOl7A7ecaP8nqIBPFaM76qwh4HA,1161
+siibra/features/connectivity/functional_connectivity.py,sha256=3UiPpHfbYAOBwMn7TI79wy1fR9lWwI3ePMSRVziJONw,2122
+siibra/features/connectivity/regional_connectivity.py,sha256=13uZ-TJBv_J3J-6KuJcKmJMKf7yWy21pzdsyvcWkWXg,18287
+siibra/features/connectivity/streamline_counts.py,sha256=OBOQblhsqnfsvf2kdySRAoWxGsFi4Ulr2PNT9wOu1Ls,1064
+siibra/features/connectivity/streamline_lengths.py,sha256=B9D6Y7szMRCuHRwisAorgTJfkq-1aTNB08H_HVZHpJs,1067
+siibra/features/connectivity/tracing_connectivity.py,sha256=JehDrEEeYl_i-T81AE_AnamlKfzHkZ3nbheRAybFn24,1083
+siibra/features/dataset/__init__.py,sha256=KlHddELER_5IQ-xQ1xx5ExcEtqXWI8gpNvzGlC2on-Y,748
+siibra/features/dataset/ebrains.py,sha256=G3-jWGBMLyJm3X8g8vTVtXN2Kws3JZ7zIEDkO9jwWxc,2544
+siibra/features/image/__init__.py,sha256=HZ5LdR6DzkkkgsftTu314-DAMMLdf6Sfg6ceYVzYjas,1013
+siibra/features/image/image.py,sha256=QtFtXBt4rRkFq6AHeUOaQSCOjgBygIJ7lhz1gjsQ4c4,3585
+siibra/features/image/sections.py,sha256=oQparLp7Nj5dLBvUAs09rgnSgAxH86wN1SMmwkit0S0,961
+siibra/features/image/volume_of_interest.py,sha256=FuYxt-r6YOWN4tLaaZPL3_GAvX_WcZz3jRHxEnWySnQ,2654
+siibra/features/tabular/__init__.py,sha256=sldsgKiwpGOk5PvntIO16lJlWiTy68qVI_pLhepqbdI,1176
+siibra/features/tabular/bigbrain_intensity_profile.py,sha256=noXtsmQjW75epnpfHex0VAbvz7QLwvlkTn_PLSwASIQ,2708
+siibra/features/tabular/cell_density_profile.py,sha256=W1GtrOCacankczxpkz2V3n9zJyf2WCW3W_BpYrEc6yk,10820
+siibra/features/tabular/cortical_profile.py,sha256=I3MFsytAjvi6A2GaMhgXnF9-94LnAScIo_GR-HMEAv0,12540
+siibra/features/tabular/gene_expression.py,sha256=GbXmsdHCz8eFErTLUd6DXhQaeObftrwl9aIEgzlEdXA,9827
+siibra/features/tabular/layerwise_bigbrain_intensities.py,sha256=GIYjX7_Bfs7ywhJBkXd878BZGSiaKUV0BhILr-6D4zc,2117
+siibra/features/tabular/layerwise_cell_density.py,sha256=V8c16KdBACUYFxMYh1T9tdlXs_V67iFAZqlYx7y_4RY,3783
+siibra/features/tabular/receptor_density_fingerprint.py,sha256=GudVpZ2wWF1yGsDFKz4AEU761qA45rItLOwHYpY4Zcs,7299
+siibra/features/tabular/receptor_density_profile.py,sha256=ZYgL-3WxevVFtmEQSbR8Ot24VCMg5xzfXYEPBH1oM6k,3725
+siibra/features/tabular/regional_timeseries_activity.py,sha256=vfoEIu92l3wVdUbdnNqZ5nr9oBuahOrIGS5xhA8cW7s,10026
+siibra/features/tabular/tabular.py,sha256=NoNexdPJ3nhSsztWdWnnIHcX6PakcjEAOV-f9azqa-s,5323
+siibra/livequeries/__init__.py,sha256=yZ2bFYizwF_Z3F9VLNI95IrHcmSO5lqfFML_juifVHs,875
+siibra/livequeries/allen.py,sha256=2jj1gMr9mZFaOfRSf9lPzrcRLAoAMuWjvT_N3_KUkHI,14809
+siibra/livequeries/bigbrain.py,sha256=V7yRQIx6VLIkA9fwW6PfEw7kSkrwp3oE_-WYXe3bjMk,8365
+siibra/livequeries/ebrains.py,sha256=nAIhyPlVeRPNmmMKkGATUSDRoGK7aAg8zOGEKuS-z_w,5820
+siibra/livequeries/query.py,sha256=Yh24vRdcSYBTNx61sMoRCyXyNZ7TX1iqoiJ8fxOJ3V8,1849
+siibra/locations/__init__.py,sha256=q97HYl9mdBWNuQKvgh1Wi0eAz1TlG_dLSIxpyJuHCZo,3342
+siibra/locations/boundingbox.py,sha256=pdLZNyxUD-WvGHNYOvuqZtputCd5tPOxLYTvH6oBBNg,16492
+siibra/locations/location.py,sha256=Taw7oUIFBdXTE8C3b2vbGicPusJlad_KI1wW6iLL324,4361
+siibra/locations/point.py,sha256=wmtH0Isx1-bsk3TfNxXHFcYUmbsQXBt34l8LpFWxhHU,12863
+siibra/locations/pointcloud.py,sha256=61sUvXw5dtKouNKinQNwgGOFd7iwgJLf4D4zYNWo7Js,12474
+siibra/retrieval/__init__.py,sha256=bgoasCN6LFDlKVFCJC0q4kfGMZCsxt_NVCcJ5qy0sIo,1062
+siibra/retrieval/cache.py,sha256=kVB-hYtvQIQmlCozKlYJPaQxgtCKWOS3jB2qqefCVNc,7832
+siibra/retrieval/datasets.py,sha256=Hjai2cSFK1WoMgXp4uMJWBUqlO_APLQ_iDQ__8EpKEI,11031
+siibra/retrieval/repositories.py,sha256=L-JrEuKF6Xq7sEIdJ3iPFQPWaf5CiHMt96X1zi-gOVM,29936
+siibra/retrieval/requests.py,sha256=oup12LGw-MnSc7c3IwlX9Z5TrVXzCCRfGZFLLLR4jAs,23069
+siibra/retrieval/exceptions/__init__.py,sha256=CEY_n-Eh0_EBXYHDPxmIXzO6C_Km0WQFvENAMvRXmYg,875
+siibra/vocabularies/__init__.py,sha256=Qn_xBKrFhla7d_PjDgN6gX4gxroeSRP3ntBZ6gNnvtE,1288
+siibra/vocabularies/gene_names.json,sha256=i-gnh753GyZtQfX_dWibNYr_d5ccDPHooOwsdeKUYqE,1647972
+siibra/vocabularies/receptor_symbols.json,sha256=F6DZIArPCBmJV_lWGV-zDpBBH_GOJOZm67LBE4qzMa4,5722
+siibra/vocabularies/region_aliases.json,sha256=T2w1wRlxPNTsPppXn0bzC70tNsb8mOjLsoHuxDSYm2w,8563
+siibra/volumes/__init__.py,sha256=j7h6WNQk2juIyxs2OlruWj5VcKxsy1g-wD2Q05rM-wM,935
+siibra/volumes/parcellationmap.py,sha256=lgqVjwHdmjmKj_2PguAH4jda3dc-L0p0QzfQ9emPJRg,49774
+siibra/volumes/sparsemap.py,sha256=ZHkHh7NNEPZzRE2-XGWWPRaVVL2V4voYYzYdZ7RCxRg,17437
+siibra/volumes/volume.py,sha256=-ULibtP5MCy0a3tHqbeFweIUP7sLZGuhj6eW558BRlM,32619
+siibra/volumes/providers/__init__.py,sha256=0uDbnsjlAHnxoSdFghzYfhtjVki9721hi7Sp1P6GjNY,934
+siibra/volumes/providers/freesurfer.py,sha256=LxPHbfVJLXkP4WVXCYhsildRUZUvzgv6jJOWeNLavw8,4893
+siibra/volumes/providers/gifti.py,sha256=mPVFkBFnwbCbMks_ysuNbhe0Pj5ndxONPmq-Xr-ir3w,6231
+siibra/volumes/providers/neuroglancer.py,sha256=JH8z6jb7u6nkqtNR3ZFYPrtwexAS6z68pesrLA2lYrk,28712
+siibra/volumes/providers/nifti.py,sha256=AXhWvbt78uEvIT6Z8ABWZ6k0zYUEWZKniSxfLAqDE3k,10135
+siibra/volumes/providers/provider.py,sha256=jxhOGHrSEeBgN0tAi7p8ju3twtUkhkjrk-e-3-chtxI,3695
+siibra-1.0.1a0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+siibra-1.0.1a0.dist-info/METADATA,sha256=jY1qR1aP2er68Kb1URFJ-bE4i8ZXYj8wlLviXdlkxlI,8884
+siibra-1.0.1a0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+siibra-1.0.1a0.dist-info/top_level.txt,sha256=NF0OSGLL0li2qyC7MaU0iBB5Y9S09_euPpvisD0-8Hg,7
+siibra-1.0.1a0.dist-info/RECORD,,

{siibra-1.0a14.dist-info → siibra-1.0.1a0.dist-info}/WHEEL

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