siibra 1.0.1a0__py3-none-any.whl → 1.0.1a2__py3-none-any.whl

siibra/features/tabular/regional_timeseries_activity.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");
@@ -13,19 +13,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import Callable, List, Union
+
+import numpy as np
+import pandas as pd
+
 from . import tabular
+from .. import anchor as _anchor
 from ..feature import Compoundable
-
 from ...core import region as _region
-from .. import anchor as _anchor
 from ...commons import QUIET, siibra_tqdm
 from ...locations import pointcloud
-from ...retrieval.repositories import RepositoryConnector
 from ...retrieval.requests import HttpRequest
-
-from typing import Callable, List, Union
-import pandas as pd
-import numpy as np
+from ...retrieval.repositories import RepositoryConnector
 
 
 class RegionalTimeseriesActivity(tabular.Tabular, Compoundable):
@@ -239,7 +239,7 @@ class RegionalTimeseriesActivity(tabular.Tabular, Compoundable):
         backend="plotly", **kwargs
     ):
         """
-        Create a carpet plot ofthe timeseries data per region.
+        Create a carpet plot of the timeseries data per region.
 
         Parameters
         ----------

siibra/features/tabular/tabular.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");
@@ -15,15 +15,14 @@
 """Base type of features in tabular formats."""
 
 from zipfile import ZipFile
-from .. import feature
-
-from .. import anchor as _anchor
-
-from ... import commons
 
 import pandas as pd
 from textwrap import wrap
 
+from .. import feature
+from .. import anchor as _anchor
+from ...commons import logger
+
 
 class Tabular(feature.Feature):
     """
@@ -91,9 +90,11 @@ class Tabular(feature.Feature):
         if backend == "matplotlib":
             try:
                 import matplotlib.pyplot as plt
-            except ImportError:
-                commons.logger.error("matplotlib not available. Plotting of fingerprints disabled.")
-                return None
+            except ImportError as e:
+                logger.error(
+                    "matplotlib not available. Please install matplotlib or use or another backend such as plotly."
+                )
+                raise e
             # default kwargs
             if kwargs.get("error_y") is None:
                 kwargs["yerr"] = kwargs.get("yerr", 'std' if 'std' in self.data.columns else None)

siibra/livequeries/__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");

siibra/livequeries/allen.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");
@@ -14,21 +14,21 @@
 # limitations under the License.
 """Query Allen Human Brain Atlas microarray data in specified volume."""
 
-from .query import LiveQuery
+from typing import List
+from xml.etree import ElementTree
+import json
 
-from ..core import space as _space, structure
+import numpy as np
+
+from . import query as _query
+from ..core import structure
 from ..features import anchor as _anchor
 from ..features.tabular.gene_expression import GeneExpressions
 from ..commons import logger, Species
-from ..locations import point, pointcloud
+from ..locations import pointcloud
 from ..retrieval import HttpRequest
 from ..vocabularies import GENE_NAMES
 
-from typing import List
-from xml.etree import ElementTree
-import numpy as np
-import json
-
 
 BASE_URL = "http://api.brain-map.org/api/v2/data"
 
@@ -51,7 +51,7 @@ class InvalidAllenAPIResponseException(Exception):
     pass
 
 
-class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions):
+class AllenBrainAtlasQuery(_query.LiveQuery, args=['gene'], FeatureType=GeneExpressions):
     """
     Interface to Allen Human Brain Atlas microarray data.
 
@@ -66,7 +66,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
     - Each sample was subject to multiple (in fact 4) different probes.
     - The probe data structures contain the list of gene expression of a
       particular gene measured in each sample. Therefore the length of the gene
-      expression list in a probe coresponds to the number of samples taken in
+      expression list in a probe corresponds to the number of samples taken in
       the corresponding donor for the given gene.
     """
 
@@ -114,10 +114,10 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         Each sample is linked to a donor, brain structure, and
         ICBM coordinate.
         When querying with a brain structure, the ICBM coordinates
-        will be tested agains the region mask in ICBM space
+        will be tested against the region mask in ICBM space
         to produce a table of outputs.
         """
-        LiveQuery.__init__(self, **kwargs)
+        _query.LiveQuery.__init__(self, **kwargs)
         gene = kwargs.get('gene')
 
         def parse_gene(spec):
@@ -144,27 +144,25 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
                 'https://github.com/FZJ-INM1-BDA/siibra-python/issues/636.'
             )
 
-        mnispace = _space.Space.registry().get('mni152')
-
         # Match the microarray probes to the query mask.
         # Record matched instances and their locations.
-        measurements = []
-        coordinates = []
-        for measurement in self:
-            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(coordinates) == 0:
+        all_measurements = list(self)
+        all_mes_points = pointcloud.PointCloud(
+            [measurement['mni_xyz'] for measurement in all_measurements],
+            space='mni152',
+            sigma_mm=LOCATION_PRECISION_MM
+        )
+        intersecting_points = concept.intersection(all_mes_points)
+        if intersecting_points is None:
             logger.info(f"No probes found that lie within {concept}")
             return []
+        measurements = [all_measurements[index] for index in intersecting_points.labels]
 
         # 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=pointcloud.from_points(coordinates),
+            location=intersecting_points,
             species=self.species
         )
         explanation = f"MNI coordinates of tissue samples were filtered using {concept}"

siibra/livequeries/bigbrain.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");
@@ -12,21 +12,25 @@
 # 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.
-"""Matches BigBrain intesity profiles extracted by Wagstyl et al. to volumes."""
+"""Matches BigBrain intensity profiles extracted by Wagstyl et al. to volumes."""
 
-from . import query
+from typing import List
+from os import path
 
-from ..features.tabular import bigbrain_intensity_profile, layerwise_bigbrain_intensities
+import numpy as np
+from scipy.spatial import KDTree
+
+from . import query
 from ..features import anchor as _anchor
-from ..commons import logger
-from ..locations import point, pointcloud
+from ..features.tabular import bigbrain_intensity_profile, layerwise_bigbrain_intensities
+from ..features.image import CellbodyStainedSection, BigBrain1MicronPatch
+from ..commons import logger, siibra_tqdm
+from ..locations import point, pointcloud, location, experimental
 from ..core import structure
+from ..core.concept import get_registry
 from ..retrieval import requests, cache
 from ..retrieval.datasets import GenericDataset
-
-import numpy as np
-from typing import List
-from os import path
+from ..volumes import Volume, from_array
 
 
 class WagstylProfileLoader:
@@ -41,23 +45,23 @@ class WagstylProfileLoader:
     DATASET = GenericDataset(
         name="HIBALL workshop on cortical layers",
         contributors=[
-            'Konrad Wagstyl',
-            'Stéphanie Larocque',
-            'Guillem Cucurull',
-            'Claude Lepage',
-            'Joseph Paul Cohen',
-            'Sebastian Bludau',
-            'Nicola Palomero-Gallagher',
-            'Lindsay B. Lewis',
-            'Thomas Funck',
-            'Hannah Spitzer',
-            'Timo Dickscheid',
-            'Paul C. Fletcher',
-            'Adriana Romero',
-            'Karl Zilles',
-            'Katrin Amunts',
-            'Yoshua Bengio',
-            'Alan C. Evans'
+            "Konrad Wagstyl",
+            "Stéphanie Larocque",
+            "Guillem Cucurull",
+            "Claude Lepage",
+            "Joseph Paul Cohen",
+            "Sebastian Bludau",
+            "Nicola Palomero-Gallagher",
+            "Lindsay B. Lewis",
+            "Thomas Funck",
+            "Hannah Spitzer",
+            "Timo Dickscheid",
+            "Paul C. Fletcher",
+            "Adriana Romero",
+            "Karl Zilles",
+            "Katrin Amunts",
+            "Yoshua Bengio",
+            "Alan C. Evans",
         ],
         url="https://github.com/kwagstyl/cortical_layers_tutorial/",
         description="Cortical profiles of BigBrain staining intensities computed by Konrad Wagstyl, "
@@ -67,7 +71,7 @@ class WagstylProfileLoader:
         "http://dx.doi.org/10.1371/journal.pbio.3000678."
         "The data is taken from the tutorial at "
         "https://github.com/kwagstyl/cortical_layers_tutorial. Each vertex is "
-        "assigned to the regional map when queried."
+        "assigned to the regional map when queried.",
     )
 
     def __init__(self):
@@ -76,15 +80,22 @@ class WagstylProfileLoader:
 
     @property
     def profile_labels(self):
-        return np.arange(0., 1., 1. / self._profiles.shape[1])
+        return np.arange(0.0, 1.0, 1.0 / self._profiles.shape[1])
 
     @classmethod
     def _load(cls):
         # read thicknesses, in mm, and normalize by their last column which is the total thickness
-        thickness = requests.HttpRequest(f"{cls.REPO}/{cls.THICKNESSES_FILE_LEFT}").data.T
-        total_thickness = thickness[:, :-1].sum(1)  # last column is the computed total thickness
+        thickness = requests.HttpRequest(
+            f"{cls.REPO}/{cls.THICKNESSES_FILE_LEFT}"
+        ).data.T
+        total_thickness = thickness[:, :-1].sum(
+            1
+        )  # last column is the computed total thickness
         valid = np.where(total_thickness > 0)[0]
-        cls._boundary_depths = np.c_[np.zeros_like(valid), (thickness[valid, :] / total_thickness[valid, None]).cumsum(1)]
+        cls._boundary_depths = np.c_[
+            np.zeros_like(valid),
+            (thickness[valid, :] / total_thickness[valid, None]).cumsum(1),
+        ]
         cls._boundary_depths[:, -1] = 1  # account for float calculation errors
 
         # find profiles with valid thickness
@@ -112,38 +123,51 @@ class WagstylProfileLoader:
 cache.Warmup.register_warmup_fn()(lambda: WagstylProfileLoader._load())
 
 
-class BigBrainProfileQuery(query.LiveQuery, args=[], FeatureType=bigbrain_intensity_profile.BigBrainIntensityProfile):
+class BigBrainProfileQuery(
+    query.LiveQuery,
+    args=[],
+    FeatureType=bigbrain_intensity_profile.BigBrainIntensityProfile,
+):
 
     def __init__(self):
         query.LiveQuery.__init__(self)
 
-    def query(self, concept: structure.BrainStructure, **kwargs) -> List[bigbrain_intensity_profile.BigBrainIntensityProfile]:
+    def query(
+        self, concept: structure.BrainStructure, **kwargs
+    ) -> List[bigbrain_intensity_profile.BigBrainIntensityProfile]:
         loader = WagstylProfileLoader()
-        mesh_vertices = pointcloud.PointCloud(loader._vertices, space='bigbrain')
-        matched = concept.intersection(mesh_vertices)  # returns a reduced PointCloud 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 []
+        if isinstance(matched, point.Point):
+            matched = pointcloud.from_points([matched])
         assert isinstance(matched, pointcloud.PointCloud)
+        if isinstance(concept, location.Location):
+            mesh_as_list = mesh_vertices.as_list()
+            matched.labels = [mesh_as_list.index(v.coordinate) for v in matched]
         indices = matched.labels
         assert indices is not None
         features = []
-        for i in matched.labels:
+        for i in indices:
             anchor = _anchor.AnatomicalAnchor(
-                location=point.Point(loader._vertices[i], space='bigbrain'),
+                location=point.Point(loader._vertices[i], space="bigbrain"),
                 region=str(concept),
-                species='Homo sapiens'
+                species="Homo sapiens",
             )
             prof = bigbrain_intensity_profile.BigBrainIntensityProfile(
                 anchor=anchor,
                 depths=loader.profile_labels,
                 values=loader._profiles[i],
-                boundaries=loader._boundary_depths[i]
+                boundaries=loader._boundary_depths[i],
             )
             prof.anchor._assignments[concept] = _anchor.AnatomicalAssignment(
                 query_structure=concept,
                 assigned_structure=concept,
                 qualification=_anchor.Qualification.CONTAINED,
-                explanation=f"Surface vertex of BigBrain cortical profile was filtered using {concept}"
+                explanation=f"Surface vertex of BigBrain cortical profile was filtered using {concept}",
             )
             prof.datasets = [WagstylProfileLoader.DATASET]
             features.append(prof)
@@ -151,47 +175,220 @@ class BigBrainProfileQuery(query.LiveQuery, args=[], FeatureType=bigbrain_intens
         return features
 
 
-class LayerwiseBigBrainIntensityQuery(query.LiveQuery, args=[], FeatureType=layerwise_bigbrain_intensities.LayerwiseBigBrainIntensities):
+class LayerwiseBigBrainIntensityQuery(
+    query.LiveQuery,
+    args=[],
+    FeatureType=layerwise_bigbrain_intensities.LayerwiseBigBrainIntensities,
+):
 
     def __init__(self):
         query.LiveQuery.__init__(self)
 
-    def query(self, concept: structure.BrainStructure, **kwargs) -> List[layerwise_bigbrain_intensities.LayerwiseBigBrainIntensities]:
+    def query(
+        self, concept: structure.BrainStructure, **kwargs
+    ) -> List[layerwise_bigbrain_intensities.LayerwiseBigBrainIntensities]:
 
         loader = WagstylProfileLoader()
-        mesh_vertices = pointcloud.PointCloud(loader._vertices, space='bigbrain')
-        matched = concept.intersection(mesh_vertices)  # returns a reduced PointCloud 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 the concept is a region
         if matched is None:
             return []
+        if isinstance(matched, point.Point):
+            matched = pointcloud.from_points([matched])
         assert isinstance(matched, pointcloud.PointCloud)
+        if isinstance(concept, location.Location):
+            mesh_as_list = mesh_vertices.as_list()
+            matched.labels = [mesh_as_list.index(v.coordinate) for v in matched]
         indices = matched.labels
-        assert indices is not None
         matched_profiles = loader._profiles[indices, :]
         boundary_depths = loader._boundary_depths[indices, :]
         # compute array of layer labels for all coefficients in profiles_left
         N = matched_profiles.shape[1]
         prange = np.arange(N)
-        layer_labels = 7 - np.array([
-            [np.array([[(prange < T) * 1] for i, T in enumerate((b * N).astype('int'))]).squeeze().sum(0)]
-            for b in boundary_depths
-        ]).reshape((-1, 200))
+        layer_labels = 7 - np.array(
+            [
+                [
+                    np.array(
+                        [
+                            [(prange < T) * 1]
+                            for i, T in enumerate((b * N).astype("int"))
+                        ]
+                    )
+                    .squeeze()
+                    .sum(0)
+                ]
+                for b in boundary_depths
+            ]
+        ).reshape((-1, 200))
 
         anchor = _anchor.AnatomicalAnchor(
-            location=pointcloud.PointCloud(loader._vertices[indices, :], space='bigbrain'),
+            location=pointcloud.PointCloud(
+                loader._vertices[indices, :], space="bigbrain"
+            ),
             region=str(concept),
-            species='Homo sapiens'
+            species="Homo sapiens",
         )
         result = layerwise_bigbrain_intensities.LayerwiseBigBrainIntensities(
             anchor=anchor,
-            means=[matched_profiles[layer_labels == layer].mean() for layer in range(1, 7)],
-            stds=[matched_profiles[layer_labels == layer].std() for layer in range(1, 7)],
+            means=[
+                matched_profiles[layer_labels == layer].mean() for layer in range(1, 7)
+            ],
+            stds=[
+                matched_profiles[layer_labels == layer].std() for layer in range(1, 7)
+            ],
         )
         result.anchor._assignments[concept] = _anchor.AnatomicalAssignment(
             query_structure=concept,
             assigned_structure=concept,
             qualification=_anchor.Qualification.CONTAINED,
-            explanation=f"Surface vertices of BigBrain cortical profiles were filtered using {concept}"
+            explanation=f"Surface vertices of BigBrain cortical profiles were filtered using {concept}",
         )
         result.datasets = [WagstylProfileLoader.DATASET]
 
         return [result]
+
+
+class BigBrain1MicronPatchQuery(
+    query.LiveQuery, args=[], FeatureType=BigBrain1MicronPatch
+):
+    """
+    Sample approximately orthogonal cortical image patches
+    from BigBrain 1 micron sections, guided by an image volume
+    in a supported reference space providing. The image
+    volume is used as a weighted mask to extract patches
+    along the cortical midsurface with nonzero weights in the
+    input image.
+    An optional lower_threshold can be used to narrow down
+    the search
+    The weight is stored with the resulting features.
+    """
+
+    def __init__(self, lower_threshold=0.):
+        self.layermap = get_registry("Map").get("cortical layers bigbrain")
+        self.lower_threshold = lower_threshold
+        query.LiveQuery.__init__(self)
+
+    def query(
+        self, concept: structure.BrainStructure, **kwargs
+    ) -> List[BigBrain1MicronPatch]:
+
+        # make sure input is an image volume
+        # TODO function should be extended to deal with other concepts as well
+        if not isinstance(concept, Volume):
+            logger.warning(
+                "Querying BigBrain1MicronPatch features requires to "
+                "query with an image volume."
+            )
+            return []
+
+        # threshold image volume, if requested
+        if self.lower_threshold > 0.0:
+            logger.info(
+                f"Applying lower threshold of {self.lower_threshold} "
+                "for BigBrain 1 micron patch query."
+            )
+            img = concept.fetch()
+            arr = np.asanyarray(img.dataobj)
+            arr[arr < self.lower_threshold] = 0
+            query_vol = from_array(arr, img.affine, space=concept.space, name="filtered volume")
+        else:
+            query_vol = concept
+        bb_bbox = query_vol.get_boundingbox().warp('bigbrain')
+
+        # find 1 micron BigBrain sections intersecting the thresholded volume
+        sections: List[CellbodyStainedSection] = [
+            s
+            for s in CellbodyStainedSection._get_instances()
+            if isinstance(s, CellbodyStainedSection)
+            and s.get_boundingbox(clip=False).intersects(query_vol)
+        ]
+        if not sections:
+            return []
+
+        # extract relevant patches
+        features = []
+        for hemisphere in ["left", "right"]:
+
+            # get layer 4 mesh in the hemisphere
+            l4 = self.layermap.parcellation.get_region("4 " + hemisphere)
+            l4mesh = self.layermap.fetch(l4, format="mesh")
+            layerverts = {
+                n: self.layermap.fetch(region=n, format="mesh")["verts"]
+                for n in self.layermap.regions if hemisphere in n
+            }
+            l4verts = pointcloud.PointCloud(layerverts[l4.name], "bigbrain")
+            if not l4verts.boundingbox.intersects(bb_bbox):
+                continue
+
+            # for each relevant BigBrain 1 micron section, intersect layer IV mesh
+            # to obtain midcortex-locations, and build their orthogonal patches.
+            # store the concept's value with the patch.
+            vertex_tree = KDTree(layerverts[l4.name])
+            for s in siibra_tqdm(
+                sections, unit="sections", desc=f"Sampling patches in {hemisphere} hemisphere"
+            ):
+
+                # compute layer IV contour in the image plane
+                imgplane = experimental.Plane.from_image(s)
+                try:
+                    contour_segments = imgplane.intersect_mesh(l4mesh)
+                except AssertionError:
+                    logger.error(f"Could not intersect with layer 4 mesh: {s.name}")
+                    continue
+                if len(contour_segments) == 0:
+                    continue
+
+                # score the contour points with the query image volume
+                all_points = pointcloud.from_points(sum(map(list, contour_segments), []))
+                all_probs = query_vol.evaluate_points(all_points)
+                points_prob_lookup = {
+                    pt.coordinate: prob
+                    for pt, prob in zip(all_points, all_probs)
+                    if prob >= self.lower_threshold
+                }
+                if len(points_prob_lookup) == 0:
+                    continue
+
+                # For each contour point,
+                # - find the closest BigBrain layer surface vertex,
+                # - build the profile of corresponding vertices across all layers
+                # - project the profile to the image section
+                # - determine the oriented patch along the profile
+                _, indices = vertex_tree.query(np.array(list(points_prob_lookup.keys())))
+                for prob, nnb in zip(points_prob_lookup.values(), indices):
+
+                    prof = pointcloud.Contour(
+                        [
+                            layerverts[_][nnb]
+                            for _ in self.layermap.regions
+                            if hemisphere in _
+                        ],
+                        space=self.layermap.space,
+                    )
+                    patch = imgplane.get_enclosing_patch(prof)
+                    if patch is None:
+                        continue
+
+                    anchor = _anchor.AnatomicalAnchor(
+                        location=patch, species="Homo sapiens"
+                    )
+                    anchor._assignments[concept] = _anchor.AnatomicalAssignment(
+                        query_structure=query_vol,
+                        assigned_structure=s.anchor.volume,
+                        qualification=_anchor.Qualification.CONTAINED
+                    )
+                    features.append(
+                        BigBrain1MicronPatch(
+                            patch=patch,
+                            profile=prof,
+                            section=s,
+                            vertex=nnb,
+                            relevance=prob,
+                            anchor=anchor
+                        )
+                    )
+
+        # return the patches sorted by relevance (ie. probability)
+        return sorted(features, key=lambda p: p.relevance, reverse=True)

siibra/livequeries/ebrains.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");
@@ -14,18 +14,21 @@
 # limitations under the License.
 """Query data features published as Ebrains datasets with AtlasConcepts"""
 
-from ..features.dataset import ebrains as _ebrains
-from . import query
+from collections import defaultdict
+import re
+from packaging.version import Version
+from tempfile import NamedTemporaryFile
+from typing import TYPE_CHECKING
 
+from . import query
+from ..features.dataset import ebrains as _ebrains
 from ..commons import logger, siibra_tqdm
 from ..features import anchor as _anchor
 from ..retrieval import requests, datasets, cache
-from ..core import parcellation, region
+from ..core.concept import get_registry
 
-from collections import defaultdict
-import re
-from packaging.version import Version
-from tempfile import NamedTemporaryFile
+if TYPE_CHECKING:
+    from ..core.region import Region
 
 
 class EbrainsFeatureQuery(query.LiveQuery, args=[], FeatureType=_ebrains.EbrainsDataFeature):
@@ -58,17 +61,17 @@ class EbrainsFeatureQuery(query.LiveQuery, args=[], FeatureType=_ebrains.Ebrains
         if self.__class__.parcellation_ids is None:
             self.__class__.parcellation_ids = [
                 dset.id
-                for parc in parcellation.Parcellation.registry()
+                for parc in get_registry("Parcellation")
                 for dset in parc.datasets
                 if isinstance(dset, datasets.EbrainsV3DatasetVersion)
             ]
 
-    def query(self, region: region.Region):
+    def query(self, region: "Region"):
         versioned_datasets = defaultdict(dict)
         invalid_species_datasets = {}
         results = self.loader.data.get("results", [])
 
-        for r in siibra_tqdm(results, total=len(results)):
+        for r in siibra_tqdm(results, total=len(results), unit='dataset', desc=f'Matching datasets to "{region}"'):
             regionname = r.get("name", None)
             alias = r.get("alias", None)
             for ds_spec in r.get("datasets", []):