siibra 1.0.1a1__py3-none-any.whl → 1.0.1a2__py3-none-any.whl

siibra/volumes/parcellationmap.py

@@ -14,9 +14,18 @@
 # limitations under the License.
 """Provides spatial representations for parcellations and regions."""
 
+from collections import defaultdict
+from dataclasses import dataclass, asdict
+from typing import Union, Dict, List, TYPE_CHECKING, Iterable, Tuple
+
+import numpy as np
+import pandas as pd
+from scipy.ndimage import distance_transform_edt
+from nilearn import image
+
 from . import volume as _volume
 from .providers import provider
-from .. import logger, QUIET, exceptions
+from .. import exceptions
 from ..commons import (
     MapIndex,
     MapType,
@@ -29,19 +38,13 @@ from ..commons import (
     siibra_tqdm,
     Species,
     CompareMapsResult,
-    generate_uuid
+    generate_uuid,
+    logger,
+    QUIET,
 )
 from ..core import concept, space, parcellation, region as _region
 from ..locations import location, point, pointcloud
 
-import numpy as np
-from typing import Union, Dict, List, TYPE_CHECKING, Iterable, Tuple
-from scipy.ndimage import distance_transform_edt
-from collections import defaultdict
-from nilearn import image
-import pandas as pd
-from dataclasses import dataclass, asdict
-
 if TYPE_CHECKING:
     from ..core.region import Region
 
@@ -690,7 +693,7 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
             name=f"Custom colorization of {self}"
         )
 
-    def get_colormap(self, region_specs: Iterable = None, *, allow_random_colors: bool = False):
+    def get_colormap(self, region_specs: Iterable = None, *, fill_uncolored: bool = False):
         """
         Generate a matplotlib colormap from known rgb values of label indices.
 
@@ -698,7 +701,8 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
         ----------
         region_specs: iterable(regions), optional
             Optional parameter to only color the desired regions.
-        allow_random_colors: bool , optional
+        fill_uncolored: bool , optional
+            If a region has no preconfigured color, a color will be randomly (reproducible) created.
 
         Returns
         -------
@@ -711,10 +715,10 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
                 "matplotlib not available. Please install matplotlib to create a matplotlib colormap."
             )
             raise e
-        if allow_random_colors:
+        if fill_uncolored:
             seed = len(self.regions)
             np.random.seed(seed)
-            logger.info(f"Random colors are allowed for regions without preconfgirued colors. Random seee: {seed}.")
+            logger.info(f"Random colors are allowed for regions without preconfgirued colors. Random seed: {seed}.")
 
         colors = {}
         if region_specs is not None:
@@ -724,6 +728,7 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
         else:
             include_region_names = None
 
+        no_predefined_color = []
         for regionname, indices in self._indices.items():
             for index in indices:
                 if index.label is None:
@@ -735,16 +740,25 @@ class Map(concept.AtlasConcept, configuration_folder="maps"):
                     region = self.get_region(index=index)
                     if region.rgb is not None:
                         colors[index.label] = region.rgb
-                    elif allow_random_colors:
+                    elif fill_uncolored:
                         random_clr = [np.random.randint(0, 255) for r in range(3)]
                         while random_clr in list(colors.values()):
                             random_clr = [np.random.randint(0, 255) for r in range(3)]
                         colors[index.label] = random_clr
+                    else:
+                        no_predefined_color.append(region.name)
 
         if len(colors) == 0:
             raise exceptions.NoPredifinedColormapException(
                 f"There is no predefined/preconfigured colormap for '{self}'."
-                "Set `allow_random_colors=True` to a colormap with random values"
+                "Set `fill_uncolored=True` to get a reproducible colormap."
+            )
+
+        if no_predefined_color:
+            logger.info(
+                f"No preconfigured color found for the following regions."
+                "Use `fill_uncolored=True` to display with a non-background color.\n"
+                f"{no_predefined_color}"
             )
 
         palette = np.array(

siibra/volumes/providers/freesurfer.py

@@ -14,12 +14,12 @@
 # limitations under the License.
 """Handles reading and preparing gii files."""
 
-from . import provider as _provider
-
-from ...retrieval.requests import HttpRequest, ZipfileRequest
+from typing import Union, Dict, TYPE_CHECKING
 
 import numpy as np
-from typing import Union, Dict, TYPE_CHECKING
+
+from . import provider as _provider
+from ...retrieval.requests import HttpRequest, ZipfileRequest
 
 if TYPE_CHECKING:
     from ...locations import boundingbox as _boundingbox

siibra/volumes/providers/gifti.py

@@ -14,15 +14,15 @@
 # limitations under the License.
 """Handles reading and preparing gii files."""
 
-from . import provider as _provider
+from typing import Union, Dict
+
+import numpy as np
 
+from . import provider as _provider
 from ...retrieval import requests
 from ...commons import logger, merge_meshes
 from ...locations import boundingbox as _boundingbox
 
-import numpy as np
-from typing import Union, Dict
-
 
 class GiftiMesh(_provider.VolumeProvider, srctype="gii-mesh"):
     """

siibra/volumes/providers/neuroglancer.py

@@ -13,8 +13,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from . import provider as _provider
+from io import BytesIO
+import os
+from typing import Union, Dict, Tuple
+import json
+
+import numpy as np
+import nibabel as nib
+from neuroglancer_scripts.precomputed_io import get_IO_for_existing_dataset, PrecomputedIO
+from neuroglancer_scripts.http_accessor import HttpAccessor
+from neuroglancer_scripts.mesh import read_precomputed_mesh, affine_transform_mesh
 
+from . import provider as _provider
+from ...retrieval import requests, cache
+from ...locations import boundingbox as _boundingbox
 from ...commons import (
     logger,
     MapType,
@@ -23,18 +35,6 @@ from ...commons import (
     QUIET,
     resample_img_to_img
 )
-from ...retrieval import requests, cache
-from ...locations import boundingbox as _boundingbox
-
-from neuroglancer_scripts.precomputed_io import get_IO_for_existing_dataset, PrecomputedIO
-from neuroglancer_scripts.http_accessor import HttpAccessor
-from neuroglancer_scripts.mesh import read_precomputed_mesh, affine_transform_mesh
-from io import BytesIO
-import nibabel as nib
-import os
-import numpy as np
-from typing import Union, Dict, Tuple
-import json
 
 
 def shift_ng_transfrom(
@@ -529,14 +529,7 @@ class NeuroglancerScale:
         if voi is None:
             bbox_ = _boundingbox.BoundingBox((0, 0, 0), self.size, space=None)
         else:
-            bbox_ = voi.transform(np.linalg.inv(self.affine))
-
-        for dim in range(3):
-            if bbox_.shape[dim] < 1:
-                logger.warning(
-                    f"Bounding box in voxel space will be enlarged to by {self.res_mm[dim]} along axis {dim}."
-                )
-                bbox_.maxpoint[dim] = bbox_.maxpoint[dim] + self.res_mm[dim]
+            bbox_ = voi.transform(np.linalg.inv(self.affine), space=None)
 
         # extract minimum and maximum the chunk indices to be loaded
         gx0, gy0, gz0 = self._point_to_lower_chunk_idx(tuple(bbox_.minpoint))
@@ -559,8 +552,12 @@ class NeuroglancerScale:
         # exact bounding box requested, to cut off undesired borders
         data_min = np.array([gx0, gy0, gz0]) * self.chunk_sizes
         x0, y0, z0 = (np.array(bbox_.minpoint) - data_min).astype("int")
-        xd, yd, zd = np.ceil((np.array(bbox_.maxpoint))).astype(int) - np.floor((np.array(bbox_.minpoint))).astype(int)
+        xd, yd, zd = np.ceil(bbox_.maxpoint).astype(int) - np.floor(bbox_.minpoint).astype(int)
         offset = tuple(bbox_.minpoint)
+        if voi is not None:
+            logger.debug(
+                f"Input: {voi.minpoint.coordinate}, {voi.maxpoint.coordinate}.\nVoxel space: {bbox_.minpoint.coordinate}, {bbox_.maxpoint.coordinate}"
+            )
 
         # build the nifti image
         trans = np.identity(4)[[2, 1, 0, 3], :]  # zyx -> xyz

siibra/volumes/providers/nifti.py

@@ -13,17 +13,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from . import provider as _provider
+import os
+from typing import Union, Dict, Tuple
+
+import numpy as np
+import nibabel as nib
 
+from . import provider as _provider
 from ...commons import logger, resample_img_to_img
 from ...retrieval import requests
 from ...locations import pointcloud, boundingbox as _boundingbox
 
-from typing import Union, Dict, Tuple
-import nibabel as nib
-import os
-import numpy as np
-
 
 class NiftiProvider(_provider.VolumeProvider, srctype="nii"):
 

siibra/volumes/providers/provider.py

@@ -17,12 +17,13 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Union, Dict, List
-from nibabel import Nifti1Image
 import json
+
+from nibabel import Nifti1Image
+
 if TYPE_CHECKING:
     from ...locations.boundingbox import BoundingBox
 
-# TODO add mesh primitive. Check nibabel implementation? Use trimesh? Do we want to add yet another dependency?
 VolumeData = Union[Nifti1Image, Dict]
 
 

siibra/volumes/sparsemap.py

@@ -13,19 +13,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Represents lists of probabilistic brain region maps."""
-from . import parcellationmap, volume as _volume
 
+from os import path, makedirs
+from typing import Dict, List
+
+import numpy as np
+from nilearn import image
+
+from . import parcellationmap, volume as _volume
 from .providers import provider
 from ..commons import MapIndex, logger, connected_components, siibra_tqdm
 from ..locations import boundingbox
 from ..retrieval.cache import CACHE
 from ..retrieval.requests import HttpRequest, FileLoader
 
-from os import path, makedirs
-from typing import Dict, List
-from nilearn import image
-import numpy as np
-
 
 class SparseIndex:
 

siibra/volumes/volume.py

@@ -14,27 +14,26 @@
 # limitations under the License.
 """A specific mesh or 3D array."""
 
-from .providers import provider as _provider
-
-from .. import logger
-from ..retrieval import requests
-from ..core import space as _space, structure
-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
+from dataclasses import dataclass
 from time import sleep
 import json
-from skimage import feature as skimage_feature, filters
 from functools import lru_cache
 
+import numpy as np
+from nibabel import Nifti1Image
+from skimage import feature as skimage_feature, filters
+
+from . import providers as _providers
+from ..commons import resample_img_to_img, siibra_tqdm, affine_scaling, connected_components, logger
+from ..exceptions import NoMapAvailableError, SpaceWarpingFailedError, EmptyPointCloudError
+from ..retrieval import requests
+from ..core import space as _space, structure
+from ..core.concept import get_registry
+from ..locations import point, pointcloud, boundingbox
+
 if TYPE_CHECKING:
-    from ..retrieval.datasets import EbrainsDataset
-    TypeDataset = EbrainsDataset
+    from ..retrieval.datasets import EbrainsDataset as TypeDataset
 
 
 @dataclass
@@ -129,7 +128,7 @@ class Volume(structure.BrainStructure):
     def __init__(
         self,
         space_spec: dict,
-        providers: List['_provider.VolumeProvider'],
+        providers: List[_providers.provider.VolumeProvider],
         name: str = "",
         variant: str = None,
         datasets: List['TypeDataset'] = [],
@@ -138,7 +137,7 @@ class Volume(structure.BrainStructure):
         self._name = name
         self._space_spec = space_spec
         self.variant = variant
-        self._providers: Dict[str, _provider.VolumeProvider] = {}
+        self._providers: Dict[str, _providers.provider.VolumeProvider] = {}
         self.datasets = datasets
         self._boundingbox = bbox
         for provider in providers:
@@ -714,7 +713,7 @@ class Subvolume(Volume):
             self,
             space_spec=parent_volume._space_spec,
             providers=[
-                _provider.SubvolumeProvider(p, z=z)
+                _providers.provider.SubvolumeProvider(p, z=z)
                 for p in parent_volume._providers.values()
             ],
             name=parent_volume.name + f" - z: {z}"
@@ -722,25 +721,21 @@ class Subvolume(Volume):
 
 
 def from_file(filename: str, space: str, name: str) -> Volume:
-    """ Builds a nifti volume from a filename. """
-    from ..core.concept import get_registry
-    from .providers.nifti import NiftiProvider
+    """Builds a nifti volume from a filename."""
     spaceobj = get_registry("Space").get(space)
     return Volume(
         space_spec={"@id": spaceobj.id},
-        providers=[NiftiProvider(filename)],
+        providers=[_providers.NiftiProvider(filename)],
         name=filename if name is None else name,
     )
 
 
 def from_nifti(nifti: Nifti1Image, space: str, name: str) -> Volume:
     """Builds a nifti volume from a Nifti image."""
-    from ..core.concept import get_registry
-    from .providers.nifti import NiftiProvider
     spaceobj = get_registry("Space").get(space)
     return Volume(
         space_spec={"@id": spaceobj.id},
-        providers=[NiftiProvider((np.asanyarray(nifti.dataobj), nifti.affine))],
+        providers=[_providers.NiftiProvider((np.asanyarray(nifti.dataobj), nifti.affine))],
         name=name
     )
 
@@ -754,13 +749,11 @@ def from_array(
     """Builds a siibra volume from an array and an affine matrix."""
     if len(name) == 0:
         raise ValueError("Please provide a non-empty string for `name`")
-    from ..core.concept import get_registry
-    from .providers.nifti import NiftiProvider
     spacespec = next(iter(space.values())) if isinstance(space, dict) else space
     spaceobj = get_registry("Space").get(spacespec)
     return Volume(
         space_spec={"@id": spaceobj.id},
-        providers=[NiftiProvider((data, affine))],
+        providers=[_providers.NiftiProvider((data, affine))],
         name=name,
     )
 

{siibra-1.0.1a1.dist-info → siibra-1.0.1a2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: siibra
-Version: 1.0.1a1
+Version: 1.0.1a2
 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)
@@ -59,6 +59,14 @@ It aims to facilitate programmatic and reproducible incorporation of brain parce
 It supports both discretely labelled and statistical (probabilistic) parcellation maps, which can be used to assign brain regions to spatial locations and image signals, to retrieve region-specific neuroscience datasets from multiple online repositories, and to sample information from high-resolution image data. 
 The datasets anchored to brain regions address features of molecular, cellular and architecture as well as connectivity, and are complemented with live queries to external repositories as well as dynamic extraction from "big" image volumes such as the 20 micrometer BigBrain model.
 
+``siibra`` hides much of the complexity that would be required to collect and interact with the individual parcellations, templates and data repositories.
+By encapsulating many aspects of interacting with different maps and reference templates spaces, it also minimizes common errors like misinterpretation of coordinates from different reference spaces, confusing label indices of brain regions, or using inconsistent versions of parcellation maps. 
+It aims to provide a safe way of using maps defined across multiple spatial scales for reproducible analysis.
+
+.. intro-end
+
+.. about-start
+
 ``siibra`` was developed in the frame of the `Human Brain Project <https://humanbrainproject.eu>`__ for accessing the `EBRAINS
 human brain atlas <https://ebrains.eu/service/human-brain-atlas>`__. 
 It stores most of its contents as sustainable and open datasets in the `EBRAINS Knowledge Graph <https://kg.ebrains.eu>`__, and is designed to support the `OpenMINDS metadata standards <https://github.com/HumanBrainProject/openMINDS_SANDS>`__. 
@@ -67,11 +75,7 @@ In fact, the viewer is a good resource for exploring ``siibra``\ ’s core funct
 Feature queries in ``siibra`` are parameterized by data modality and anatomical location, while the latter could be a brain region, brain parcellation, or location in reference space. 
 Beyond the explorative focus of ``siibra-explorer``, the Python library supports a range of data analysis functions suitable for typical neuroscience workflows.
 
-``siibra`` hides much of the complexity that would be required to collect and interact with the individual parcellations, templates and data repositories.
-By encapsulating many aspects of interacting with different maps and reference templates spaces, it also minimizes common errors like misinterpretation of coordinates from different reference spaces, confusing label indices of brain regions, or using inconsistent versions of parcellation maps. 
-It aims to provide a safe way of using maps defined across multiple spatial scales for reproducible analysis.
-
-.. intro-end
+.. about-end
 
 .. getting-started-start
 

siibra-1.0.1a2.dist-info/RECORD

@@ -0,0 +1,80 @@
+siibra/VERSION,sha256=tnNU724QbIsJd2y5y9A2yYp48XeoqEJ_sfDYRgMGdrg,14
+siibra/__init__.py,sha256=1uWhsE93KG4N9wiWoMdEokUXxfoRcyznXDktjAGhpEI,4496
+siibra/commons.py,sha256=i4qS4CPteESu2NlchZuLjJrc23PYc0_WMiPr7WMi9ro,27646
+siibra/exceptions.py,sha256=6MlXOadwXcCsceOE4lmy4fLJyAaBCCVvJF6BZlMYjU8,1371
+siibra/configuration/__init__.py,sha256=ArqQ_B8C_O61KA4Fk3ho8ksckbjLu-COOlPGiXyf8LE,752
+siibra/configuration/configuration.py,sha256=FhJ2MF925BeI3KHk8r68-1PnMzIqTfsZEM8ZpvbtqzQ,7263
+siibra/configuration/factory.py,sha256=WPOP0hugX47cTWMGsXo99B4RER14pGllJDUvcC3kMko,22628
+siibra/core/__init__.py,sha256=zW887SH2txImUfvU80k83NbxxnlHlbdzBjdryY-3-48,766
+siibra/core/assignment.py,sha256=7TL3cV2uU8XHatpOkrt5uMju04HfDtcgRR7HM3B1chU,3820
+siibra/core/atlas.py,sha256=Iwqgcf8sG8_iL4mlw_4Nzi7HWVR-wxYLESqnIS0CFTw,8549
+siibra/core/concept.py,sha256=rLqgJ72Mt1Mc8mlh-bGYOyq65rV7Vc8vCZGs-amJp1w,10891
+siibra/core/parcellation.py,sha256=JzrnoB8G0XupffP8mnwE3oHYmHjo2Mzn4-pXnZ2R6Ow,14480
+siibra/core/region.py,sha256=036Fjck1H6wGSubJomjEHUN1I-XMPSPqx3_78MEYbG8,44108
+siibra/core/space.py,sha256=X7FyKgdhao3ezSWQZ0MAjDxlQh305S-4a4D630RaM-c,4588
+siibra/core/structure.py,sha256=M2li4PPiJf27dOc3b2ycCfHf7Ad1AWxBYc9OpSFazJM,4498
+siibra/explorer/__init__.py,sha256=XBAeYm4W3HlbWsKtt8gOwqE_FinIEY7RdA6Rg4Y275A,781
+siibra/explorer/url.py,sha256=ja5i-VkEMYwqhlQ-K5tEfnlYTcgMpPFYJCK7IV0d3Us,7069
+siibra/explorer/util.py,sha256=ul82TQZAULdupr4tJBACdkjlHm2mt8LJ9UpwNWGHYhE,2083
+siibra/features/__init__.py,sha256=FER6DMnkPhXSV1XMZWibZdyBwVhIgWYSUGYMEYEKb9c,3970
+siibra/features/anchor.py,sha256=Umu_Ljkr656h7jvgp43Wi6thMFEycxz_Lf8Bj_QOTZA,9129
+siibra/features/feature.py,sha256=mpQ0M7sMYJEqOkx91rvaDlV_W5iRi_-z4S3eJLAZR8M,35283
+siibra/features/connectivity/__init__.py,sha256=FkPf0vyrLo3ERxrDbsRHUd7FUgJyajD87NiiXIiXhmY,1161
+siibra/features/connectivity/functional_connectivity.py,sha256=9lQoOXv8lZUnyMduAbWABwDIkQC0QTI8V23yx0NjOBg,2122
+siibra/features/connectivity/regional_connectivity.py,sha256=V401G_EOTIDVz3IJJR4d2xOxLiWmIb9qQAMFD46qPlM,18283
+siibra/features/connectivity/streamline_counts.py,sha256=JaAYf6-1S8NYhkE4lhshCSY__EQ5BFcL2i_XXdFfgrM,1064
+siibra/features/connectivity/streamline_lengths.py,sha256=QeuoW_ZDVa9dxCguaemj4Cq9CCPB8ur8_alhATto2-w,1067
+siibra/features/connectivity/tracing_connectivity.py,sha256=rkYgD8mOZzDp0STo5djhDqOaEdz-9j5EuLffXE0F01A,1083
+siibra/features/dataset/__init__.py,sha256=qRV_P0335b4LnSMiONRpSC4elGckp0FXmtJz_QQuVLA,748
+siibra/features/dataset/ebrains.py,sha256=zA_GSIJzeJgClY5KrsfAJgrdjcM5N2Z_mz442UR_1vc,2544
+siibra/features/image/__init__.py,sha256=_Vf6AgIEiYTmtYiKdM7v6YRQco3XWnrEL8vLDhU1sqo,1015
+siibra/features/image/image.py,sha256=heXBen5Sq3dVEcHSb4W4rs7n9nOXy3Nqp-eO0Vzjz4A,3583
+siibra/features/image/sections.py,sha256=rZPoeZbu_cK8td5J4LVxZxsojjwTodrHe42P2de28_Y,3708
+siibra/features/image/volume_of_interest.py,sha256=6rMMWekSAji7p0KFJMSVX7QuhbODfDBEIR-KNHGvnuM,2392
+siibra/features/tabular/__init__.py,sha256=DdE1GXPEsHSNJ3pyNYZNWu5JxDfuI08DbrDF1iBrXIA,1203
+siibra/features/tabular/bigbrain_intensity_profile.py,sha256=C7rP2QTJPyTz_EnRlgdFWPVaDcwJszTlm1ylHBydJOE,2709
+siibra/features/tabular/cell_density_profile.py,sha256=ScpjD9W-w-lLxdG6q42Zfyqe8LW4JvaorIdnixuPzo4,10818
+siibra/features/tabular/cortical_profile.py,sha256=x0TqZh8FzcVx13EwPtbt8kBYfF1dREWWuf9BhpWzj7o,12542
+siibra/features/tabular/gene_expression.py,sha256=8n3aJgJfU_hyIZFnOmKg76GNCath5TMkH0tElWvZhTg,9828
+siibra/features/tabular/layerwise_bigbrain_intensities.py,sha256=iFCNG641yCSuIXFTY30xgRQqLERDHMqJrAy3SdKkAJ4,2118
+siibra/features/tabular/layerwise_cell_density.py,sha256=j5EznhcWjGb_hwbsQtIiQNWkbeUtEOS13vPeP-Zw2Xw,3740
+siibra/features/tabular/receptor_density_fingerprint.py,sha256=CvFJv940whxzavhEQWnTjueDEq0ZoiuYVpqUpR8t-Ec,8065
+siibra/features/tabular/receptor_density_profile.py,sha256=VW2Ry8ifQLfmiBDKqIdvaN7K1YzMENGU92Lnm4wA8P0,3724
+siibra/features/tabular/regional_timeseries_activity.py,sha256=wuno4oI1I-dyxRr8-tLFj42iaD6dYZiPigCqVMhrG50,10027
+siibra/features/tabular/tabular.py,sha256=wFfCeRwh45Bu7eUT9hBygqy4K010tf7n96t2ddA0tIk,5392
+siibra/livequeries/__init__.py,sha256=hToUNmyFq1UW5CxScHyBB-mSZ7kUK_w1Cvrk1OkZQf0,875
+siibra/livequeries/allen.py,sha256=QtKf5sYsSuF8NeqPvyw_DakEJrVYh47mfJVF1rMkJWg,14827
+siibra/livequeries/bigbrain.py,sha256=hT-T6gKRoZQFPWvitm1hv-DoMkkGjz-NfqSx7khfLR0,15762
+siibra/livequeries/ebrains.py,sha256=GBwpm9f_rVjZgF-SyGZ5PGMmL9e9OZzXhHs78uCNhYs,5952
+siibra/livequeries/query.py,sha256=P_uUVFxv4KyOPQXh2WnDQxuaSSBK_dXPKEr8I0-4xSQ,1849
+siibra/locations/__init__.py,sha256=yTJVMdv-pICm_gUYLQ09lDKSkZBfgUihM6LNv07e_yk,3546
+siibra/locations/boundingbox.py,sha256=uCFQBiwsq39UUTz0xwTNIIl4RMXQRH3MDXO0t9pbY9Q,16369
+siibra/locations/experimental.py,sha256=kd9yroLKpnY-N6hoMVgtHK4pVdgeGqhpad4GyxYy6LU,14484
+siibra/locations/location.py,sha256=sdIZiUHGURpOo9JVMUH2w1dEmZAtMBbBXYED-ho_K5s,4383
+siibra/locations/point.py,sha256=g8rjHCuHENTgkiJB7UGH0nWu4anbhf2GSlUfjhek67o,12533
+siibra/locations/pointcloud.py,sha256=_9-4k9yLMiCu8phoxFO6bUsIuJFbRqw7BmBMQ0_FHmk,13979
+siibra/retrieval/__init__.py,sha256=E-UA8rDQZFGkHmAcmit6siONo7G2mH_Y0xgLlR1RfvY,1062
+siibra/retrieval/cache.py,sha256=uMWEi93VePSOSXaiU5PZAbUlWBYyO7gbpRxod4jO2Rc,7833
+siibra/retrieval/datasets.py,sha256=JgnSc41TM0oGNAVn8zQjL84HML-feOBVy5bLxxHrEt8,11110
+siibra/retrieval/repositories.py,sha256=mMmSAnLZJjDb-bi86FPKNQXDbIPKpA_kh7IjKlTPkxM,29935
+siibra/retrieval/requests.py,sha256=VhAnD8mTK26YHVv0haWjfYcdnJuHg6uHhZD-TSs8Cfo,23094
+siibra/retrieval/exceptions/__init__.py,sha256=sOuzPHh2xq1p55T0zAcrSW2B1wfwwYEXBOWIuCjGePE,875
+siibra/vocabularies/__init__.py,sha256=aWXsCVmtz0ZtX5J-f_XeyeGSAj9XbuQQjKJz_rvPVtY,1287
+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=9eiVjgGTqq9BiFJaLVLABtTrhIcE2k3Cn51yC4EKplg,936
+siibra/volumes/parcellationmap.py,sha256=-Yb9SINRyug-nT_pZkLGvZB3iNrpxFyjp1-PgdMTv2k,51329
+siibra/volumes/sparsemap.py,sha256=PI-3dxORjCFyg_B03ByQpwdAT69GHMRrcLBgweHc0vM,17438
+siibra/volumes/volume.py,sha256=wLmtqoXBDoPvE3WBO_Hc8uny3cdE9mB0KgdCq0LOTa0,32408
+siibra/volumes/providers/__init__.py,sha256=AHZCjutCqO4mnHxyykVjqxlz85jDqFWcSjsa4ciwc1A,934
+siibra/volumes/providers/freesurfer.py,sha256=l3zkLlE28EAEmg75tv9yp1YYiaHVkf4Zi8rKn9TUWVs,4893
+siibra/volumes/providers/gifti.py,sha256=JGuixlSJTVjbDU_M5oMDCV8BAwIzuczhnI-qZ7LMQIc,6231
+siibra/volumes/providers/neuroglancer.py,sha256=b3TiJ6yrx_akLFKgHRKZyHculzzRIqbZ7U3TMQHy6-k,28618
+siibra/volumes/providers/nifti.py,sha256=aAzkmeDZaXRZ-dkAeEb2cSywNn9WzIz0z7yFtN6iNpU,10135
+siibra/volumes/providers/provider.py,sha256=Vn02au_LKynO5SIfqLyjqzxCf7JD9Wm4i7yEFcTX0WU,3585
+siibra-1.0.1a2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+siibra-1.0.1a2.dist-info/METADATA,sha256=lndYng0x27sYef1UlLiD6evMTEYXFsCamHTuTWgfzcs,9111
+siibra-1.0.1a2.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+siibra-1.0.1a2.dist-info/top_level.txt,sha256=NF0OSGLL0li2qyC7MaU0iBB5Y9S09_euPpvisD0-8Hg,7
+siibra-1.0.1a2.dist-info/RECORD,,

{siibra-1.0.1a1.dist-info → siibra-1.0.1a2.dist-info}/WHEEL

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

siibra/experimental/__init__.py

@@ -1,19 +0,0 @@
-# Copyright 2018-2025
-# Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from .plane3d import Plane3D
-from .contour import Contour
-from .cortical_profile_sampler import CorticalProfileSampler
-from .patch import Patch

siibra/experimental/contour.py

@@ -1,61 +0,0 @@
-# Copyright 2018-2025
-# Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from ..locations import point, pointcloud, boundingbox
-
-import numpy as np
-
-
-class Contour(pointcloud.PointCloud):
-    """
-    A PointCloud that represents a contour line.
-    The only difference is that the point order is relevant,
-    and consecutive points are thought as being connected by an edge.
-
-    In fact, PointCloud assumes order as well, but no connections between points.
-    """
-
-    def __init__(self, coordinates, space=None, sigma_mm=0, labels: list = None):
-        pointcloud.PointCloud.__init__(self, coordinates, space, sigma_mm, labels)
-
-    def crop(self, voi: boundingbox.BoundingBox):
-        """
-        Crop the contour with a volume of interest.
-        Since the contour might be split from the cropping,
-        returns a set of contour segments.
-        """
-        segments = []
-
-        # set the contour point labels to a linear numbering
-        # so we can use them after the intersection to detect splits.
-        old_labels = self.labels
-        self.labels = list(range(len(self)))
-        cropped = self.intersection(voi)
-
-        if cropped is not None and not isinstance(cropped, point.Point):
-            assert isinstance(cropped, pointcloud.PointCloud)
-            # Identify contour splits are by discontinuouities ("jumps")
-            # of their labels, which denote positions in the original contour
-            jumps = np.diff([self.labels.index(lb) for lb in cropped.labels])
-            splits = [0] + list(np.where(jumps > 1)[0] + 1) + [len(cropped)]
-            for i, j in zip(splits[:-1], splits[1:]):
-                segments.append(
-                    self.__class__(cropped.coordinates[i:j, :], space=cropped.space)
-                )
-
-        # reset labels of the input contour points.
-        self.labels = old_labels
-
-        return segments

siibra/experimental/cortical_profile_sampler.py

@@ -1,57 +0,0 @@
-# Copyright 2018-2025
-# Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
-
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-
-#     http://www.apache.org/licenses/LICENSE-2.0
-
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from . import contour
-from ..locations import point
-from ..core import parcellation
-
-import numpy as np
-
-
-class CorticalProfileSampler:
-    """Samples cortical profiles from the cortical layer maps."""
-
-    def __init__(self):
-        self.layermap = parcellation.Parcellation.get_instance(
-            "cortical layers"
-        ).get_map(space="bigbrain", maptype="labelled")
-
-    def query(self, query_point: point.Point):
-        q = query_point.warp(self.layermap.space)
-        smallest_dist = np.inf
-        best_match = None
-        for layername in self.layermap.regions:
-            vertices = self.layermap.fetch(region=layername, format="mesh")["verts"]
-            dists = np.sqrt(((vertices - q.coordinate) ** 2).sum(1))
-            best = np.argmin(dists)
-            if dists[best] < smallest_dist:
-                best_match = (layername, best)
-                smallest_dist = dists[best]
-
-        best_vertex = best_match[1]
-        hemisphere = "left" if "left" in best_match[0] else "right"
-        print(f"Best match is vertex #{best_match[1]} in {best_match[0]}.")
-
-        profile = [
-            (_, self.layermap.fetch(region=_, format="mesh")["verts"][best_vertex])
-            for _ in self.layermap.regions
-            if hemisphere in _
-        ]
-
-        return contour.Contour(
-            [p[1] for p in profile],
-            space=self.layermap.space,
-            labels=[p[0] for p in profile],
-        )