siibra 1.0a19__py3-none-any.whl → 1.0.1a1__py3-none-any.whl

siibra/core/region.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2024
+# Copyright 2018-2025
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,7 +18,7 @@ from . import concept, structure, space as _space, parcellation as _parcellation
 from .assignment import Qualification, AnatomicalAssignment
 
 from ..retrieval.cache import cache_user_fn
-from ..locations import location, pointset, boundingbox as _boundingbox
+from ..locations import location, pointcloud, boundingbox as _boundingbox
 from ..volumes import parcellationmap, volume
 from ..commons import (
     logger,
@@ -26,20 +26,18 @@ from ..commons import (
     create_key,
     clear_name,
     InstanceTable,
-    SIIBRA_DEFAULT_MAPTYPE,
-    SIIBRA_DEFAULT_MAP_THRESHOLD
 )
 from ..exceptions import NoMapAvailableError, SpaceWarpingFailedError
 
-import numpy as np
 import re
 import anytree
-from typing import List, Union, Iterable, Dict, Callable, Tuple
+from typing import List, Union, Iterable, Dict, Callable, Tuple, Set
 from difflib import SequenceMatcher
 from ebrains_drive import BucketApiClient
 import json
 from functools import wraps, reduce
 from concurrent.futures import ThreadPoolExecutor
+from functools import lru_cache
 
 
 REGEX_TYPE = type(re.compile("test"))
@@ -55,8 +53,8 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
     _regex_re = re.compile(r'^\/(?P<expression>.+)\/(?P<flags>[a-zA-Z]*)$')
     _accepted_flags = "aiLmsux"
 
-    _GETMAP_CACHE = {}
-    _GETMAP_CACHE_MAX_ENTRIES = 1
+    _GETMASK_CACHE = {}
+    _GETMASK_CACHE_MAX_ENTRIES = 1
 
     def __init__(
         self,
@@ -113,20 +111,20 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
         )
 
         # anytree node will take care to use this appropriately
-        self.parent = parent
-        self.children = children
+        self.parent: "Region" = parent
+        self.children: List["Region"] = children
         # convert hex to int tuple if rgb is given
         self.rgb = (
             None if rgb is None
             else tuple(int(rgb[p:p + 2], 16) for p in [1, 3, 5])
         )
-        self._supported_spaces = None  # computed on 1st call of self.supported_spaces
+        self._supported_spaces: Set[_space.Space] = None  # computed on 1st call of self.supported_spaces
         self._str_aliases = None
-        self._CACHED_REGION_SEARCHES = {}
+        self.find = lru_cache(maxsize=3)(self.find)
 
     def get_related_regions(self) -> Iterable["RegionRelationAssessments"]:
         """
-        Get assements on relations of this region to others defined on EBRAINS.
+        Get assessments on relations of this region to others defined on EBRAINS.
 
         Yields
         ------
@@ -135,8 +133,8 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
         Example
         -------
         >>> region = siibra.get_region("monkey", "PG")
-        >>> for assesment in region.get_related_regions():
-        >>>    print(assesment)
+        >>> for assessment in region.get_related_regions():
+        >>>    print(assessment)
         'PG' is homologous to 'Area PGa (IPL)'
         'PG' is homologous to 'Area PGa (IPL) left'
         'PG' is homologous to 'Area PGa (IPL) right'
@@ -265,7 +263,7 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
 
         Parameters
         ----------
-        regionspec: str, regex, int, Region
+        regionspec: str, regex, 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, see at https://docs.python.org/3/library/re.html#flags)
             - a regex applied to region names
@@ -286,11 +284,6 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
         ---
         See example 01-003, find regions.
         """
-        key = (regionspec, filter_children, find_topmost)
-        MEM = self._CACHED_REGION_SEARCHES
-        if key in MEM:
-            return MEM[key]
-
         if isinstance(regionspec, str):
             # convert the specified string into a regex for matching
             regex_match = self._regex_re.match(regionspec)
@@ -352,7 +345,7 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
         found_regions = sorted(set(candidates), key=lambda r: r.depth)
 
         # reverse is set to True, since SequenceMatcher().ratio(), higher == better
-        MEM[key] = (
+        return (
             sorted(
                 found_regions,
                 reverse=True,
@@ -361,8 +354,6 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
             if isinstance(regionspec, str) else found_regions
         )
 
-        return MEM[key]
-
     def matches(self, regionspec):
         """
         Checks whether this region matches the given region specification.
@@ -422,15 +413,14 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
 
         return self._CACHED_MATCHES[regionspec]
 
-    def get_regional_map(
+    def get_regional_mask(
         self,
         space: Union[str, _space.Space],
-        maptype: MapType = SIIBRA_DEFAULT_MAPTYPE,
-        threshold: float = SIIBRA_DEFAULT_MAP_THRESHOLD,
-        via_space: Union[str, _space.Space] = None
-    ) -> volume.Volume:
+        maptype: MapType = MapType.LABELLED,
+        threshold: float = 0.0,
+    ) -> volume.FilteredVolume:
         """
-        Attempts to build a binary mask of this region in the given space,
+        Get a binary mask of this region in the given space,
         using the specified MapTypes.
 
         Parameters
@@ -439,128 +429,135 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
             The requested reference space
         maptype: MapType, default: SIIBRA_DEFAULT_MAPTYPE
             The type of map to be used ('labelled' or 'statistical')
-        threshold: float, optional
+        threshold: float, default: 0.0
             When fetching a statistical map, use this threshold to convert
-            it to a binary mask
-        via_space: Space or str
-            If specified, fetch the map in this space first, and then perform
-            a linear warping from there to the requested space.
-
-            Tip
-            ---
-                You might want to use this if a map in the requested space
-                is not available.
-
-            Note
-            ----
-                This linear warping is an affine approximation of the
-                nonlinear deformation, computed from the warped corner points
-                of the bounding box (see siibra.locations.BoundingBox.estimate_affine()).
-                It does not require voxel resampling, just replaces the affine
-                matrix, but is less accurate than a full nonlinear warping,
-                which is currently not supported in siibra-python for images.
+            it to a binary mask.
+
         Returns
         -------
         Volume (use fetch() to get a NiftiImage)
         """
-        # check for a cached object
+        if isinstance(maptype, str):
+            maptype = MapType[maptype.upper()]
 
-        getmap_hash = hash(f"{self.id}{space}{maptype}{threshold}{via_space}")
-        if getmap_hash in self._GETMAP_CACHE:
-            return self._GETMAP_CACHE[getmap_hash]
+        threshold_info = "" if maptype == MapType.LABELLED else f"(threshold: {threshold}) "
+        # check cache
+        getmask_hash = hash(f"{self.id} - {space} - {maptype}{threshold_info}")
+        if getmask_hash in self._GETMASK_CACHE:
+            return self._GETMASK_CACHE[getmask_hash]
 
+        name = f"Mask {threshold_info}of '{self.name} ({self.parcellation})' in "
+        try:
+            regional_map = self.get_regional_map(space=space, maptype=maptype)
+            if maptype == MapType.LABELLED:
+                assert threshold == 0.0, f"threshold can only be set for {MapType.STATISTICAL} maps."
+                result = volume.FilteredVolume(
+                    parent_volume=regional_map,
+                    label=regional_map.label,
+                    fragment=regional_map.fragment
+                )
+                result._boundingbox = None
+            if maptype == MapType.STATISTICAL:
+                result = volume.FilteredVolume(
+                    parent_volume=regional_map,
+                    threshold=threshold
+                )
+                if threshold == 0.0:
+                    result._boundingbox = regional_map._boundingbox
+            name += f"'{result.space}'"
+        except NoMapAvailableError as e:
+            # This region is not mapped directly in any map in the registry.
+            # Try building a map from the child regions
+            if (len(self.children) > 0) and self.mapped_in_space(space, recurse=True):
+                mapped_descendants: List[Region] = [
+                    d for d in self.descendants if d.mapped_in_space(space, recurse=False)
+                ]
+                logger.info(f"{self.name} is not mapped in {space}. Merging the masks of its {len(mapped_descendants)} map descendants.")
+                descendant_volumes = [
+                    descendant.get_regional_mask(space=space, maptype=maptype, threshold=threshold)
+                    for descendant in mapped_descendants
+                ]
+                result = volume.FilteredVolume(
+                    volume.merge(descendant_volumes),
+                    label=1
+                )
+                name += f"'{result.space}' (built by merging the mask {threshold_info} of its descendants)"
+            else:
+                raise e
+        result._name = name
+
+        while len(self._GETMASK_CACHE) > self._GETMASK_CACHE_MAX_ENTRIES:
+            self._GETMASK_CACHE.pop(next(iter(self._GETMASK_CACHE)))
+        self._GETMASK_CACHE[getmask_hash] = result
+        return result
+
+    def get_regional_map(
+        self,
+        space: Union[str, _space.Space],
+        maptype: MapType = MapType.LABELLED,
+    ) -> Union[volume.FilteredVolume, volume.Volume, volume.Subvolume]:
+        """
+        Get a volume representing this region in the given space and MapType.
+
+        Note
+        ----
+        If a region is not mapped in any of the `Map`s in the registry, then
+        siibra will get the maps of its children recursively and merge them.
+        If no map is available this way as well, an exception is raised.
+
+        Parameters
+        ----------
+        space: Space or str
+            The requested reference space
+        maptype: MapType, default: SIIBRA_DEFAULT_MAPTYPE
+            The type of map to be used ('labelled' or 'statistical')
+
+        Returns
+        -------
+        Volume (use fetch() to get a NiftiImage)
+        """
         if isinstance(maptype, str):
             maptype = MapType[maptype.upper()]
 
-        # prepare space instances
+        # prepare space instance
         if isinstance(space, str):
             space = _space.Space.get_instance(space)
-        fetch_space = space if via_space is None else via_space
-        if isinstance(fetch_space, str):
-            fetch_space = _space.Space.get_instance(fetch_space)
-
-        result = None  # try to replace this with the actual regionmap volume
 
         # see if we find a map supporting the requested region
         for m in parcellationmap.Map.registry():
             if (
-                m.space.matches(fetch_space)
+                m.space.matches(space)
                 and m.parcellation == self.parcellation
                 and m.provides_image
                 and m.maptype == maptype
                 and self.name in m.regions
             ):
-                region_img = m.fetch(region=self, format='image')
-                imgdata = np.asanyarray(region_img.dataobj)
-                if maptype == MapType.STATISTICAL:  # compute thresholded statistical map, default is 0.0
-                    logger.info(f"Thresholding statistical map at {threshold}")
-                    imgdata = (imgdata > threshold).astype('uint8')
-                    name = f"Statistical mask of {self} on {fetch_space}{f' thresholded by {threshold}' if threshold else ''}"
-                else:  # compute region mask from labelled parcellation map
-                    name = f"Mask of {self} in {m.parcellation} on {fetch_space}"
-                result = volume.from_array(
-                    data=imgdata,
-                    affine=region_img.affine,
-                    space=fetch_space,
-                    name=name,
-                )
-            if result is not None:
-                break
-
-        if result is None:
-            # No region map available. Then see if we can build a map from the child regions
-            if (len(self.children) > 0) and all(c.mapped_in_space(fetch_space) for c in self.children):
-                logger.debug(f"Building regional map of {self.name} in {self.parcellation} from {len(self.children)} child regions.")
-                child_volumes = [
-                    child.get_regional_map(fetch_space, maptype, threshold, via_space)
-                    for child in self.children
-                ]
-                result = volume.merge(child_volumes)
-                result._name = f"Subtree {'mask' if maptype == MapType.LABELLED else 'statistical map of'} built from {self.name}"
-
-        if result is None:
-            raise NoMapAvailableError(f"Cannot build region map for {self.name} from {str(maptype)} maps in {fetch_space}")
-
-        if via_space is not None:
-            # the map volume is taken from an intermediary reference space
-            # provided by 'via_space'. Now transform the affine to match the
-            # desired target space.
-            intermediary_result = result
-            transform = intermediary_result.get_boundingbox(clip=True, background=0.0).estimate_affine(space)
-            result = volume.from_array(
-                imgdata,
-                np.dot(transform, region_img.affine),
-                space,
-                f"{result.name} fetched from {fetch_space} and linearly corrected to match {space}"
-            )
-
-        while len(self._GETMAP_CACHE) > self._GETMAP_CACHE_MAX_ENTRIES:
-            self._GETMAP_CACHE.pop(next(iter(self._GETMAP_CACHE)))
-        self._GETMAP_CACHE[getmap_hash] = result
-        return result
+                return m.get_volume(region=self)
+        raise NoMapAvailableError(
+            f"{self.name} is not mapped in {space} as a {str(maptype)} map."
+            " Please try getting the children or getting the mask."
+        )
 
-    def mapped_in_space(self, space, recurse: bool = True) -> bool:
+    def mapped_in_space(self, space, recurse: bool = False) -> bool:
         """
-        Verifies wether this region is defined by an explicit map in the given space.
+        Verifies whether this region is defined by an explicit map in the given space.
 
         Parameters
         ----------
         space: Space or str
             reference space
-        recurse: bool, default: True
-            If True, check if all child regions are mapped instead
+        recurse: bool, default: False
+            If True, check if itself or all child regions are mapped instead recursively.
         Returns
         -------
         bool
         """
         from ..volumes.parcellationmap import Map
         for m in Map.registry():
-            # Use and operant for efficiency (short circuiting logic)
-            # Put the most inexpensive logic first
             if (
-                self.name in m.regions
-                and m.space.matches(space)
+                m.space.matches(space)
                 and m.parcellation.matches(self.parcellation)
+                and self.name in m.regions
             ):
                 return True
         if recurse and not self.is_leaf:
@@ -571,21 +568,16 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
     @property
     def supported_spaces(self) -> List[_space.Space]:
         """
-        The set of spaces for which a mask could be extracted.
-        Overwrites the corresponding method of AtlasConcept.
+        The list of spaces for which a mask could be extracted from an existing
+        map or combination of masks of its children.
         """
         if self._supported_spaces is None:
-            self._supported_spaces = sorted(
-                {s for s in _space.Space.registry() if self.mapped_in_space(s)}
-            )
+            self._supported_spaces = sorted({
+                s for s in _space.Space.registry()
+                if self.mapped_in_space(s, recurse=True)
+            })
         return self._supported_spaces
 
-    def supports_space(self, space: _space.Space):
-        """
-        Return true if this region supports the given space, else False.
-        """
-        return any(s.matches(space) for s in self.supported_spaces)
-
     @property
     def spaces(self):
         return InstanceTable(
@@ -598,7 +590,7 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
             return len(self.find(other)) > 0
         else:
             try:
-                regionmap = self.get_regional_map(space=other.space)
+                regionmap = self.get_regional_mask(space=other.space)
                 return regionmap.__contains__(other)
             except NoMapAvailableError:
                 return False
@@ -627,9 +619,9 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
                 return None
             return self._ASSIGNMENT_CACHE[other, self].invert()
 
-        if isinstance(other, location.Location):
-            if self.mapped_in_space(other.space):
-                regionmap = self.get_regional_map(other.space)
+        if isinstance(other, (location.Location, volume.Volume)):
+            if self.mapped_in_space(other.space, recurse=True):
+                regionmap = self.get_regional_mask(other.space)
                 self._ASSIGNMENT_CACHE[self, other] = regionmap.assign(other)
                 return self._ASSIGNMENT_CACHE[self, other]
 
@@ -646,7 +638,7 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
             for targetspace in self.supported_spaces:
                 try:
                     other_warped = other.warp(targetspace)
-                    regionmap = self.get_regional_map(targetspace)
+                    regionmap = self.get_regional_mask(targetspace)
                     assignment_result = regionmap.assign(other_warped)
                 except SpaceWarpingFailedError:
                     try:
@@ -696,10 +688,10 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
         self,
         space: _space.Space,
         maptype: MapType = MapType.LABELLED,
-        threshold_statistical=None,
-        restrict_space=True,
+        threshold_statistical: float = 0.0,
+        restrict_space: bool = True,
         **fetch_kwargs
-    ):
+    ) -> Union[_boundingbox.BoundingBox, None]:
         """
         Compute the bounding box of this region in the given space.
 
@@ -711,9 +703,9 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
             Type of map to build ('labelled' will result in a binary mask,
             'statistical' attempts to build a statistical mask, possibly by
             elementwise maximum of statistical maps of children)
-        threshold_statistical: float, or None
-            if not None, masks will be preferably constructed by thresholding
-            statistical maps with the given value.
+        threshold_statistical: float, default: 0.0
+            When masking a statistical map, use this threshold to convert
+            it to a binary mask before finding its bounding box.
         restrict_space: bool, default: False
             If True, it will not try to fetch maps from other spaces and warp
             its boundingbox to requested space.
@@ -724,16 +716,20 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
         """
         spaceobj = _space.Space.get_instance(space)
         try:
-            mask = self.get_regional_map(
+            mask = self.get_regional_mask(
                 spaceobj, maptype=maptype, threshold=threshold_statistical
             )
-            return mask.get_boundingbox(clip=True, background=0.0, **fetch_kwargs)
+            return mask.get_boundingbox(
+                clip=True,
+                background=0.0,
+                **fetch_kwargs
+            )
         except (RuntimeError, ValueError):
             if restrict_space:
                 return None
             for other_space in self.parcellation.spaces - spaceobj:
                 try:
-                    mask = self.get_regional_map(
+                    mask = self.get_regional_mask(
                         other_space,
                         maptype=maptype,
                         threshold=threshold_statistical,
@@ -754,7 +750,14 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
         logger.error(f"Could not compute bounding box for {self.name}.")
         return None
 
-    def compute_centroids(self, space: _space.Space) -> pointset.PointSet:
+    def compute_centroids(
+        self,
+        space: _space.Space,
+        maptype: MapType = MapType.LABELLED,
+        threshold_statistical: float = 0.0,
+        split_components: bool = True,
+        **fetch_kwargs,
+    ) -> pointcloud.PointCloud:
         """
         Compute the centroids of the region in the given space.
 
@@ -762,19 +765,32 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
         ----------
         space: Space
             reference space in which the computation will be performed
+        maptype: MapType, default: MapType.LABELLED
+            Type of map to build ('labelled' will result in a binary mask,
+            'statistical' attempts to build a statistical mask, possibly by
+            elementwise maximum of statistical maps of children)
+        threshold_statistical: float, default: 0.0
+            When masking a statistical map, use this threshold to convert
+            it to a binary mask before finding its centroids.
 
         Returns
         -------
-        PointSet
-            Found centroids (as Point objects) in a PointSet
+        PointCloud
+            Found centroids (as Point objects) in a PointCloud
 
         Note
         ----
         A region can generally have multiple centroids if it has multiple
         connected components in the map.
         """
-        props = self.spatial_props(space)
-        return pointset.PointSet(
+        props = self.spatial_props(
+            space=space,
+            maptype=maptype,
+            threshold_statistical=threshold_statistical,
+            split_components=split_components,
+            **fetch_kwargs,
+        )
+        return pointcloud.PointCloud(
             [c.centroid for c in props],
             space=space
         )
@@ -783,7 +799,9 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
         self,
         space: _space.Space,
         maptype: MapType = MapType.LABELLED,
-        threshold_statistical=None,
+        threshold_statistical: float = 0.0,
+        split_components: bool = True,
+        **fetch_kwargs,
     ):
         """
         Compute spatial properties for connected components of this region in the given space.
@@ -796,21 +814,21 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
             Type of map to build ('labelled' will result in a binary mask,
             'statistical' attempts to build a statistical mask, possibly by
             elementwise maximum of statistical maps of children)
-        threshold_statistical: float, or None
+        threshold_statistical: float, default: 0.0
             if not None, masks will be preferably constructed by thresholding
             statistical maps with the given value.
 
         Returns
         -------
-        Dict
-            Dictionary of region's spatial properties
+        List
+            List of region's component spatial properties
         """
         if not isinstance(space, _space.Space):
             space = _space.Space.get_instance(space)
 
         # build binary mask of the image
         try:
-            region_vol = self.get_regional_map(
+            region_vol = self.get_regional_mask(
                 space, maptype=maptype, threshold=threshold_statistical
             )
         except NoMapAvailableError:
@@ -820,7 +838,9 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
                 f"{', '.join(s.name for s in self.supported_spaces)}"
             )
 
-        return region_vol.compute_spatial_props()
+        return region_vol.compute_spatial_props(
+            split_components=split_components, **fetch_kwargs
+        )
 
     def __iter__(self):
         """
@@ -832,9 +852,9 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
     def intersection(self, other: "location.Location") -> "location.Location":
         """Use this region for filtering a location object."""
 
-        if self.supports_space(other.space):
+        if self.mapped_in_space(other.space, recurse=True):
             try:
-                volume = self.get_regional_map(other.space)
+                volume = self.get_regional_mask(other.space)
                 if volume is not None:
                     return volume.intersection(other)
             except NotImplementedError:
@@ -844,7 +864,7 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
         for space in self.supported_spaces:
             if space.provides_image:
                 try:
-                    volume = self.get_regional_map(space)
+                    volume = self.get_regional_mask(space)
                     if volume is not None:
                         intersection = volume.intersection(other)
                         logger.info(f"Warped {other} to {space} to find the intersection.")
@@ -898,7 +918,7 @@ def get_peid_from_region(region: Region) -> str:
 
 def get_related_regions(region: Region) -> Iterable["RegionRelationAssessments"]:
     """
-    Get assements on relations of a region to others defined on EBRAINS.
+    Get assessments on relations of a region to others defined on EBRAINS.
 
     Parameters
     ----------
@@ -911,8 +931,8 @@ def get_related_regions(region: Region) -> Iterable["RegionRelationAssessments"]
     Example
     -------
     >>> region = siibra.get_region("monkey", "PG")
-    >>> for assesment in siibra.core.region.get_related_regions(region):
-    >>>    print(assesment)
+    >>> for assessment in siibra.core.region.get_related_regions(region):
+    >>>    print(assessment)
     'PG' is homologous to 'Area PGa (IPL)'
     'PG' is homologous to 'Area PGa (IPL) left'
     'PG' is homologous to 'Area PGa (IPL) right'

siibra/core/space.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2024
+# Copyright 2018-2025
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");

siibra/core/structure.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2024
+# Copyright 2018-2025
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -76,7 +76,7 @@ class BrainStructure(ABC):
         # Two cases:
         # 1) self is location, other is location -> look at spatial intersection/relationship, do it here
         # 2) self is location, other is region -> get region map, then call again. do it here
-        # If self is region -> Region overwrite this method, adressed there
+        # If self is region -> Region overwrite this method, addressed there
 
         assert not isinstance(self, _region.Region)  # method is overwritten by Region!
         if (self, other) in self._ASSIGNMENT_CACHE:

siibra/exceptions.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2024
+# Copyright 2018-2025
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -53,3 +53,15 @@ class ZeroVolumeBoundingBox(Exception):
 
 class NoneCoordinateSuppliedError(ValueError):
     pass
+
+
+class MapNotFound(ValueError):
+    pass
+
+
+class EmptyPointCloudError(ValueError):
+    pass
+
+
+class NoPredifinedColormapException(ValueError):
+    pass

siibra/experimental/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2024
+# Copyright 2018-2025
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");