siibra 0.4a33__py3-none-any.whl → 0.4a46__py3-none-any.whl

siibra/VERSION

@@ -1 +1 @@
-0.4a33
+0.4a46

siibra/__init__.py

@@ -119,6 +119,7 @@ def __dir__():
         "use_configuration",
         "extend_configuration",
         "get_region",
+        "find_regions",
         "get_map",
         "get_template",
         "MapType",
@@ -130,4 +131,5 @@ def __dir__():
         "set_ebrains_token",
         "vocabularies",
         "__version__",
+        "cache",
     ]

siibra/commons.py

@@ -18,9 +18,11 @@ import re
 from enum import Enum
 from nibabel import Nifti1Image
 import logging
+from tqdm import tqdm
 import numpy as np
 from typing import Generic, Iterable, Iterator, List, TypeVar, Union, Dict
 from skimage.filters import gaussian
+from dataclasses import dataclass
 
 logger = logging.getLogger(__name__.split(os.path.extsep)[0])
 ch = logging.StreamHandler()
@@ -36,9 +38,20 @@ KEYCLOAK_CLIENT_SECRET = os.getenv("KEYCLOAK_CLIENT_SECRET")
 SIIBRA_CACHEDIR = os.getenv("SIIBRA_CACHEDIR")
 SIIBRA_LOG_LEVEL = os.getenv("SIIBRA_LOG_LEVEL", "INFO")
 SIIBRA_USE_CONFIGURATION = os.getenv("SIIBRA_USE_CONFIGURATION")
+
+SIIBRA_USE_LOCAL_SNAPSPOT = os.getenv("SIIBRA_USE_LOCAL_SNAPSPOT")
+
 with open(os.path.join(ROOT_DIR, "VERSION"), "r") as fp:
     __version__ = fp.read().strip()
 
+@dataclass
+class CompareMapsResult:
+    intersection_over_union: float
+    intersection_over_first: float
+    intersection_over_second: float
+    correlation: float
+    weighted_mean_of_first: float
+    weighted_mean_of_second: float
 
 T = TypeVar("T")
 
@@ -233,6 +246,15 @@ QUIET = LoggingContext("ERROR")
 VERBOSE = LoggingContext("DEBUG")
 
 
+def siibra_tqdm(iterable: Iterable[T]=None, *args, **kwargs):
+    return tqdm(
+        iterable,
+        *args,
+        disable=kwargs.pop("disable", False) or (logger.level > 20),
+        **kwargs
+        )
+
+
 def create_key(name: str):
     """
     Creates an uppercase identifier string that includes only alphanumeric
@@ -350,6 +372,21 @@ def affine_scaling(affine):
     return np.prod(unit_lengths)
 
 
+def iterate_connected_components(img: Nifti1Image):
+    """
+    Provide an iterator over masks of connected components in the given image.
+    """
+    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:]
+    )
+
+
 def compare_maps(map1: Nifti1Image, map2: Nifti1Image):
     """
     Compare two maps, given as Nifti1Image objects.
@@ -396,7 +433,14 @@ def compare_maps(map1: Nifti1Image, map2: Nifti1Image):
     m1, m2 = ((_ > 0).astype("uint8") for _ in [v1, v2])
     intersection = np.minimum(m1, m2).sum()
     if intersection == 0:
-        return {"IoU": 0, "contained": 0, "contains": 0, "correlation": 0}
+        return CompareMapsResult(
+            intersection_over_union=0,
+            intersection_over_first=0,
+            intersection_over_second=0,
+            correlation=0,
+            weighted_mean_of_first=0,
+            weighted_mean_of_second=0,
+        )
 
     # Compute the nonzero voxels in map1 with their correspondences in map2
     XYZnz1 = nonzero_coordinates(a1)
@@ -430,13 +474,14 @@ def compare_maps(map1: Nifti1Image, map2: Nifti1Image):
 
     bx = (x > 0).astype("uint8")
     by = (y > 0).astype("uint8")
-
-    return {
-        "IoU": intersection / np.maximum(bx, by).sum(),
-        "contained": intersection / N1,
-        "contains": intersection / N2,
-        "correlation": r,
-    }
+    return CompareMapsResult(
+        intersection_over_union=intersection / np.maximum(bx, by).sum(),
+        intersection_over_first=intersection / N1,
+        intersection_over_second=intersection / N2,
+        correlation=r,
+        weighted_mean_of_first=np.sum(x * y) / np.sum(y),
+        weighted_mean_of_second=np.sum(x * y) / np.sum(x),
+    )
 
 
 class PolyLine:

siibra/configuration/configuration.py

@@ -13,7 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from ..commons import logger, __version__, SIIBRA_USE_CONFIGURATION
+from ..commons import logger, __version__, SIIBRA_USE_CONFIGURATION, siibra_tqdm
 from ..retrieval.repositories import GitlabConnector, RepositoryConnector
 from ..retrieval.exceptions import NoSiibraConfigMirrorsAvailableException
 from ..retrieval.requests import SiibraHttpRequestError
@@ -21,7 +21,6 @@ from ..retrieval.requests import SiibraHttpRequestError
 from typing import Union
 from collections import defaultdict
 from requests.exceptions import ConnectionError
-from tqdm import tqdm
 from os import path
 
 
@@ -47,12 +46,7 @@ class Configuration:
 
     CONFIGURATION_EXTENSIONS = []
 
-    # lists of loaders for json specification files
-    # found in the siibra configuration, stored per
-    # preconfigured class name. These files can
-    # loaded and fed to the Factory.from_json
-    # to produce the corresponding object.
-    spec_loaders = defaultdict(list)
+
 
     _cleanup_funcs = []
 
@@ -65,6 +59,13 @@ class Configuration:
 
     def __init__(self):
 
+        # lists of loaders for json specification files
+        # found in the siibra configuration, stored per
+        # preconfigured class name. These files can
+        # loaded and fed to the Factory.from_json
+        # to produce the corresponding object.
+        self.spec_loaders = defaultdict(list)
+
         # retrieve json spec loaders from the default configuration
         for connector in self.CONFIGURATIONS:
             try:
@@ -122,11 +123,14 @@ class Configuration:
             conn = RepositoryConnector._from_url(conn)
         if not isinstance(conn, RepositoryConnector):
             raise RuntimeError("conn needs to be an instance of RepositoryConnector or a valid str")
-        logger.info(f"Extending configuration with {str(conn)}")
-        cls.CONFIGURATION_EXTENSIONS.append(conn)
-        # call registered cleanup functions
-        for func in cls._cleanup_funcs:
-            func()
+        if conn in cls.CONFIGURATION_EXTENSIONS:
+            logger.warn(f"The configuration {str(conn)} is already registered.")
+        else:
+            logger.info(f"Extending configuration with {str(conn)}")
+            cls.CONFIGURATION_EXTENSIONS.append(conn)
+            # call registered cleanup functions
+            for func in cls._cleanup_funcs:
+                func()
 
     @classmethod
     def register_cleanup(cls, func):
@@ -143,7 +147,7 @@ class Configuration:
         result = []
 
         if folder not in self.folders:
-            logger.warn(f"No configuration found for building from configuration folder {folder}.")
+            logger.warning(f"No configuration found for building from configuration folder {folder}.")
             return result
 
         from .factory import Factory
@@ -158,12 +162,12 @@ class Configuration:
             )
         )
 
-        for fname, loader in tqdm(
+        for fname, loader in siibra_tqdm(
             specloaders,
             total=len(specloaders),
             desc=f"Loading preconfigured {obj0.__class__.__name__} instances"
         ):
-            # filename is added to allow Factory creating reasonable default object identifiers
+            # filename is added to allow Factory creating reasonable default object identifiers\
             obj = Factory.from_json(dict(loader.data, **{'filename': fname}))
             result.append(obj)
 
@@ -174,5 +178,5 @@ class Configuration:
 
 
 if SIIBRA_USE_CONFIGURATION:
-    logger.warn(f"config.SIIBRA_USE_CONFIGURATION defined, use configuration at {SIIBRA_USE_CONFIGURATION}")
+    logger.warning(f"config.SIIBRA_USE_CONFIGURATION defined, use configuration at {SIIBRA_USE_CONFIGURATION}")
     Configuration.use_configuration(SIIBRA_USE_CONFIGURATION)

siibra/configuration/factory.py

@@ -14,15 +14,19 @@
 # limitations under the License.
 
 from ..commons import logger, Species
-from ..features import anchor
-from ..features.molecular import receptor_density_fingerprint, receptor_density_profile
-from ..features.cellular import cell_density_profile, layerwise_cell_density
-from ..features.basetypes import volume_of_interest
+from ..features import anchor, connectivity
+from ..features.tabular import (
+    receptor_density_profile,
+    receptor_density_fingerprint,
+    cell_density_profile,
+    layerwise_cell_density,
+    regional_timeseries_activity
+)
+from ..features.image import sections, volume_of_interest
 from ..core import atlas, parcellation, space, region
 from ..locations import point, pointset
 from ..retrieval import datasets, repositories
 from ..volumes import gifti, volume, nifti, neuroglancer, sparsemap, parcellationmap
-from ..features import connectivity
 
 from os import path
 import json
@@ -49,7 +53,9 @@ BUILDFUNCS = {
     "siibra/feature/fingerprint/receptor/v0.1": "build_receptor_density_fingerprint",
     "siibra/feature/fingerprint/celldensity/v0.1": "build_cell_density_fingerprint",
     "siibra/feature/connectivitymatrix/v0.2": "build_connectivity_matrix",
+    "siibra/feature/section/v0.1": "build_section",
     "siibra/feature/voi/v0.1": "build_volume_of_interest",
+    "siibra/feature/timeseries/activity/v0.1": "build_activity_timeseries"
 }
 
 
@@ -64,6 +70,10 @@ class Factory:
             result.append(
                 datasets.EbrainsDataset(id=spec["ebrains"]["minds/core/dataset/v1.0.0"])
             )
+        if "openminds/DatasetVersion" in spec.get("ebrains", {}):
+            result.append(
+                datasets.EbrainsV3DatasetVersion(id=spec["ebrains"]["openminds/DatasetVersion"])
+            )
         return result
 
     @classmethod
@@ -72,7 +82,7 @@ class Factory:
         for vspec in volume_specs:
             if space_id:
                 if 'space' in vspec:
-                    logger.warn(f"Replacing space spec {vspec['space']} in volume spec with {space_id}")
+                    logger.warning(f"Replacing space spec {vspec['space']} in volume spec with {space_id}")
                 vspec['space'] = {"@id": space_id}
             if name and vspec.get('name') is None:  # only use provided name if the volume has no specific name
                 vspec['name'] = name
@@ -135,7 +145,7 @@ class Factory:
                 reftag=repospec['branch']
             )
         else:
-            logger.warn(
+            logger.warning(
                 "Do not know how to create a repository "
                 f"connector from specification type {spectype}."
             )
@@ -236,7 +246,7 @@ class Factory:
                     break
             else:
                 if srctype not in cls._warnings_issued:
-                    logger.warn(f"No provider defined for volume Source type {srctype}")
+                    logger.warning(f"No provider defined for volume Source type {srctype}")
                     cls._warnings_issued.append(srctype)
 
         assert all([isinstance(provider, volume.VolumeProvider) for provider in providers])
@@ -245,6 +255,7 @@ class Factory:
             providers=providers,
             name=spec.get("name", {}),
             variant=spec.get("variant"),
+            datasets=cls.extract_datasets(spec),
         )
 
         return result
@@ -267,7 +278,7 @@ class Factory:
         else:
             max_z = max(
                 d.get('z', 0)
-                for _, l in spec.get("indices", {}).items()
+                for l in spec.get("indices", {}).values()
                 for d in l
             ) + 1
             if max_z > MIN_VOLUMES_FOR_SPARSE_MAP:
@@ -364,17 +375,61 @@ class Factory:
             datasets=cls.extract_datasets(spec),
         )
 
+    @classmethod
+    def build_section(cls, spec):
+        vol = cls.build_volume(spec)
+        kwargs = {
+            "name": spec.get('name', ""),
+            "region": spec.get('region', None),
+            "space_spec": vol._space_spec,
+            "providers": vol._providers.values(),
+            "datasets": cls.extract_datasets(spec),
+        }
+        modality = spec.get('modality', "")
+        if modality == "cell body staining":
+            return sections.CellbodyStainedSection(**kwargs)
+        else:
+            raise ValueError(f"No method for building image section feature type {modality}.")
+
     @classmethod
     def build_volume_of_interest(cls, spec):
         vol = cls.build_volume(spec)
-        return volume_of_interest.VolumeOfInterest(
-            name=vol.name,
-            modality=spec.get('modality', ""),
-            region=spec.get('region', None),
-            space_spec=vol._space_spec,
-            providers=vol._providers.values(),
-            datasets=cls.extract_datasets(spec),
-        )
+        kwargs = {
+            "name": spec.get('name', ""),
+            "region": spec.get('region', None),
+            "space_spec": vol._space_spec,
+            "providers": vol._providers.values(),
+            "datasets": cls.extract_datasets(spec),
+        }
+        modality = spec.get('modality', "")
+        if modality == "cell body staining":
+            return volume_of_interest.CellBodyStainedVolumeOfInterest(**kwargs)
+        elif modality == "blockface":
+            return volume_of_interest.BlockfaceVolumeOfInterest(**kwargs)
+        elif modality == "PLI HSV fibre orientation map":
+            return volume_of_interest.PLIVolumeOfInterest(
+                modality="HSV fibre orientation map", **kwargs
+            )
+        elif modality == "transmittance":
+            return volume_of_interest.PLIVolumeOfInterest(
+                modality="transmittance", **kwargs
+            )
+        elif modality == "XPCT":
+            return volume_of_interest.XPCTVolumeOfInterest(
+                modality="XPCT", **kwargs
+            )
+        # elif modality == "segmentation":
+        #     return volume_of_interest.SegmentedVolumeOfInterest(**kwargs)
+        elif modality == "T2 weighted MRI":
+            return volume_of_interest.MRIVolumeOfInterest(
+                modality="T2", **kwargs
+            )
+        elif modality == "T1 weighted MRI":
+            return volume_of_interest.MRIVolumeOfInterest(
+                modality="T1", **kwargs
+            )
+        else:
+            raise ValueError(f"No method for building image section feature type {modality}.")
 
     @classmethod
     def build_connectivity_matrix(cls, spec):
@@ -398,10 +453,31 @@ class Factory:
             kwargs["paradigm"] = spec.get("paradigm")
             return connectivity.FunctionalConnectivity(**kwargs)
         elif modality == "RestingState":
-            kwargs["paradigm"] = "RestingState"
+            kwargs["paradigm"] = spec.get("paradigm", "RestingState")
             return connectivity.FunctionalConnectivity(**kwargs)
         else:
-            raise ValueError(f"Do not know how to build connectivity matrix of type {modality}.")
+            raise ValueError(f"No method for building connectivity matrix of type {modality}.")
+
+    @classmethod
+    def build_activity_timeseries(cls, spec):
+        modality = spec["modality"]
+        kwargs = {
+            "cohort": spec["cohort"],
+            "modality": modality,
+            "regions": spec["regions"],
+            "connector": cls.extract_connector(spec),
+            "decode_func": cls.extract_decoder(spec),
+            "files": spec.get("files", {}),
+            "anchor": cls.extract_anchor(spec),
+            "description": spec.get("description", ""),
+            "datasets": cls.extract_datasets(spec),
+            "timestep": spec.get("timestep", ("1 no_unit"))
+        }
+        if modality == "Regional BOLD signal":
+            kwargs["paradigm"] = spec.get("paradigm", "")
+            return regional_timeseries_activity.RegionalBOLD(**kwargs)
+        else:
+            raise ValueError(f"No method for building signal table of type {modality}.")
 
     @classmethod
     def from_json(cls, spec: dict):

siibra/core/atlas.py

@@ -184,17 +184,20 @@ class Atlas(concept.AtlasConcept, configuration_folder="atlases"):
 
         Parameters
         ----------
-        regionspec : any of
-            - a string with a possibly inexact name, which is matched both
-              against the name and the identifier key,
-            - an integer, which is interpreted as a labelindex
-            - a region object
+        regionspec: str, regex, int, Region, MapIndex
+            - a string with a possibly inexact name (matched both against the name and the identifier key)
+            - a string in '/pattern/flags' format to use regex search (acceptable flags: aiLmsux)
+            - a regex applied to region names
+            - a Region object
         all_versions : Bool, default: False
             If True, matched regions for all versions of a parcellation are returned.
+        filter_children : bool, default: True
+            If False, children of matched parents will be returned.
 
-        Yield
-        -----
-        list of matching regions
+        Returns
+        -------
+        list[Region]
+            list of regions matching to the regionspec
         """
         result = []
         for p in self._parcellation_ids:

siibra/core/concept.py

@@ -85,9 +85,29 @@ class AtlasConcept:
             else Species.decode(species)  # overwritable property implementation below
         self.shortname = shortname
         self.modality = modality
-        self.description = description
-        self.publications = publications
+        self._description = description
+        self._publications = publications
         self.datasets = datasets
+    
+    @property
+    def description(self):
+        if self._description:
+            return self._description
+        for ds in self.datasets:
+            if ds.description:
+                return ds.description
+        return ''
+    
+    @property
+    def publications(self) -> List[TypePublication]:
+        return [
+            *self._publications,
+            *[{
+                'citation': 'DOI',
+                'url': url.get("url")
+            } for ds in self.datasets
+            for url in ds.urls]
+        ]
 
     @property
     def species(self) -> Species:
@@ -135,12 +155,18 @@ class AtlasConcept:
     @classmethod
     def get_instance(cls, spec: str):
         """
-        Returns an instance of this class matching the given specification
-        from its registry, if possible, otherwise None.
-
-        Raises
+        Parameters
+        ----------
+            spec: str
+                Specification of the class the instance is requested.
+        Returns
         -------
-        IndexError: if spec cannot match any instance
+            an instance of this class matching the given specification from its
+            registry if possible, otherwise None.
+        Raises
+        ------
+            IndexError
+                If spec cannot match any instance
         """
         if cls.registry() is not None:
             return cls.registry().get(spec)
@@ -168,7 +194,14 @@ class AtlasConcept:
 
     def matches(self, spec):
         """
-        Test if the given specification matches the name, key or id of the concept.
+        Parameters
+        ----------
+            spec: str
+                Specification checked within the concept name, key or id
+        Returns
+        -------
+            bool
+                Whether the given specification matches the name, key or id of the concept.
         """
         if isinstance(spec, self.__class__) and (spec == self):
             return True