siibra 1.0.1a1__py3-none-any.whl → 1.0.1a4__py3-none-any.whl

siibra/livequeries/bigbrain.py

@@ -14,19 +14,23 @@
 # limitations under the License.
 """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, location
+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,15 +123,23 @@ 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):
@@ -134,21 +153,21 @@ class BigBrainProfileQuery(query.LiveQuery, args=[], FeatureType=bigbrain_intens
         features = []
         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)
@@ -156,16 +175,24 @@ 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 if the concept is a region
+        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):
@@ -180,27 +207,188 @@ class LayerwiseBigBrainIntensityQuery(query.LiveQuery, args=[], FeatureType=laye
         # 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

@@ -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", []):

siibra/livequeries/query.py

@@ -14,13 +14,13 @@
 # limitations under the License.
 """Handles feature queries that rely on live or on-the-fly calculations."""
 
+from abc import ABC, abstractmethod
+from typing import List
+
 from ..commons import logger
 from ..features.feature import Feature
 from ..core.concept import AtlasConcept
 
-from abc import ABC, abstractmethod
-from typing import List
-
 
 class LiveQuery(ABC):
 

siibra/locations/__init__.py

@@ -13,26 +13,34 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Handles spatial concepts and spatial operation like warping between spaces."""
+from typing import Iterable
+from functools import reduce
 
 from .location import Location
 from .point import Point
-from .pointcloud import PointCloud, from_points
+from .pointcloud import PointCloud, Contour, from_points
+from .experimental import AxisAlignedPatch, Plane
 from .boundingbox import BoundingBox
 
 
-def reassign_union(loc0: 'Location', loc1: 'Location') -> 'Location':
+def reassign_union(*args: Iterable["Location"]) -> "Location":
+    return reduce(pairwise_union, args)
+
+
+def pairwise_union(loc0: "Location", loc1: "Location") -> "Location":
     """
     Add two locations of same or different type to find their union as a
     Location object.
+
     Note
     ----
     `loc1` will be warped to `loc0` they are not in the same space.
+
     Parameters
     ----------
     loc0 : Location
-        _description_
     loc1 : Location
-        _description_
+
     Returns
     -------
     Location
@@ -58,12 +66,13 @@ def reassign_union(loc0: 'Location', loc1: 'Location') -> 'Location':
         try:
             return loc1.union(loc0)
         except Exception:
-            raise NotImplementedError(f"There are no union method for {(loc0.__class__.__name__, loc1.__class__.__name__)}")
+            raise NotImplementedError(
+                f"There are no union method for {(loc0.__class__.__name__, loc1.__class__.__name__)}"
+            )
 
     # convert Points to PointClouds
     loc0, loc1 = [
-        from_points([loc]) if isinstance(loc, Point) else loc
-        for loc in [loc0, loc1]
+        from_points([loc]) if isinstance(loc, Point) else loc for loc in [loc0, loc1]
     ]
 
     # adopt the space of the first location
@@ -82,7 +91,7 @@ def reassign_union(loc0: 'Location', loc1: 'Location') -> 'Location':
             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]
+            sigma_mm=[loc0.minpoint.sigma, loc0.maxpoint.sigma],
         )
 
     return reassign_union(loc1_w, loc0)

siibra/locations/boundingbox.py

@@ -14,15 +14,16 @@
 # limitations under the License.
 """A box defined by two farthest corner coordinates on a specific space."""
 
-from . import point, pointcloud, location
+from itertools import product
+import hashlib
+from typing import TYPE_CHECKING, Union, Dict
 
+import numpy as np
+
+from . import location, point, pointcloud
 from ..commons import logger
 from ..exceptions import SpaceWarpingFailedError
 
-from itertools import product
-import hashlib
-import numpy as np
-from typing import TYPE_CHECKING, Union
 if TYPE_CHECKING:
     from ..core.structure import BrainStructure
     from nibabel import Nifti1Image
@@ -85,7 +86,7 @@ class BoundingBox(location.Location):
                     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.")
+            logger.debug(f"Zero-volume bounding box from points {point1} and {point2} in {self.space} space.")
 
     @property
     def id(self) -> str:
@@ -281,14 +282,15 @@ class BoundingBox(location.Location):
             sigma_mm=np.mean([self.minpoint.sigma, self.maxpoint.sigma])
         )
 
-    def warp(self, space):
+    def warp(self, space: Union[str, Dict, "Space"]):
         """Returns a new bounding box obtained by warping the
         min- and maxpoint of this one into the new target space.
 
         TODO process the sigma values o the points
         """
         from ..core.space import Space
-        spaceobj = Space.get_instance(space)
+
+        spaceobj = space if isinstance(space, Space) else Space.get_instance(space)
         if spaceobj == self.space:
             return self
         else: