siibra 0.5a2__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

siibra/locations/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,9 +14,9 @@
 # limitations under the License.
 """Handles spatial concepts and spatial operation like warping between spaces."""
 
-from .location import WholeBrain, Location
+from .location import Location
 from .point import Point
-from .pointset import PointSet
+from .pointcloud import PointCloud, from_points
 from .boundingbox import BoundingBox
 
 
@@ -36,11 +36,11 @@ def reassign_union(loc0: 'Location', loc1: 'Location') -> 'Location':
     Returns
     -------
     Location
-        - Point U Point = PointSet
-        - Point U PointSet = PointSet
-        - PointSet U PointSet = PointSet
+        - Point U Point = PointCloud
+        - Point U PointCloud = PointCloud
+        - PointCloud U PointCloud = PointCloud
         - BoundingBox U BoundingBox = BoundingBox
-        - BoundingBox U PointSet = BoundingBox
+        - BoundingBox U PointCloud = BoundingBox
         - BoundingBox U Point = BoundingBox
         - WholeBrain U Location = NotImplementedError
         (all operations are commutative)
@@ -48,32 +48,39 @@ def reassign_union(loc0: 'Location', loc1: 'Location') -> 'Location':
     if loc0 is None or loc1 is None:
         return loc0 or loc1
 
-    if isinstance(loc0, WholeBrain) or isinstance(loc1, WholeBrain):
-        raise NotImplementedError("Union of WholeBrains is not yet implemented.")
+    # All location types should be unionable among each other and this should
+    # be implemented here to avoid code repetition. Volumes are the only type of
+    # location that has its own union method since it is not a part of locations
+    # module and to avoid importing Volume here.
+    if not all(
+        isinstance(loc, (Point, PointCloud, BoundingBox)) for loc in [loc0, loc1]
+    ):
+        try:
+            return loc1.union(loc0)
+        except Exception:
+            raise NotImplementedError(f"There are no union method for {(loc0.__class__.__name__, loc1.__class__.__name__)}")
 
-    loc1_w = loc1.warp(loc0.space)  # adopt the space of the first location
+    # convert Points to PointClouds
+    loc0, loc1 = [
+        from_points([loc]) if isinstance(loc, Point) else loc
+        for loc in [loc0, loc1]
+    ]
 
-    if isinstance(loc0, Point):  # turn Points to PointSets
-        return reassign_union(
-            PointSet([loc0], space=loc0.space, sigma_mm=loc0.sigma), loc1_w
-        )
+    # adopt the space of the first location
+    loc1_w = loc1.warp(loc0.space)
 
-    if isinstance(loc0, PointSet):
-        if isinstance(loc1_w, PointSet):
-            points = set(loc0.points + loc1_w.points)
-            return PointSet(
-                points,
-                space=loc0.space,
-                sigma_mm=[p.sigma for p in points],
-            )
+    if isinstance(loc0, PointCloud):
+        if isinstance(loc1_w, PointCloud):
+            points = list(dict.fromkeys([*loc0, *loc1_w]))
+            return from_points(points)
         if isinstance(loc1_w, BoundingBox):
             return reassign_union(loc0.boundingbox, loc1_w)
 
     if isinstance(loc0, BoundingBox) and isinstance(loc1_w, BoundingBox):
-        points = [loc0.minpoint, loc0.maxpoint, loc1_w.minpoint, loc1_w.maxpoint]
+        coordinates = [loc0.minpoint, loc0.maxpoint, loc1_w.minpoint, loc1_w.maxpoint]
         return BoundingBox(
-            point1=[min(p[i] for p in points) for i in range(3)],
-            point2=[max(p[i] for p in points) for i in range(3)],
+            point1=[min(p[i] for p in coordinates) for i in range(3)],
+            point2=[max(p[i] for p in coordinates) for i in range(3)],
             space=loc0.space,
             sigma_mm=[loc0.minpoint.sigma, loc0.maxpoint.sigma]
         )

siibra/locations/boundingbox.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -14,14 +14,19 @@
 # limitations under the License.
 """A box defined by two farthest corner coordinates on a specific space."""
 
-from . import point, pointset, location, boundingbox
+from . import point, pointcloud, location
 
 from ..commons import logger
+from ..exceptions import SpaceWarpingFailedError
 
+from itertools import product
 import hashlib
 import numpy as np
-from typing import Union
-from nibabel import Nifti1Image
+from typing import TYPE_CHECKING, Union
+if TYPE_CHECKING:
+    from ..core.structure import BrainStructure
+    from nibabel import Nifti1Image
+    from ..core.space import Space
 
 
 class BoundingBox(location.Location):
@@ -32,13 +37,18 @@ class BoundingBox(location.Location):
     from the two corner points.
     """
 
-    def __init__(self, point1, point2, space=None, minsize: float = None, sigma_mm=None):
+    def __init__(
+        self,
+        point1,
+        point2,
+        space: Union[str, 'Space'] = None,
+        minsize: float = None,
+        sigma_mm=None
+    ):
         """
         Construct a new bounding box spanned by two 3D coordinates
         in the given reference space.
 
-        TODO allow to pass sigma for the points, if tuples
-
         Parameters
         ----------
         point1 : Point or 3-tuple
@@ -53,6 +63,7 @@ class BoundingBox(location.Location):
         sigma_mm : float, or list of float
             Optional standard deviation of the spanning point locations.
         """
+        # TODO: allow to pass sigma for the points, if tuples
         location.Location.__init__(self, space)
         xyz1 = point.Point.parse(point1)
         xyz2 = point.Point.parse(point2)
@@ -65,6 +76,7 @@ class BoundingBox(location.Location):
             s1, s2 = sigma_mm
         else:
             raise ValueError(f"Cannot interpret sigma_mm parameter value {sigma_mm} for bounding box")
+        self.sigma_mm = [s1, s2]
         self.minpoint = point.Point([min(xyz1[i], xyz2[i]) for i in range(3)], space, sigma_mm=s1)
         self.maxpoint = point.Point([max(xyz1[i], xyz2[i]) for i in range(3)], space, sigma_mm=s2)
         if minsize is not None:
@@ -72,129 +84,83 @@ class BoundingBox(location.Location):
                 if self.shape[d] < minsize:
                     self.maxpoint[d] = self.minpoint[d] + minsize
 
+        if self.volume == 0:
+            logger.warning(f"Zero-volume bounding box from points {point1} and {point2} in {self.space} space.")
+
     @property
     def id(self) -> str:
         return hashlib.md5(str(self).encode("utf-8")).hexdigest()
 
     @property
-    def volume(self):
+    def volume(self) -> float:
+        """The volume of the boundingbox in mm^3"""
         return np.prod(self.shape)
 
     @property
-    def center(self):
+    def center(self) -> 'point.Point':
         return self.minpoint + (self.maxpoint - self.minpoint) / 2
 
     @property
-    def shape(self):
+    def shape(self) -> float:
+        """The distances of the diagonal points in each axis. (Accounts for sigma)."""
         return tuple(
             (self.maxpoint + self.maxpoint.sigma)
             - (self.minpoint - self.minpoint.sigma)
         )
 
     @property
-    def is_planar(self):
+    def is_planar(self) -> bool:
         return any(d == 0 for d in self.shape)
 
-    @staticmethod
-    def _determine_bounds(A, threshold=0):
-        """
-        Bounding box of nonzero values in a 3D array.
-        https://stackoverflow.com/questions/31400769/bounding-box-of-numpy-array
-        """
-        x = np.any(A > threshold, axis=(1, 2))
-        y = np.any(A > threshold, axis=(0, 2))
-        z = np.any(A > threshold, axis=(0, 1))
-        nzx, nzy, nzz = [np.where(v) for v in (x, y, z)]
-        if any(len(nz[0]) == 0 for nz in [nzx, nzy, nzz]):
-            # empty array
-            return None
-        xmin, xmax = nzx[0][[0, -1]]
-        ymin, ymax = nzy[0][[0, -1]]
-        zmin, zmax = nzz[0][[0, -1]]
-        return np.array([[xmin, xmax + 1], [ymin, ymax + 1], [zmin, zmax + 1], [1, 1]])
-
-    @classmethod
-    def from_image(cls, image: Nifti1Image, space, ignore_affine=False, threshold=0):
-        """Construct a bounding box from a nifti image"""
-        bounds = cls._determine_bounds(image.get_fdata(), threshold=threshold)
-        if bounds is None:
-            return None
-        if ignore_affine:
-            target_space = None
-        else:
-            bounds = np.dot(image.affine, bounds)
-            target_space = space
-        return BoundingBox(point1=bounds[:3, 0], point2=bounds[:3, 1], space=target_space)
-
     def __str__(self):
         if self.space is None:
             return (
-                f"Bounding box from ({','.join(f'{v:.2f}' for v in self.minpoint)}) mm "
-                f"to ({','.join(f'{v:.2f}' for v in self.maxpoint)}) mm"
+                f"Bounding box from ({','.join(f'{v:.2f}' for v in self.minpoint)})mm "
+                f"to ({','.join(f'{v:.2f}' for v in self.maxpoint)})mm"
             )
         else:
             return (
-                f"Bounding box from ({','.join(f'{v:.2f}' for v in self.minpoint)}) mm "
+                f"Bounding box from ({','.join(f'{v:.2f}' for v in self.minpoint)})mm "
                 f"to ({','.join(f'{v:.2f}' for v in self.maxpoint)})mm in {self.space.name} space"
             )
 
-    def contains(self, other: location.Location):
-        """Returns true if the bounding box contains the given location."""
-        if isinstance(other, point.Point):
-            return (other >= self.minpoint) and (other <= self.maxpoint)
-        elif isinstance(other, pointset.PointSet):
-            return all(self.contains(p) for p in other)
-        elif isinstance(other, boundingbox.BoundingBox):
-            return all([
-                other.minpoint >= self.minpoint,
-                other.maxpoint <= self.maxpoint
-            ])
-        elif isinstance(other, Nifti1Image):
-            return self.contains(BoundingBox.from_image(other, space=self.space))
-        else:
-            raise NotImplementedError(
-                f"Cannot test containedness of {type(other)} in {self.__class__.__name__}"
-            )
-
-    def contained_in(self, other: Union[location.Location, Nifti1Image]):
-        if isinstance(other, location.Location):
-            return other.contains(self)
-        elif isinstance(other, Nifti1Image):
-            return self.contained_in(BoundingBox.from_image(other, space=self.space))
-        else:
-            raise RuntimeError(f"Cannot test containedness of {self} in type {other.__class__}")
-
-    def intersects(self, other: Union[location.Location, Nifti1Image]):
-        intersection = self.intersection(other)
-        if intersection is None:
-            return False
-        else:
-            return intersection.volume > 0
-
-    def intersection(self, other, dims=[0, 1, 2], threshold=0):
+    def intersection(self, other: 'BrainStructure', dims=[0, 1, 2]):
         """Computes the intersection of this bounding box with another one.
 
-        TODO process the sigma values o the points
-
-        Args:
-            other (BoundingBox): Another bounding box
-            dims (list of int): Dimensions where the intersection should be computed (applies only to bounding boxes)
-            Default: all three. Along dimensions not listed, the union is applied instead.
-            threshold: optional intensity threshold for intersecting with image mask
+        Parameters
+        ----------
+        other: BrainStructure
+        dims: List[int], default: all three
+            Dimensions where the intersection should be computed
+            (applies only to bounding boxes). Along dimensions not listed,
+            the union is applied instead.
         """
-        if isinstance(other, Nifti1Image):
-            return self._intersect_mask(other, threshold=threshold)
-        elif isinstance(other, BoundingBox):
-            return self._intersect_bbox(other, dims)
-        else:
-            raise NotImplementedError(
-                f"Intersection of bounding box with {type(other)} not implemented."
+        # TODO: process the sigma values o the points
+        if isinstance(other, BoundingBox):
+            try:
+                return self._intersect_bbox(other, dims)
+            except SpaceWarpingFailedError:
+                return other._intersect_bbox(self, dims)  # TODO: check this mechanism carefully
+        if isinstance(other, point.Point):
+            warped = other.warp(self.space)
+            return other if self.minpoint <= warped <= self.maxpoint else None
+        if isinstance(other, pointcloud.PointCloud):
+            points_inside = [p for p in other if self.intersects(p)]
+            if len(points_inside) == 0:
+                return None
+            result = pointcloud.PointCloud(
+                points_inside,
+                space=other.space,
+                sigma_mm=[p.sigma for p in points_inside]
             )
+            return result[0] if len(result) == 1 else result  # if PointCloud has single point return as a Point
+
+        return other.intersection(self)
 
-    def _intersect_bbox(self, other, dims=[0, 1, 2]):
+    def _intersect_bbox(self, other: 'BoundingBox', dims=[0, 1, 2]):
         warped = other.warp(self.space)
 
-        # Determine the intersecting bounding box by sorting
+        # Determine the intersecting bounsding box by sorting
         # the coordinates of both bounding boxes for each dimension,
         # and fetching the second and third coordinate after sorting.
         # If those belong to a minimum and maximum point,
@@ -222,14 +188,20 @@ class BoundingBox(location.Location):
                 result_minpt.append(A[dim])
                 result_maxpt.append(B[dim])
 
+        if result_minpt == result_maxpt:
+            return result_minpt
+
         bbox = BoundingBox(
             point1=point.Point(result_minpt, self.space),
             point2=point.Point(result_maxpt, self.space),
             space=self.space,
         )
-        return bbox if bbox.volume > 0 else None
 
-    def _intersect_mask(self, mask, threshold=0):
+        if bbox.volume == 0 and sum(cmin == cmax for cmin, cmax in zip(result_minpt, result_maxpt)) == 2:
+            return None
+        return bbox
+
+    def _intersect_mask(self, mask: 'Nifti1Image', threshold=0):
         """Intersect this bounding box with an image mask. Returns None if they do not intersect.
 
         TODO process the sigma values o the points
@@ -268,8 +240,8 @@ class BoundingBox(location.Location):
             )
         else:
             return self._intersect_bbox(
-                pointset
-                .PointSet(XYZ, space=self.space, sigma_mm=voxel_size.max())
+                pointcloud
+                .PointCloud(XYZ, space=self.space, sigma_mm=voxel_size.max())
                 .boundingbox
             )
 
@@ -284,6 +256,35 @@ class BoundingBox(location.Location):
             sigma_mm=[self.minpoint.sigma, self.maxpoint.sigma]
         )
 
+    @property
+    def corners(self):
+        """
+        Returns all 8 corners of the box as a pointcloud.
+
+        Note
+        ----
+        x0, y0, z0 = self.minpoint
+        x1, y1, z1 = self.maxpoint
+        all_corners = [
+            (x0, y0, z0),
+            (x1, y0, z0),
+            (x0, y1, z0),
+            (x1, y1, z0),
+            (x0, y0, z1),
+            (x1, y0, z1),
+            (x0, y1, z1),
+            (x1, y1, z1)
+        ]
+
+        TODO: deal with sigma. Currently, returns the mean of min and max point.
+        """
+        xs, ys, zs = zip(self.minpoint, self.maxpoint)
+        return pointcloud.PointCloud(
+            coordinates=[[x, y, z] for x, y, z in product(xs, ys, zs)],
+            space=self.space,
+            sigma_mm=np.mean([self.minpoint.sigma, self.maxpoint.sigma])
+        )
+
     def warp(self, space):
         """Returns a new bounding box obtained by warping the
         min- and maxpoint of this one into the new target space.
@@ -296,27 +297,10 @@ class BoundingBox(location.Location):
             return self
         else:
             try:
-                return self.__class__(
-                    point1=self.minpoint.warp(spaceobj),
-                    point2=self.maxpoint.warp(spaceobj),
-                    space=spaceobj,
-                )
-            except ValueError:
-                logger.debug(f"Warping {str(self)} to {spaceobj.name} not successful.")
-                return None
-
-    def fetch_regional_map(self):
-        """Generate a volumetric binary mask of this
-        bounding box in the reference template space."""
-        tpl = self.space.get_template().fetch()
-        arr = np.zeros(tpl.shape, dtype="uint8")
-        bbvox = self.transform(np.linalg.inv(tpl.affine))
-        arr[
-            int(bbvox.minpoint[0]): int(bbvox.maxpoint[0]),
-            int(bbvox.minpoint[1]): int(bbvox.maxpoint[2]),
-            int(bbvox.minpoint[2]): int(bbvox.maxpoint[2]),
-        ] = 1
-        return Nifti1Image(arr, tpl.affine)
+                warped_corners = self.corners.warp(spaceobj)
+            except SpaceWarpingFailedError:
+                raise SpaceWarpingFailedError(f"Warping {str(self)} to {spaceobj.name} not successful.")
+            return warped_corners.boundingbox
 
     def transform(self, affine: np.ndarray, space=None):
         """Returns a new bounding box obtained by transforming the
@@ -335,12 +319,9 @@ class BoundingBox(location.Location):
         """
         from ..core.space import Space
         spaceobj = Space.get_instance(space)
-        return self.__class__(
-            point1=self.minpoint.transform(affine, spaceobj),
-            point2=self.maxpoint.transform(affine, spaceobj),
-            space=space,
-            sigma_mm=[self.minpoint.sigma, self.maxpoint.sigma]  # TODO: error propagation
-        )
+        result = self.corners.transform(affine, spaceobj).boundingbox
+        result.sigma_mm = [self.minpoint.sigma, self.maxpoint.sigma]  # TODO: error propagation
+        return result
 
     def shift(self, offset):
         return self.__class__(
@@ -379,7 +360,7 @@ class BoundingBox(location.Location):
         x1, y1, z1 = self.maxpoint
 
         # set of 8 corner points in source space
-        corners1 = pointset.PointSet(
+        corners1 = pointcloud.PointCloud(
             [
                 (x0, y0, z0),
                 (x0, y0, z1),
@@ -426,3 +407,48 @@ class BoundingBox(location.Location):
     def __iter__(self):
         """Iterate the min- and maxpoint of this bounding box."""
         return iter((self.minpoint, self.maxpoint))
+
+    def __eq__(self, other: 'BoundingBox'):
+        if not isinstance(other, BoundingBox):
+            return False
+        return self.minpoint == other.minpoint and self.maxpoint == other.maxpoint
+
+    def __hash__(self):
+        return super().__hash__()
+
+
+def _determine_bounds(masked_array: np.ndarray, background: float = 0.0):
+    """
+    Bounding box of nonzero (background) values in a 3D array.
+
+    https://stackoverflow.com/questions/31400769/bounding-box-of-numpy-array
+    """
+    x = np.any(masked_array != background, axis=(1, 2))
+    y = np.any(masked_array != background, axis=(0, 2))
+    z = np.any(masked_array != background, axis=(0, 1))
+    nzx, nzy, nzz = [np.where(v) for v in (x, y, z)]
+    if any(len(nz[0]) == 0 for nz in [nzx, nzy, nzz]):
+        # empty array
+        return None
+    xmin, xmax = nzx[0][[0, -1]]
+    ymin, ymax = nzy[0][[0, -1]]
+    zmin, zmax = nzz[0][[0, -1]]
+    return np.array([[xmin, xmax + 1], [ymin, ymax + 1], [zmin, zmax + 1], [1, 1]])
+
+
+def from_array(
+    array: np.ndarray,
+    background: Union[int, float] = 0.0,
+    space: "Space" = None
+) -> BoundingBox:
+    """
+    Find the bounding box of non-background values for any 3D array.
+
+    Parameters
+    ----------
+    array: np.ndarray
+    background: int or float, default: 0.0
+    space: Space, default: None
+    """
+    bounds = _determine_bounds(array, background)
+    return BoundingBox(point1=bounds[:3, 0], point2=bounds[:3, 1], space=space)

siibra/locations/location.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,15 +12,21 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-"""Concpets that have primarily spatial meaning."""
+"""Concepts that have primarily spatial meaning."""
+
+from __future__ import annotations
+
+from ..core.structure import BrainStructure
 
 import numpy as np
-from abc import ABC, abstractmethod
-from nibabel import Nifti1Image
-from typing import Union
+from abc import abstractmethod
+
+from typing import TYPE_CHECKING, Union, Dict
+if TYPE_CHECKING:
+    from siibra.core.space import Space
 
 
-class Location(ABC):
+class Location(BrainStructure):
     """
     Abstract base class for locations in a given reference space.
     """
@@ -37,26 +43,23 @@ class Location(ABC):
 
     # The id of BigBrain reference space
     BIGBRAIN_ID = "minds/core/referencespace/v1.0.0/a1655b99-82f1-420f-a3c2-fe80fd4c8588"
-
-    def __init__(self, space):
-        from ..core.space import Space
-        self.space = Space.get_instance(space)
-
-    @abstractmethod
-    def intersection(self, mask: Nifti1Image) -> bool:
-        """All subclasses of Location must implement intersection, as it is required by SpatialFeature._test_mask()
-        """
-        pass
-
-    @abstractmethod
-    def intersects(self, other: Union[Nifti1Image, 'Location']) -> bool:
-        """
-        Verifies wether this 3D location intersects the given mask.
-
-        NOTE: The affine matrix of the image must be set to warp voxels
-        coordinates into the reference space of this Bounding Box.
-        """
-        raise NotImplementedError
+    _MASK_MEMO = {}  # cache region masks for Location._assign_region()
+    _ASSIGNMENT_CACHE = {}  # caches assignment results, see Region.assign()
+
+    def __init__(self, spacespec: Union[str, Dict[str, str], "Space"]):
+        self._space_spec = spacespec
+        self._space_cached = None
+
+    @property
+    def space(self):
+        if self._space_cached is None:
+            from ..core.space import Space
+            if isinstance(self._space_spec, dict):
+                spec = self._space_spec.get("@id") or self._space_spec.get("name")
+                self._space_cached = Space.get_instance(spec)
+            else:
+                self._space_cached = Space.get_instance(self._space_spec)
+        return self._space_cached
 
     @abstractmethod
     def warp(self, space):
@@ -80,26 +83,26 @@ class Location(ABC):
         """
         pass
 
-    @abstractmethod
-    def __iter__(self):
-        """To be implemented in derived classes to return an iterator
-        over the coordinates associated with the location."""
-        pass
+    @property
+    def species(self):
+        return None if self.space is None else self.space.species
 
     def __str__(self):
-        if self.space is None:
-            return (
-                f"{self.__class__.__name__} "
-                f"[{','.join(str(l) for l in iter(self))}]"
-            )
-        else:
-            return (
-                f"{self.__class__.__name__} in {self.space.name} "
-                f"[{','.join(str(l) for l in iter(self))}]"
-            )
+        space_str = "" if self.space is None else f" in {self.space.name}"
+        coord_str = "" if len(self) == 0 else f" [{','.join(str(pt) for pt in iter(self))}]"
+        return f"{self.__class__.__name__}{space_str}{coord_str}"
 
     def __repr__(self):
-        return f"{self.__class__.__name__}: {self}"
+        spacespec = f"'{self.space.id}'" if self.space else None
+        return f"<{self.__class__.__name__}({[point.__repr__() for point in self]}), space={spacespec}>"
+
+    def __hash__(self) -> int:
+        return hash(self.__repr__())
+
+    @abstractmethod
+    def __eq__(self):
+        """Required to provide comparison and making the object hashable"""
+        raise NotImplementedError
 
     @staticmethod
     def union(loc0: 'Location', loc1: 'Location') -> 'Location':
@@ -110,41 +113,3 @@ class Location(ABC):
         raise NotImplementedError(
             "This method is designed to be reassigned at the module level"
         )
-
-
-class WholeBrain(Location):
-    """
-    Trivial location class for formally representing
-    location in a particular reference space, which
-    is not further specified.
-    """
-
-    def intersection(self, mask: Nifti1Image) -> bool:
-        """
-        Required for abstract class Location
-        """
-        return True
-
-    def __init__(self, space=None):
-        Location.__init__(self, space)
-
-    def intersects(self, *_args, **_kwargs):
-        """Always true for whole brain features"""
-        return True
-
-    def warp(self, space):
-        """Generates a new whole brain location
-        in another reference space."""
-        return self.__class__(space)
-
-    def transform(self, affine: np.ndarray, space=None):
-        """Does nothing."""
-        pass
-
-    def __iter__(self):
-        """To be implemented in derived classes to return an iterator
-        over the coordinates associated with the location."""
-        yield from ()
-
-    def __str__(self):
-        return f"{self.__class__.__name__} in {self.space.name}"