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

siibra/features/connectivity/regional_connectivity.py

@@ -21,7 +21,7 @@ from .. import anchor as _anchor
 
 from ...commons import logger, QUIET, siibra_tqdm
 from ...core import region as _region
-from ...locations import pointset
+from ...locations import pointcloud
 from ...retrieval.repositories import RepositoryConnector
 from ...retrieval.requests import HttpRequest
 
@@ -440,7 +440,7 @@ class RegionalConnectivity(Feature, Compoundable):
                 found = [r for r in region if r.name in all_centroids]
             assert len(found) > 0
             result.append(
-                tuple(pointset.PointSet(
+                tuple(pointcloud.PointCloud(
                     [all_centroids[r.name] for r in found], space=space
                 ).centroid)
             )

siibra/features/feature.py

@@ -251,13 +251,16 @@ class Feature:
         """ Removes all instantiated object instances"""
         cls._preconfigured_instances = None
 
-    def matches(self, concept: structure.BrainStructure, restrict_space: bool = False) -> bool:
+    def matches(
+        self,
+        concept: Union[structure.BrainStructure, space.Space],
+    ) -> bool:
         """
         Match the features anatomical anchor agains the given query concept.
         Record the most recently matched concept for inspection by the caller.
         """
         # TODO: storing the last matched concept. It is not ideal, might cause problems in multithreading
-        if self.anchor and self.anchor.matches(concept, restrict_space):
+        if self.anchor and self.anchor.matches(concept):
             self.anchor._last_matched_concept = concept
             return True
         self.anchor._last_matched_concept = None
@@ -483,10 +486,10 @@ class Feature:
                 f"objects linked to {str(concept)}{argstr}"
             )
             q = QueryType(**kwargs)
-            try:
+            if isinstance(concept, space.Space):
+                features = q.query(concept.get_template())
+            else:
                 features = q.query(concept)
-            except StopIteration:
-                continue
             live_instances.extend(
                 Feature._wrap_livequery_feature(f, Feature._serialize_query_context(f, concept))
                 for f in features
@@ -497,9 +500,8 @@ class Feature:
     @classmethod
     def _match(
         cls,
-        concept: structure.BrainStructure,
+        concept: Union[structure.BrainStructure, space.Space],
         feature_type: Union[str, Type['Feature'], list],
-        restrict_space: bool = False,
         **kwargs
     ) -> List['Feature']:
         """
@@ -518,10 +520,6 @@ class Feature:
             An anatomical concept, typically a brain region or parcellation.
         feature_type: subclass of Feature, str
             specififies the type of features ("modality")
-        restrict_space: bool: default: False
-            If true, will skip features anchored at spatial locations of
-            different spaces than the concept. Requires concept to be a
-            Location.
         """
         if isinstance(feature_type, list):
             # a list of feature types is given, collect match results on those
@@ -531,7 +529,7 @@ class Feature:
             )
             return list(dict.fromkeys(
                 sum((
-                    cls._match(concept, t, restrict_space, **kwargs) for t in feature_type
+                    cls._match(concept, t, **kwargs) for t in feature_type
                 ), [])
             ))
 
@@ -548,15 +546,15 @@ class Feature:
                 f"'{feature_type}' decoded as feature type/s: "
                 f"{[c.__name__ for c in ftype_candidates]}."
             )
-            return cls._match(concept, ftype_candidates, restrict_space, **kwargs)
+            return cls._match(concept, ftype_candidates, **kwargs)
 
         assert issubclass(feature_type, Feature)
 
         # At this stage, no recursion is needed.
         # We expect a specific supported feature type is to be matched now.
-        if not isinstance(concept, structure.BrainStructure):
+        if not isinstance(concept, (structure.BrainStructure, space.Space)):
             raise ValueError(
-                f"{concept.__class__.__name__} cannot be used for feature queries as it is not a BrainStructure type."
+                f"{concept.__class__.__name__} cannot be used for feature queries as it is not a `BrainStructure` or a `Space` type."
             )
 
         # Collect any preconfigured instances of the requested feature type
@@ -574,7 +572,7 @@ class Feature:
                 total=len(instances),
                 disable=(not instances)
             )
-            if f.matches(concept, restrict_space)
+            if f.matches(concept)
         ]
 
         # Then run any registered live queries for the requested feature type

siibra/features/tabular/bigbrain_intensity_profile.py

@@ -65,7 +65,7 @@ class BigBrainIntensityProfile(
 
     @classmethod
     def _merge_anchors(cls, anchors: List['AnatomicalAnchor']):
-        from ...locations.pointset import from_points
+        from ...locations.pointcloud import from_points
         from ...features.anchor import AnatomicalAnchor
 
         location = from_points([anchor.location for anchor in anchors])

siibra/features/tabular/cell_density_profile.py

@@ -16,15 +16,77 @@
 from . import cortical_profile
 
 from .. import anchor as _anchor
-from ...commons import PolyLine, logger, create_key
+from ...commons import logger
 from ...retrieval import requests
 
 from skimage.draw import polygon
 from skimage.transform import resize
-from io import BytesIO
 import numpy as np
 import pandas as pd
 
+from io import BytesIO
+from typing import Union, Tuple, Iterable
+
+
+def cell_reader(bytes_buffer: bytes):
+    return pd.read_csv(BytesIO(bytes_buffer[2:]), delimiter=" ", header=0).astype(
+        {"layer": int, "label": int}
+    )
+
+
+def layer_reader(bytes_buffer: bytes):
+    return pd.read_csv(BytesIO(bytes_buffer[2:]), delimiter=" ", header=0, index_col=0)
+
+
+def poly_srt(poly):
+    return poly[poly[:, 0].argsort(), :]
+
+
+def poly_rev(poly):
+    return poly[poly[:, 0].argsort()[::-1], :]
+
+
+class PolyLine:
+    """Simple polyline representation which allows equidistant sampling."""
+
+    def __init__(self, pts):
+        self.pts = pts
+        self.lengths = [
+            np.sqrt(np.sum((pts[i, :] - pts[i - 1, :]) ** 2))
+            for i in range(1, pts.shape[0])
+        ]
+
+    def length(self):
+        return sum(self.lengths)
+
+    def sample(self, d: Union[Iterable[float], np.ndarray, float]):
+        # if d is interable, we assume a list of sample positions
+        try:
+            iter(d)
+        except TypeError:
+            positions = [d]
+        else:
+            positions = d
+
+        samples = []
+        for s_ in positions:
+            s = min(max(s_, 0), 1)
+            target_distance = s * self.length()
+            current_distance = 0
+            for i, length in enumerate(self.lengths):
+                current_distance += length
+                if current_distance >= target_distance:
+                    p1 = self.pts[i, :]
+                    p2 = self.pts[i + 1, :]
+                    r = (target_distance - current_distance + length) / length
+                    samples.append(p1 + (p2 - p1) * r)
+                    break
+
+        if len(samples) == 1:
+            return samples[0]
+        else:
+            return np.array(samples)
+
 
 class CellDensityProfile(
     cortical_profile.CorticalProfile,
@@ -45,24 +107,6 @@ class CellDensityProfile(
 
     _filter_attrs = cortical_profile.CorticalProfile._filter_attrs + ["location"]
 
-    @classmethod
-    def CELL_READER(cls, b):
-        return pd.read_csv(BytesIO(b[2:]), delimiter=" ", header=0).astype(
-            {"layer": int, "label": int}
-        )
-
-    @classmethod
-    def LAYER_READER(cls, b):
-        return pd.read_csv(BytesIO(b[2:]), delimiter=" ", header=0, index_col=0)
-
-    @staticmethod
-    def poly_srt(poly):
-        return poly[poly[:, 0].argsort(), :]
-
-    @staticmethod
-    def poly_rev(poly):
-        return poly[poly[:, 0].argsort()[::-1], :]
-
     def __init__(
         self,
         section: int,
@@ -89,9 +133,9 @@ class CellDensityProfile(
         )
         self._step = 0.01
         self._url = url
-        self._cell_loader = requests.HttpRequest(url, self.CELL_READER)
+        self._cell_loader = requests.HttpRequest(url, cell_reader)
         self._layer_loader = requests.HttpRequest(
-            url.replace("segments", "layerinfo"), self.LAYER_READER
+            url.replace("segments", "layerinfo"), layer_reader
         )
         self._density_image = None
         self._layer_mask = None
@@ -105,47 +149,49 @@ class CellDensityProfile(
 
     @property
     def shape(self):
-        return tuple(self.cells[["y", "x"]].max().astype("int") + 1)
+        """(y,x)"""
+        return tuple(np.ceil(self.cells[["y", "x"]].max()).astype("int"))
 
-    def boundary_annotation(self, boundary):
+    def boundary_annotation(self, boundary: Tuple[int, int]) -> np.ndarray:
         """Returns the annotation of a specific layer boundary."""
-        y1, x1 = self.shape
+        shape_y, shape_x = self.shape
 
         # start of image patch
         if boundary == (-1, 0):
-            return np.array([[0, 0], [x1, 0]])
+            return np.array([[0, 0], [shape_x, 0]])
 
         # end of image patch
         if boundary == (7, 8):
-            return np.array([[0, y1], [x1, y1]])
+            return np.array([[0, shape_y], [shape_x, shape_y]])
 
         # retrieve polygon
         basename = "{}_{}.json".format(
             *(self.LAYERS[layer] for layer in boundary)
         ).replace("0_I", "0")
-        url = self._url.replace("segments.txt", basename)
-        poly = self.poly_srt(np.array(requests.HttpRequest(url).get()["segments"]))
+        poly_url = self._url.replace("segments.txt", basename)
+        poly = poly_srt(np.array(requests.HttpRequest(poly_url).get()["segments"]))
 
-        # ensure full width
+        # ensure full width and trim to the image shape
         poly[0, 0] = 0
-        poly[-1, 0] = x1
+        poly[poly[:, 0] > shape_x, 0] = shape_x
+        poly[poly[:, 1] > shape_y, 1] = shape_y
 
         return poly
 
-    def layer_annotation(self, layer):
+    def layer_annotation(self, layer: int) -> np.ndarray:
         return np.vstack(
             (
                 self.boundary_annotation((layer - 1, layer)),
-                self.poly_rev(self.boundary_annotation((layer, layer + 1))),
+                poly_rev(self.boundary_annotation((layer, layer + 1))),
                 self.boundary_annotation((layer - 1, layer))[0, :],
             )
         )
 
     @property
-    def layer_mask(self):
+    def layer_mask(self) -> np.ndarray:
         """Generates a layer mask from boundary annotations."""
         if self._layer_mask is None:
-            self._layer_mask = np.zeros(np.array(self.shape).astype("int") + 1)
+            self._layer_mask = np.zeros(np.array(self.shape, dtype=int) + 1, dtype="int")
             for layer in range(1, 8):
                 pl = self.layer_annotation(layer)
                 X, Y = polygon(pl[:, 0], pl[:, 1])
@@ -153,20 +199,20 @@ class CellDensityProfile(
         return self._layer_mask
 
     @property
-    def depth_image(self):
+    def depth_image(self) -> np.ndarray:
         """Cortical depth image from layer boundary polygons by equidistant sampling."""
 
         if self._depth_image is None:
-
+            logger.info("Calculating cell densities from cell and layer data...")
             # compute equidistant cortical depth image from inner and outer contour
             scale = 0.1
-            D = np.zeros((np.array(self.density_image.shape) * scale).astype("int") + 1)
+            depth_arr = np.zeros(np.ceil(np.array(self.shape) * scale).astype("int") + 1)
 
             # determine sufficient stepwidth for profile sampling
             # to match downscaled image resolution
-            vstep, hstep = 1.0 / np.array(D.shape) / 2.0
+            vstep, hstep = 1.0 / np.array(depth_arr.shape) / 2.0
             vsteps = np.arange(0, 1 + vstep, vstep)
-            hsteps = np.arange(0, 1 + vstep, hstep)
+            hsteps = np.arange(0, 1 + hstep, hstep)
 
             # build straight profiles between outer and inner cortical boundary
             s0 = PolyLine(self.boundary_annotation((0, 1)) * scale).sample(hsteps)
@@ -175,16 +221,16 @@ class CellDensityProfile(
 
             # write sample depths to their location in the depth image
             for prof in profiles:
-                XY = prof.sample(vsteps).astype("int")
-                D[XY[:, 1], XY[:, 0]] = vsteps
+                prof_samples_as_index = prof.sample(vsteps).astype("int")
+                depth_arr[prof_samples_as_index[:, 1], prof_samples_as_index[:, 0]] = vsteps
 
             # fix wm region, account for rounding error
             XY = self.layer_annotation(7) * scale
-            D[polygon(XY[:, 1] - 1, XY[:, 0])] = 1
-            D[-1, :] = 1
+            depth_arr[polygon(XY[:, 1] - 1, XY[:, 0])] = 1
+            depth_arr[-1, :] = 1
 
             # rescale depth image to original patch size
-            self._depth_image = resize(D, self.density_image.shape)
+            self._depth_image = resize(depth_arr, self.density_image.shape)
 
         return self._depth_image
 
@@ -200,7 +246,7 @@ class CellDensityProfile(
         return self._boundary_positions
 
     @property
-    def density_image(self):
+    def density_image(self) -> np.ndarray:
         if self._density_image is None:
             logger.debug("Computing density image for", self._url)
             # we integrate cell counts into 2D bins
@@ -209,9 +255,7 @@ class CellDensityProfile(
             counts, xedges, yedges = np.histogram2d(
                 self.cells.y,
                 self.cells.x,
-                bins=(np.array(self.layer_mask.shape) / pixel_size_micron + 0.5).astype(
-                    "int"
-                ),
+                bins=np.round(np.array(self.shape) / pixel_size_micron).astype("int"),
             )
 
             # rescale the counts from count / pixel_size**2  to count / 0.1mm^3,
@@ -229,11 +273,11 @@ class CellDensityProfile(
         return self._density_image
 
     @property
-    def cells(self):
+    def cells(self) -> pd.DataFrame:
         return self._cell_loader.get()
 
     @property
-    def layers(self):
+    def layers(self) -> pd.DataFrame:
         return self._layer_loader.get()
 
     @property
@@ -242,6 +286,7 @@ class CellDensityProfile(
 
     @property
     def _values(self):
+        # TODO: release a dataset update instead of on the fly computation
         densities = []
         delta = self._step / 2.0
         for d in self._depths:
@@ -249,16 +294,5 @@ class CellDensityProfile(
             if np.sum(mask) > 0:
                 densities.append(self.density_image[mask].mean())
             else:
-                densities.append(np.NaN)
+                densities.append(np.nan)
         return np.asanyarray(densities)
-
-    @property
-    def key(self):
-        assert len(self.species) == 1
-        return create_key("{}_{}_{}_{}_{}".format(
-            self.id,
-            self.species[0]['name'],
-            self.regionspec,
-            self.section,
-            self.patch
-        ))

siibra/features/tabular/layerwise_cell_density.py

@@ -16,13 +16,13 @@
 from . import cortical_profile
 from .. import anchor as _anchor
 from . import tabular
+from ..tabular.cell_density_profile import cell_reader, layer_reader
 
 from ... import commons
 from ...retrieval import requests
 
 import pandas as pd
 import numpy as np
-from io import BytesIO
 
 
 class LayerwiseCellDensity(
@@ -40,16 +40,6 @@ class LayerwiseCellDensity(
         "The cortical depth is estimated from the measured layer thicknesses."
     )
 
-    @classmethod
-    def CELL_READER(cls, b):
-        return pd.read_csv(BytesIO(b[2:]), delimiter=" ", header=0).astype(
-            {"layer": int, "label": int}
-        )
-
-    @classmethod
-    def LAYER_READER(cls, b):
-        return pd.read_csv(BytesIO(b[2:]), delimiter=" ", header=0, index_col=0)
-
     def __init__(
         self,
         segmentfiles: list,
@@ -77,8 +67,8 @@ class LayerwiseCellDensity(
         density_dict = {}
         for i, (cellfile, layerfile) in enumerate(self._filepairs):
             try:
-                cells = requests.HttpRequest(cellfile, func=self.CELL_READER).data
-                layers = requests.HttpRequest(layerfile, func=self.LAYER_READER).data
+                cells = requests.HttpRequest(cellfile, func=cell_reader).data
+                layers = requests.HttpRequest(layerfile, func=layer_reader).data
             except requests.SiibraHttpRequestError as e:
                 print(str(e))
                 commons.logger.error(f"Skipping to bootstrap a {self.__class__.__name__} feature, cannot access file resource.")
@@ -103,12 +93,3 @@ class LayerwiseCellDensity(
             )
             self._data_cached.index.name = 'layer'
         return self._data_cached
-
-    @property
-    def key(self):
-        assert len(self.species) == 1
-        return commons.create_key("{}_{}_{}".format(
-            self.dataset_id,
-            self.species[0]['name'],
-            self.regionspec
-        ))

siibra/features/tabular/regional_timeseries_activity.py

@@ -19,7 +19,7 @@ from ..feature import Compoundable
 from ...core import region as _region
 from .. import anchor as _anchor
 from ...commons import QUIET, siibra_tqdm
-from ...locations import pointset
+from ...locations import pointcloud
 from ...retrieval.repositories import RepositoryConnector
 from ...retrieval.requests import HttpRequest
 
@@ -203,7 +203,7 @@ class RegionalTimeseriesActivity(tabular.Tabular, Compoundable):
                 found = [r for r in region if r.name in all_centroids]
             assert len(found) > 0
             result.append(
-                tuple(pointset.PointSet(
+                tuple(pointcloud.PointCloud(
                     [all_centroids[r.name] for r in found], space=space
                 ).centroid)
             )

siibra/livequeries/allen.py

@@ -20,11 +20,11 @@ from ..core import space as _space, structure
 from ..features import anchor as _anchor
 from ..features.tabular.gene_expression import GeneExpressions
 from ..commons import logger, Species
-from ..locations import point, pointset
+from ..locations import point, pointcloud
 from ..retrieval import HttpRequest
 from ..vocabularies import GENE_NAMES
 
-from typing import Iterable
+from typing import List
 from xml.etree import ElementTree
 import numpy as np
 import json
@@ -32,6 +32,24 @@ import json
 
 BASE_URL = "http://api.brain-map.org/api/v2/data"
 
+LOCATION_PRECISION_MM = 2.  # the assumed spatial precision of the probe locations in MNI space
+
+
+def is_allen_api_microarray_service_available():
+    import requests
+
+    # see https://community.brain-map.org/t/human-brain-atlas-api/2876
+    microarray_test_url = "http://api.brain-map.org/api/v2/data/query.json?criteria= service::human_microarray_expression[probes$eq1023146,1023147][donors$eq15496][structures$eq9148]"
+    try:
+        response = requests.get(microarray_test_url).json()
+    except requests.RequestException:
+        return False
+    return response["success"]
+
+
+class InvalidAllenAPIResponseException(Exception):
+    pass
+
 
 class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions):
     """
@@ -117,7 +135,14 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
 
         self.genes = parse_gene(gene)
 
-    def query(self, concept: structure.BrainStructure) -> Iterable[GeneExpressions]:
+    def query(self, concept: structure.BrainStructure) -> List[GeneExpressions]:
+        if not is_allen_api_microarray_service_available():
+            raise InvalidAllenAPIResponseException(
+                'The service "web API of the Allen Brain Atlas for the human microarray expression" '
+                'is not available at the moment, therefore siibra is not able to fetch '
+                'gene expression features. This is a known issue which we are investigating: '
+                'https://github.com/FZJ-INM1-BDA/siibra-python/issues/636.'
+            )
 
         mnispace = _space.Space.registry().get('mni152')
 
@@ -125,23 +150,21 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         # Record matched instances and their locations.
         measurements = []
         coordinates = []
-        points_inside = dict()
         for measurement in self:
-            pt = point.Point(measurement['mni_xyz'], space=mnispace)
-            if pt not in points_inside:  # cache redundant intersection tests
-                points_inside[pt] = pt in concept
-            if points_inside[pt]:
+            pt = point.Point(measurement['mni_xyz'], space=mnispace, sigma_mm=LOCATION_PRECISION_MM)
+            if pt in concept:
                 measurements.append(measurement)
                 coordinates.append(pt)
 
-        if len(points_inside) == 0:
-            raise StopIteration
+        if len(coordinates) == 0:
+            logger.info(f"No probes found that lie within {concept}")
+            return []
 
         # Build the anatomical anchor and assignment to the query concept.
         # It will be attached to the returned feature, with the set of matched
         # MNI coordinates as anchor's location.
         anchor = _anchor.AnatomicalAnchor(
-            location=pointset.from_points(coordinates),
+            location=pointcloud.from_points(coordinates),
             species=self.species
         )
         explanation = f"MNI coordinates of tissue samples were filtered using {concept}"
@@ -153,7 +176,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         )]
         anchor._last_matched_concept = concept
 
-        yield GeneExpressions(
+        return [GeneExpressions(
             anchor=anchor,
             genes=[m['gene'] for m in measurements],
             levels=[m['expression_level'] for m in measurements],
@@ -167,7 +190,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
                 "probe_id": [m['probe_id'] for m in measurements],
                 "donor_name": [m['donor_name'] for m in measurements],
             }
-        )
+        )]
 
     def __iter__(self):
 
@@ -261,7 +284,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         url = AllenBrainAtlasQuery._QUERY["specimen"].format(specimen_id=specimen_id)
         response = HttpRequest(url).get()
         if not response["success"]:
-            raise Exception(
+            raise InvalidAllenAPIResponseException(
                 "Invalid response when retrieving specimen information: {}".format(url)
             )
         # we ask for 1 specimen, so list should have length 1
@@ -278,7 +301,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         return specimen
 
     @classmethod
-    def _retrieve_microarray(cls, donor_id: str, probe_ids: str) -> Iterable[GeneExpressions]:
+    def _retrieve_microarray(cls, donor_id: str, probe_ids: str):
         """
         Retrieve microarray data for several probes of a given donor, and
         compute the MRI position of the corresponding tissue block in the ICBM
@@ -297,7 +320,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         except json.JSONDecodeError as e:
             raise RuntimeError(f"Allen institute site produced an empty response - please try again later.\n{e}")
         if not response["success"]:
-            raise Exception(
+            raise InvalidAllenAPIResponseException(
                 "Invalid response when retrieving microarray data: {}".format(url)
             )
 

siibra/livequeries/bigbrain.py

@@ -19,7 +19,7 @@ from . import query
 from ..features.tabular import bigbrain_intensity_profile, layerwise_bigbrain_intensities
 from ..features import anchor as _anchor
 from ..commons import logger
-from ..locations import point, pointset
+from ..locations import point, pointcloud
 from ..core import structure
 from ..retrieval import requests, cache
 from ..retrieval.datasets import GenericDataset
@@ -119,11 +119,11 @@ class BigBrainProfileQuery(query.LiveQuery, args=[], FeatureType=bigbrain_intens
 
     def query(self, concept: structure.BrainStructure, **kwargs) -> List[bigbrain_intensity_profile.BigBrainIntensityProfile]:
         loader = WagstylProfileLoader()
-        mesh_vertices = pointset.PointSet(loader._vertices, space='bigbrain')
-        matched = concept.intersection(mesh_vertices)  # returns a reduced PointSet with og indices as labels
+        mesh_vertices = pointcloud.PointCloud(loader._vertices, space='bigbrain')
+        matched = concept.intersection(mesh_vertices)  # returns a reduced PointCloud with og indices as labels
         if matched is None:
             return []
-        assert isinstance(matched, pointset.PointSet)
+        assert isinstance(matched, pointcloud.PointCloud)
         indices = matched.labels
         assert indices is not None
         features = []
@@ -159,11 +159,11 @@ class LayerwiseBigBrainIntensityQuery(query.LiveQuery, args=[], FeatureType=laye
     def query(self, concept: structure.BrainStructure, **kwargs) -> List[layerwise_bigbrain_intensities.LayerwiseBigBrainIntensities]:
 
         loader = WagstylProfileLoader()
-        mesh_vertices = pointset.PointSet(loader._vertices, space='bigbrain')
-        matched = concept.intersection(mesh_vertices)  # returns a reduced PointSet with og indices as labels
+        mesh_vertices = pointcloud.PointCloud(loader._vertices, space='bigbrain')
+        matched = concept.intersection(mesh_vertices)  # returns a reduced PointCloud with og indices as labels
         if matched is None:
             return []
-        assert isinstance(matched, pointset.PointSet)
+        assert isinstance(matched, pointcloud.PointCloud)
         indices = matched.labels
         assert indices is not None
         matched_profiles = loader._profiles[indices, :]
@@ -177,7 +177,7 @@ class LayerwiseBigBrainIntensityQuery(query.LiveQuery, args=[], FeatureType=laye
         ]).reshape((-1, 200))
 
         anchor = _anchor.AnatomicalAnchor(
-            location=pointset.PointSet(loader._vertices[indices, :], space='bigbrain'),
+            location=pointcloud.PointCloud(loader._vertices[indices, :], space='bigbrain'),
             region=str(concept),
             species='Homo sapiens'
         )

siibra/livequeries/query.py

@@ -47,4 +47,3 @@ class LiveQuery(ABC):
     @abstractmethod
     def query(self, concept: AtlasConcept, **kwargs) -> List[Feature]:
         raise NotImplementedError(f"Dervied class {self.__class__} needs to implement query()")
-        pass