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

siibra/core/region.py

@@ -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,12 +26,9 @@ 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
@@ -40,6 +37,7 @@ 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"))
@@ -122,7 +120,7 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
         )
         self._supported_spaces = 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"]:
         """
@@ -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,106 +429,98 @@ 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()]
+
+        threshold_info = "" if maptype == MapType.LABELLED else f"(threshold: {threshold}) "
+        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 = regional_map
+                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:
+            # 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 all(c.mapped_in_space(space) for c in self.children):
+                logger.info(f"{self.name} is not mapped in {space}. Merging the masks of its {len(self.children)} child regions.")
+                child_volumes = [
+                    child.get_regional_mask(space=space, maptype=maptype, threshold=threshold)
+                    for child in self.children
+                ]
+                result = volume.FilteredVolume(
+                    volume.merge(child_volumes),
+                    label=1
+                )
+                name += f"'{result.space}' (built by merging the mask {threshold_info} of its decendants)"
+        result._name = name
+        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 reprsenting this region in the given space and MapType.
 
-        getmap_hash = hash(f"{self.id}{space}{maptype}{threshold}{via_space}")
-        if getmap_hash in self._GETMAP_CACHE:
-            return self._GETMAP_CACHE[getmap_hash]
+        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}"
+                return m.get_volume(region=self)
+        else:
+            raise NoMapAvailableError(
+                f"{self.name} is not mapped in {space} as a {str(maptype)} map."
+                " Please try getting the children or getting the mask."
             )
 
-        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
-
     def mapped_in_space(self, space, recurse: bool = True) -> bool:
         """
         Verifies wether this region is defined by an explicit map in the given space.
@@ -598,7 +580,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 +609,9 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
                 return None
             return self._ASSIGNMENT_CACHE[other, self].invert()
 
-        if isinstance(other, location.Location):
+        if isinstance(other, (location.Location, volume.Volume)):
             if self.mapped_in_space(other.space):
-                regionmap = self.get_regional_map(other.space)
+                regionmap = self.get_regional_mask(other.space)
                 self._ASSIGNMENT_CACHE[self, other] = regionmap.assign(other)
                 return self._ASSIGNMENT_CACHE[self, other]
 
@@ -646,7 +628,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 +678,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 +693,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 +706,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 +740,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 +755,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 +789,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 +804,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 +828,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):
         """
@@ -834,7 +844,7 @@ class Region(anytree.NodeMixin, concept.AtlasConcept, structure.BrainStructure):
 
         if self.supports_space(other.space):
             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 +854,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.")

siibra/exceptions.py

@@ -53,3 +53,11 @@ class ZeroVolumeBoundingBox(Exception):
 
 class NoneCoordinateSuppliedError(ValueError):
     pass
+
+
+class NoMapMatchingValues(ValueError):
+    pass
+
+
+class EmptyPointCloudError(ValueError):
+    pass

siibra/experimental/contour.py

@@ -13,22 +13,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from ..locations import point, pointset, boundingbox
+from ..locations import point, pointcloud, boundingbox
 
 import numpy as np
 
 
-class Contour(pointset.PointSet):
+class Contour(pointcloud.PointCloud):
     """
-    A PointSet that represents a contour line.
+    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, PointSet assumes order as well, but no connections between points.
+    In fact, PointCloud assumes order as well, but no connections between points.
     """
 
     def __init__(self, coordinates, space=None, sigma_mm=0, labels: list = None):
-        pointset.PointSet.__init__(self, coordinates, space, sigma_mm, labels)
+        pointcloud.PointCloud.__init__(self, coordinates, space, sigma_mm, labels)
 
     def crop(self, voi: boundingbox.BoundingBox):
         """
@@ -45,7 +45,7 @@ class Contour(pointset.PointSet):
         cropped = self.intersection(voi)
 
         if cropped is not None and not isinstance(cropped, point.Point):
-            assert isinstance(cropped, pointset.PointSet)
+            assert isinstance(cropped, pointcloud.PointCloud)
             # Identifiy 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])

siibra/experimental/patch.py

@@ -14,7 +14,7 @@
 # limitations under the License.
 
 from ..volumes import volume
-from ..locations import pointset, boundingbox
+from ..locations import pointcloud, boundingbox
 from ..commons import translation_matrix, y_rotation_matrix
 
 import numpy as np
@@ -24,7 +24,7 @@ from nilearn import image
 
 class Patch:
 
-    def __init__(self, corners: pointset.PointSet):
+    def __init__(self, corners: pointcloud.PointCloud):
         """Construct a patch in physical coordinates.
         As of now, only patches aligned in the y plane of the physical space
         are supported."""

siibra/experimental/plane3d.py

@@ -15,7 +15,7 @@
 
 from . import contour
 from . import patch
-from ..locations import point, pointset
+from ..locations import point, pointcloud
 from ..volumes import volume
 
 import numpy as np
@@ -93,9 +93,9 @@ class Plane3D:
         and an Mx3 array "faces" of face definitions.
         Each row in the face array corresponds to the three indices of vertices making up the
         triangle.
-        The result is a list of contour segments, each represented as a PointSet
+        The result is a list of contour segments, each represented as a PointCloud
         holding the ordered list of contour points.
-        The point labels in each "contour" PointSet hold the index of the face in the
+        The point labels in each "contour" PointCloud hold the index of the face in the
         mesh which made up each contour point.
         """
 
@@ -185,17 +185,17 @@ class Plane3D:
 
         return result
 
-    def project_points(self, points: pointset.PointSet):
+    def project_points(self, points: pointcloud.PointCloud):
         """projects the given points onto the plane."""
         assert self.space == points.space
         XYZ = points.coordinates
         N = XYZ.shape[0]
         dists = np.dot(self._n, XYZ.T) - self._d
-        return pointset.PointSet(
+        return pointcloud.PointCloud(
             XYZ - np.tile(self._n, (N, 1)) * dists[:, np.newaxis], space=self.space
         )
 
-    def get_enclosing_patch(self, points: pointset.PointSet, margin=[0.5, 0.5]):
+    def get_enclosing_patch(self, points: pointcloud.PointCloud, margin=[0.5, 0.5]):
         """
         Computes the enclosing patch in the given plane
         which contains the projections of the given points.
@@ -225,7 +225,7 @@ class Plane3D:
 
         m0, m1 = margin
         w = np.linalg.norm(p3 - p2)
-        corners = pointset.PointSet(
+        corners = pointcloud.PointCloud(
             [
                 p1 + (w / 2 + m1) * v2 + m0 * v1,
                 p0 + (w / 2 + m1) * v2 - m0 * v1,
@@ -249,7 +249,7 @@ class Plane3D:
         assert isinstance(image, volume.Volume)
         im_lowres = image.fetch(resolution_mm=1)
         plane_dims = np.where(np.argsort(im_lowres.shape) < 2)[0]
-        voxels = pointset.PointSet(
+        voxels = pointcloud.PointCloud(
             np.vstack(([0, 0, 0], np.identity(3)[plane_dims])), space=None
         )
         points = voxels.transform(im_lowres.affine, space=image.space)

siibra/features/anchor.py

@@ -19,7 +19,7 @@ from ..commons import Species, logger
 from ..core.structure import BrainStructure
 from ..core.assignment import AnatomicalAssignment, Qualification
 from ..locations.location import Location
-from ..core.parcellation import Parcellation
+from ..core.parcellation import Parcellation, find_regions
 from ..core.region import Region
 from ..core.space import Space
 from ..exceptions import SpaceWarpingFailedError
@@ -126,13 +126,13 @@ class AnatomicalAnchor:
             # decode the region specification into a dict of region objects and assignment qualifications
             regions = {
                 region: Qualification.EXACT
-                for region in Parcellation.find_regions(self._regionspec)
+                for region in find_regions(self._regionspec, filter_children=True, find_topmost=False)
                 if region.species in self.species
             }
             # add more regions from possible aliases of the region spec
             for alt_species, aliases in self.region_aliases.items():
                 for alias_regionspec, qualificationspec in aliases.items():
-                    for r in Parcellation.find_regions(alias_regionspec):
+                    for r in find_regions(alias_regionspec, filter_children=True, find_topmost=False):
                         if r.species != alt_species:
                             continue
                         if r not in regions:
@@ -156,18 +156,17 @@ class AnatomicalAnchor:
         else:
             return region + separator + location
 
-    def assign(self, concept: BrainStructure, restrict_space: bool = False) -> AnatomicalAssignment:
+    def assign(self, concept: Union[BrainStructure, Space]) -> AnatomicalAssignment:
         """
         Match this anchor to a query concept. Assignments are cached at runtime,
         so repeated assignment with the same concept will be cheap.
         """
-        if (
-            restrict_space
-            and self.location is not None
-            and isinstance(concept, Location)
-            and not self.location.space.matches(concept.space)
-        ):
-            return []
+        if isinstance(concept, Space):
+            if self.location is not None and self.location.space.matches(concept):
+                return [AnatomicalAssignment(concept, self.location, Qualification.CONTAINED)]
+            else:
+                return []
+
         if concept not in self._assignments:
             assignments: List[AnatomicalAssignment] = []
             if self.location is not None:
@@ -184,8 +183,8 @@ class AnatomicalAnchor:
             else None
         return self._assignments[concept]
 
-    def matches(self, concept: BrainStructure, restrict_space: bool = False) -> bool:
-        return len(self.assign(concept, restrict_space)) > 0
+    def matches(self, concept: Union[BrainStructure, Space]) -> bool:
+        return len(self.assign(concept)) > 0
 
     def represented_parcellations(self) -> List[Parcellation]:
         """