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

siibra/core/region.py

@@ -20,11 +20,11 @@ from ..volumes import parcellationmap
 
 from ..commons import (
     logger,
-    MapIndex,
     MapType,
     affine_scaling,
     create_key,
     clear_name,
+    siibra_tqdm,
     InstanceTable,
     SIIBRA_DEFAULT_MAPTYPE,
     SIIBRA_DEFAULT_MAP_THRESHOLD
@@ -36,12 +36,25 @@ import anytree
 from typing import List, Set, Union
 from nibabel import Nifti1Image
 from difflib import SequenceMatcher
+from dataclasses import dataclass, field
 
 
 REGEX_TYPE = type(re.compile("test"))
 
 THRESHOLD_STATISTICAL_MAPS = None
 
+@dataclass
+class SpatialPropCmpt:
+    centroid: point.Point
+    volume: int
+
+
+@dataclass
+class SpatialProp:
+    cog:SpatialPropCmpt=None
+    components:List[SpatialPropCmpt]=field(default_factory=list)
+    space:_space.Space=None
+
 
 class Region(anytree.NodeMixin, concept.AtlasConcept):
     """
@@ -153,13 +166,9 @@ class Region(anytree.NodeMixin, concept.AtlasConcept):
             c.parent = region
         return region
 
-    @property
-    def labels(self):
-        return {r.index.label for r in self if r.index.label is not None}  # Potenially a BUG
-
     @property
     def names(self):
-        return {r.key for r in self}
+        return {r.name for r in self}
 
     def __eq__(self, other):
         """
@@ -171,9 +180,7 @@ class Region(anytree.NodeMixin, concept.AtlasConcept):
         elif isinstance(other, str):
             return any([self.name == other, self.key == other, self.id == other])
         else:
-            raise ValueError(
-                f"Cannot compare object of type {type(other)} to {self.__class__.__name__}"
-            )
+            return False
 
     def __hash__(self):
         return hash(self.id)
@@ -207,25 +214,24 @@ class Region(anytree.NodeMixin, concept.AtlasConcept):
 
         Parameters
         ----------
-        regionspec: str, regex, int, Region, MapIndex
+        regionspec: str, regex, int, Region
             - 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
-            - an integer (interpreted as a labelindex)
             - a Region object
-            - a full MapIndex object
         filter_children : bool, default: False
             If True, children of matched parents will not be returned
         find_topmost : bool, default: True
-            If True, will return parent structures if all children are matched,
-            even though the parent itself might not match the specification.
+            If True (requires `filter_children=True`), will return parent
+            structures if all children are matched, even though the parent
+            itself might not match the specification.
         Returns
         -------
         list[Region]
             list of regions matching to the regionspec
         Tip
         ---
-        See example 01-003 find regions
+        See example 01-003, find regions.
         """
         key = (regionspec, filter_children, find_topmost)
         MEM = self._CACHED_REGION_SEARCHES
@@ -244,40 +250,19 @@ class Region(anytree.NodeMixin, concept.AtlasConcept):
                 search_regex = (f"(?{flags})" if flags else "") + expression
                 regionspec = re.compile(search_regex)
 
-            if regionspec in self.names:
-                # key is given, this gives us an exact region
-                match = anytree.search.find_by_attr(self, regionspec, name="key")
-                MEM[key] = [] if match is None else [match]
-                return list(MEM[key])
-
         candidates = list(
-            set(anytree.search.findall(self, lambda node: node.matches(regionspec)))
+            anytree.search.findall(self, lambda node: node.matches(regionspec))
         )
 
         if len(candidates) > 1 and filter_children:
-
             filtered = []
             for region in candidates:
                 children_included = [c for c in region.children if c in candidates]
-                # if the parcellation index matches only approximately,
-                # while a child has an exact matching index, use the child.
                 if len(children_included) > 0:
-                    if not (
-                        isinstance(regionspec, MapIndex)
-                        and (region.index != regionspec)
-                        and any(c.index == regionspec for c in children_included)
-                    ):
-                        filtered.append(region)
+                    filtered.append(region)
                 else:
                     if region.parent not in candidates:
                         filtered.append(region)
-                    else:
-                        if (
-                            isinstance(regionspec, MapIndex)
-                            and (region.index == regionspec)
-                            and (region.parent.index != regionspec)
-                        ):
-                            filtered.append(region)
 
             # find any non-matched regions of which all children are matched
             if find_topmost:
@@ -295,7 +280,10 @@ class Region(anytree.NodeMixin, concept.AtlasConcept):
                 else:
                     # filter child regions again
                     filtered += complete_parents
-                    candidates = [r for r in filtered if r.parent not in filtered]
+                    candidates = [
+                        r for r in filtered
+                        if (r.parent not in filtered) or r == regionspec
+                    ]
             else:
                 candidates = filtered
 
@@ -307,12 +295,12 @@ class Region(anytree.NodeMixin, concept.AtlasConcept):
         else:
             candidates = list(candidates)
 
-        found_regions = sorted(candidates, key=lambda r: r.depth)
+        found_regions = sorted(set(candidates), key=lambda r: r.depth)
 
         # reverse is set to True, since SequenceMatcher().ratio(), higher == better
         MEM[key] = (
             sorted(
-                set(found_regions),
+                found_regions,
                 reverse=True,
                 key=lambda region: SequenceMatcher(None, str(region), regionspec).ratio(),
             )
@@ -429,14 +417,12 @@ class Region(anytree.NodeMixin, concept.AtlasConcept):
             fetch_space = _space.Space.get_instance(fetch_space)
 
         for m in parcellationmap.Map.registry():
-            if all(
-                [
-                    m.space.matches(fetch_space),
-                    m.parcellation == self.parcellation,
-                    m.provides_image,
-                    m.maptype == maptype,
-                    self.name in m.regions
-                ]
+            if (
+                m.space.matches(fetch_space) and
+                m.parcellation == self.parcellation and
+                m.provides_image and
+                m.maptype == maptype and
+                self.name in m.regions
             ):
                 result = m.fetch(region=self, format='image')
                 if (maptype == MapType.STATISTICAL) and (threshold is not None):
@@ -451,7 +437,12 @@ class Region(anytree.NodeMixin, concept.AtlasConcept):
             dataobj = None
             affine = None
             if all(c.mapped_in_space(fetch_space) for c in self.children):
-                for c in self.children:
+                for c in siibra_tqdm(
+                    self.children,
+                    desc=f"Building mask of {self.name}",
+                    leave=False,
+                    unit=" child region"
+                ):
                     mask = c.fetch_regional_map(fetch_space, maptype, threshold)
                     if dataobj is None:
                         dataobj = np.asanyarray(mask.dataobj)
@@ -536,41 +527,6 @@ class Region(anytree.NodeMixin, concept.AtlasConcept):
             elements={s.key: s for s in self.supported_spaces},
         )
 
-    def __getitem__(self, labelindex):
-        """
-        Given an integer label index, return the corresponding region.
-
-        If multiple matches are found, return the unique parent if possible.
-        Otherwise, returns None.
-
-        Parameters
-        ----------
-        regionlabel: int
-            Label index of the desired region.
-        Returns
-        -------
-        Region
-        """
-        if not isinstance(labelindex, int):
-            raise TypeError(
-                "Index access into the regiontree expects label indices of integer type"
-            )
-
-        # first test this head node
-        if self.index.label == labelindex:
-            return self
-
-        # Consider children, and return the one with smallest depth
-        matches = list(
-            filter(lambda x: x is not None, [c[labelindex] for c in self.children])
-        )
-        if matches:
-            parentmatches = [m for m in matches if m.parent not in matches]
-            if len(parentmatches) == 1:
-                return parentmatches[0]
-
-        return None
-
     def __str__(self):
         return self.name
 
@@ -626,7 +582,7 @@ class Region(anytree.NodeMixin, concept.AtlasConcept):
                         maptype=maptype,
                         threshold=threshold_statistical,
                     )
-                    logger.warn(
+                    logger.warning(
                         f"No bounding box for {self.name} defined in {spaceobj.name}, "
                         f"will warp the bounding box from {other_space.name} instead."
                     )
@@ -657,7 +613,7 @@ class Region(anytree.NodeMixin, concept.AtlasConcept):
         """
         props = self.spatial_props(space)
         return pointset.PointSet(
-            [tuple(c["centroid"]) for c in props["components"] if "centroid" in c],
+            [c.centroid for c in props.components],
             space=space
         )
 
@@ -666,7 +622,7 @@ class Region(anytree.NodeMixin, concept.AtlasConcept):
         space: _space.Space,
         maptype: MapType = MapType.LABELLED,
         threshold_statistical=None,
-    ):
+    ) -> SpatialProp:
         """
         Compute spatial properties for connected components of this region in the given space.
 
@@ -687,14 +643,15 @@ class Region(anytree.NodeMixin, concept.AtlasConcept):
         Dict
             Dictionary of region's spatial properties
         """
-        result = {"space": space, "components": []}
         from skimage import measure
 
         if not isinstance(space, _space.Space):
             space = _space.Space.get_instance(space)
 
+        result = SpatialProp(space=space)
+
         if not self.mapped_in_space(space):
-            logger.warn(
+            logger.warning(
                 f"Spatial properties of {self.name} cannot be computed in {space.name}. "
                 "This region is only mapped in these spaces: "
                 f"{', '.join(s.name for s in self.supported_spaces)}"
@@ -715,14 +672,18 @@ class Region(anytree.NodeMixin, concept.AtlasConcept):
 
         # compute spatial properties of each connected component
         for label in range(1, C.max() + 1):
-            props = {}
             nonzero = np.c_[np.nonzero(C == label)]
-            props["centroid"] = point.Point(
-                np.dot(pimg.affine, np.r_[nonzero.mean(0), 1])[:3], space=space
+            result.components.append(
+                SpatialPropCmpt(
+                    centroid=point.Point(
+                        np.dot(pimg.affine, np.r_[nonzero.mean(0), 1])[:3], space=space
+                    ),
+                    volume=nonzero.shape[0] * scale,
+                )
             )
-            props["volume"] = nonzero.shape[0] * scale
 
-            result["components"].append(props)
+        # sort by volume
+        result.components.sort(key=lambda cmp: cmp.volume, reverse=True)
 
         return result
 

siibra/features/anchor.py

@@ -33,6 +33,7 @@ class AssignmentQualification(Enum):
     OVERLAPS = 2
     CONTAINED = 3
     CONTAINS = 4
+    APPROXIMATE = 5
 
     @property
     def verb(self):
@@ -45,6 +46,7 @@ class AssignmentQualification(Enum):
             'OVERLAPS': 'overlaps with',
             'CONTAINED': 'is contained in',
             'CONTAINS': 'contains',
+            'APPROXIMATE': 'approximates to',
         }
         return transl[self.name]
 
@@ -57,6 +59,7 @@ class AssignmentQualification(Enum):
             "OVERLAPS": "OVERLAPS",
             "CONTAINED": "CONTAINS",
             "CONTAINS": "CONTAINED",
+            "APPROXIMATE": "APPROXIMATE",
         }
         return AssignmentQualification[inverses[self.name]]
 
@@ -158,10 +161,10 @@ class AnatomicalAnchor:
     @property
     def region_aliases(self):
         if self._aliases_cached is None:
-            self._aliases_cached = {
-                k: v
+            self._aliases_cached: Dict[str, Dict[str, str]] = {
+                species_str: region_alias_mapping
                 for s in self.species
-                for k, v in REGION_ALIASES.get(str(s), {}).get(self._regionspec, {}).items()
+                for species_str, region_alias_mapping in REGION_ALIASES.get(str(s), {}).get(self._regionspec, {}).items()
             }
         return self._aliases_cached
 
@@ -192,7 +195,7 @@ class AnatomicalAnchor:
                 for regionspec, qualificationspec in aliases.items():
                     for r in Parcellation.find_regions(regionspec, alt_species):
                         if r not in self._regions_cached:
-                            regions[r] = qualificationspec
+                            regions[r] = AssignmentQualification[qualificationspec.upper()]
             self.__class__._MATCH_MEMO[self._regionspec] = regions
         self._regions_cached = self.__class__._MATCH_MEMO[self._regionspec]
         

siibra/features/connectivity/functional_connectivity.py

@@ -14,7 +14,7 @@
 # limitations under the License.
 
 from . import regional_connectivity
-
+from hashlib import md5
 
 class FunctionalConnectivity(
     regional_connectivity.RegionalConnectivity,
@@ -26,3 +26,10 @@ class FunctionalConnectivity(
     def __init__(self, paradigm: str, **kwargs):
         regional_connectivity.RegionalConnectivity.__init__(self, **kwargs)
         self.paradigm = paradigm
+
+        # paradign is used to distinguish functional connectivity features from each other.
+        assert self.paradigm, f"Functional connectivity must have paradigm defined!"
+
+    @property
+    def id(self):
+        return super().id + "--" + md5(self.paradigm.encode("utf-8")).hexdigest()

siibra/features/connectivity/regional_connectivity.py

@@ -18,7 +18,7 @@ from ..tabular.tabular import Tabular
 
 from .. import anchor as _anchor
 
-from ...commons import logger, QUIET
+from ...commons import logger, QUIET, siibra_tqdm
 from ...core import region as _region
 from ...locations import pointset
 from ...retrieval.repositories import RepositoryConnector
@@ -26,7 +26,6 @@ from ...retrieval.repositories import RepositoryConnector
 from typing import Callable, Dict, Union, List
 import pandas as pd
 import numpy as np
-from tqdm import tqdm
 
 
 class RegionalConnectivity(Feature):
@@ -94,6 +93,11 @@ class RegionalConnectivity(Feature):
         """
         return list(self._files.keys())
 
+    @property
+    def name(self):
+        supername = super().name
+        return f"{supername} with cohort {self.cohort}"
+
     def get_matrix(self, subject: str = None):
         """
         Returns a matrix as a pandas dataframe.
@@ -102,8 +106,7 @@ class RegionalConnectivity(Feature):
         ----------
         subject: str, default: None
             Name of the subject (see ConnectivityMatrix.subjects for available names).
-            If "mean" or None is given, the mean is taken in case of multiple
-            available matrices.
+            If None, the mean is taken in case of multiple available matrices.
         Returns
         -------
         pd.DataFrame
@@ -119,21 +122,21 @@ class RegionalConnectivity(Feature):
             if "mean" not in self._matrices:
                 all_arrays = [
                     self._connector.get(fname, decode_func=self._decode_func)
-                    for fname in tqdm(
+                    for fname in siibra_tqdm(
                         self._files.values(),
                         total=len(self),
                         desc=f"Averaging {len(self)} connectivity matrices"
                     )
                 ]
                 self._matrices['mean'] = self._array_to_dataframe(np.stack(all_arrays).mean(0))
-            return self._matrices['mean']
+            return self._matrices['mean'].copy()
         if subject is None:
             subject = next(iter(self._files.keys()))
         if subject not in self._files:
             raise ValueError(f"Subject name '{subject}' not known, use one of: {', '.join(self._files)}")
         if subject not in self._matrices:
             self._matrices[subject] = self._load_matrix(subject)
-        return self._matrices[subject]
+        return self._matrices[subject].copy()
 
     def plot_matrix(self, subject: str = None, regions: List[str] = None, logscale: bool = False, **kwargs):
         """
@@ -291,23 +294,15 @@ class RegionalConnectivity(Feature):
                 for i, regionname in enumerate(self.regions)
             }
         nrows = array.shape[0]
-        if len(indexmap) == nrows:
+        try:
+            assert len(indexmap) == nrows
             remapper = {
                 label - min(indexmap.keys()): region
                 for label, region in indexmap.items()
             }
             df = df.rename(index=remapper).rename(columns=remapper)
-        else:
-            labels = {r.index.label for r in parc.regiontree} - {None}
-            if max(labels) - min(labels) + 1 == nrows:
-                indexmap = {
-                    r.index.label - min(labels): r
-                    for r in parc.regiontree
-                    if r.index.label is not None
-                }
-                df = df.rename(index=indexmap).rename(columns=indexmap)
-            else:
-                logger.warn("Could not decode connectivity matrix regions.")
+        except:
+            raise RuntimeError("Could not decode connectivity matrix regions.")
         return df
 
     def _load_matrix(self, subject: str):

siibra/features/dataset/ebrains.py

@@ -21,7 +21,7 @@ from .. import feature
 from ...retrieval import datasets
 
 
-class EbrainsDataFeature(feature.Feature, datasets.EbrainsDataset, category='dataset'):
+class EbrainsDataFeature(feature.Feature, datasets.EbrainsDataset, category='other'):
 
     def __init__(
         self,