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

siibra/features/connectivity/regional_connectivity.py

@@ -14,11 +14,18 @@
 # limitations under the License.
 
 from zipfile import ZipFile
-from ..feature import Feature, Compoundable
-from ..tabular.tabular import Tabular
+from typing import Callable, Union, List, Tuple, Iterator
+try:
+    from typing import Literal
+except ImportError:  # support python 3.7
+    from typing_extensions import Literal
 
-from .. import anchor as _anchor
+import numpy as np
+import pandas as pd
 
+from .. import anchor as _anchor
+from ..feature import Feature, Compoundable
+from ..tabular.tabular import Tabular
 from ...commons import logger, QUIET, siibra_tqdm
 from ...core import region as _region
 from ...locations import pointcloud
@@ -26,16 +33,6 @@ from ...retrieval.repositories import RepositoryConnector
 from ...retrieval.requests import HttpRequest
 
 
-import pandas as pd
-import numpy as np
-from typing import Callable, Union, List, Tuple, Iterator
-
-try:
-    from typing import Literal
-except ImportError:  # support python 3.7
-    from typing_extensions import Literal
-
-
 class RegionalConnectivity(Feature, Compoundable):
     """
     Parcellation-averaged connectivity, providing one or more matrices of a
@@ -107,6 +104,7 @@ class RegionalConnectivity(Feature, Compoundable):
         self._matrix = None
         self._subject = subject
         self._feature = feature
+        self._matrix_std = None  # only used for compound feature
 
     @property
     def subject(self):
@@ -173,6 +171,9 @@ class RegionalConnectivity(Feature, Compoundable):
         merged._matrix = elements[0]._arraylike_to_dataframe(
             np.stack(all_arrays).mean(0)
         )
+        merged._matrix_std = elements[0]._arraylike_to_dataframe(
+            np.stack(all_arrays).std(0)
+        )
         return merged
 
     def _plot_matrix(
@@ -261,10 +262,14 @@ class RegionalConnectivity(Feature, Compoundable):
             non-symmetric matrices. ('column' or 'row')
         """
         matrix = self.data
+        assert isinstance(matrix, pd.DataFrame)
+        matrix_std = self._matrix_std
         if direction.lower() not in ['column', 'row']:
             raise ValueError("Direction can only be 'column' or 'row'")
         if direction.lower() == 'row':
             matrix = matrix.transpose()
+            if matrix_std is not None:
+                matrix_std = matrix_std.transpose()
 
         def matches(r1, r2):
             if isinstance(r1, tuple):
@@ -273,32 +278,38 @@ class RegionalConnectivity(Feature, Compoundable):
                 assert isinstance(r1, _region.Region)
                 return r1.matches(r2)
 
-        regions = [r for r in matrix.index if matches(r, region)]
-        if len(regions) == 0:
+        # decode region spec
+        region_candidates = [r for r in matrix.index if matches(r, region)]
+        if len(region_candidates) == 0:
             raise ValueError(f"Invalid region specification: {region}")
-        elif len(regions) > 1:
-            raise ValueError(f"Region specification {region} matched more than one profile: {regions}")
-        else:
-            name = self.modality
-            series = matrix[regions[0]]
-            last_index = len(series) - 1 if max_rows is None \
-                else min(max_rows, len(series) - 1)
-            return Tabular(
-                description=self.description,
-                modality=f"{self.modality} {self.cohort}",
-                anchor=_anchor.AnatomicalAnchor(
-                    species=list(self.anchor.species)[0],
-                    region=regions[0]
-                ),
-                data=(
-                    series[:last_index]
-                    .to_frame(name=name)
-                    .query(f'`{name}` > {min_connectivity}')
-                    .sort_values(by=name, ascending=False)
-                    .rename_axis('Target regions')
-                ),
-                datasets=self.datasets
-            )
+        if len(region_candidates) > 1:
+            raise ValueError(f"Region specification {region} matched more than one profile: {region_candidates}")
+        region = region_candidates[0]
+
+        # create DataFrame
+        data = matrix[region].to_frame('mean')
+        if matrix_std is not None:
+            data = pd.concat([data, matrix_std[region].rename('std')], axis=1)
+
+        last_index = len(data) if max_rows is None else min(max_rows, len(data))
+
+        data = (
+            data
+            .query(f'`mean` > {min_connectivity}')
+            .sort_values(by="mean", ascending=False)
+            .rename_axis('Target regions')
+        )[:last_index]
+
+        return Tabular(
+            description=self.description,
+            modality=f"{self.modality} {self.cohort}",
+            anchor=_anchor.AnatomicalAnchor(
+                species=list(self.anchor.species)[0],
+                region=region
+            ),
+            data=data,
+            datasets=self.datasets
+        )
 
     def plot(
         self,
@@ -339,8 +350,8 @@ class RegionalConnectivity(Feature, Compoundable):
         profile = self.get_profile(regions, min_connectivity, max_rows, direction)
         kwargs["kind"] = kwargs.get("kind", "barh")
         if backend == "matplotlib":
-            kwargs["logx"] = kwargs.get("logx", logscale)
-            return profile.data.plot(*args, backend=backend, **kwargs)
+            kwargs["logy"] = kwargs.get("logy", logscale)
+            return profile.plot(*args, backend=backend, **kwargs)
         elif backend == "plotly":
             kwargs.update({
                 "color": kwargs.get("color", profile.data.columns[0]),

siibra/features/dataset/ebrains.py

@@ -15,9 +15,9 @@
 """Non-preconfigured data features hosted at EBRAINS."""
 
 from zipfile import ZipFile
+
 from .. import anchor as _anchor
 from .. import feature
-
 from ...retrieval import datasets
 
 

siibra/features/feature.py

@@ -14,12 +14,6 @@
 # limitations under the License.
 """Handles multimodal data features and related queries."""
 
-from . import anchor as _anchor
-
-from ..commons import logger, InstanceTable, siibra_tqdm, __version__
-from ..core import concept, space, region, parcellation, structure
-from ..volumes import volume
-
 from typing import Union, TYPE_CHECKING, List, Dict, Type, Tuple, BinaryIO, Any, Iterator
 from hashlib import md5
 from collections import defaultdict
@@ -28,6 +22,11 @@ from abc import ABC, abstractmethod
 from re import sub
 from textwrap import wrap
 
+from . import anchor as _anchor
+from ..commons import logger, InstanceTable, siibra_tqdm, __version__
+from ..core import concept, space, region, parcellation, structure
+from ..volumes import volume
+
 if TYPE_CHECKING:
     from ..retrieval.datasets import EbrainsDataset
     TypeDataset = EbrainsDataset
@@ -130,23 +129,22 @@ class Feature:
         # allows subclasses to implement lazy loading of an anchor
         return self._anchor_cached
 
-    def __init_subclass__(cls, configuration_folder=None, category=None, do_not_index=False, **kwargs):
+    def __init_subclass__(cls, configuration_folder=None, category=None, **kwargs):
 
         # Feature.SUBCLASSES serves as an index where feature class inheritance is cached. When users
         # queries a branch on the hierarchy, all children will also be queried. There are usecases where
         # such behavior is not desired (e.g. ProxyFeature, which wraps livequery features id to capture the
         # query context).
-        # do_not_index flag allow the default index behavior to be toggled off.
-
-        if do_not_index is False:
+        if "ProxyFeature" in cls.__name__:
+            return
 
-            # extend the subclass lists
-            # Iterate over all mro, not just immediate base classes
-            for BaseCls in cls.__mro__:
-                # some base classes may not be sub class of feature, ignore these
-                if not issubclass(BaseCls, Feature):
-                    continue
-                cls._SUBCLASSES[BaseCls].append(cls)
+        # extend the subclass lists
+        # Iterate over all mro, not just immediate base classes
+        for BaseCls in cls.__mro__:
+            # some base classes may not be sub class of feature, ignore these
+            if not issubclass(BaseCls, Feature):
+                continue
+            cls._SUBCLASSES[BaseCls].append(cls)
 
         cls._live_queries = []
         cls._preconfigured_instances = None
@@ -156,6 +154,9 @@ class Feature:
             cls._CATEGORIZED[category].add(cls.__name__, cls)
         return super().__init_subclass__(**kwargs)
 
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}(id='{self.id}', name='{self.name}')>"
+
     @classmethod
     def _get_subclasses(cls):
         return {Cls.__name__: Cls for Cls in cls._SUBCLASSES}
@@ -231,7 +232,10 @@ class Feature:
         from ..configuration.configuration import Configuration
         conf = Configuration()
         Configuration.register_cleanup(cls._clean_instances)
-        assert cls._configuration_folder in conf.folders
+        if cls._configuration_folder not in conf.folders:
+            logger.debug(f"{cls._configuration_folder} is not in current configuration")
+            return []
+
         cls._preconfigured_instances = [
             o for o in conf.build_objects(cls._configuration_folder)
             if isinstance(o, cls)
@@ -579,7 +583,10 @@ class Feature:
         # with the query concept.
         live_instances = feature_type._livequery(concept, **kwargs)
 
-        results = list(dict.fromkeys(preconfigured_instances + live_instances))
+        results = sorted(
+            dict.fromkeys(preconfigured_instances + live_instances),  # to remove duplicates
+            key=lambda f: min(f.last_match_result) if f.last_match_result else False,  # to order according to assignmnent ranking
+        )
         return CompoundFeature._compound(results, concept)
 
     @classmethod
@@ -625,7 +632,9 @@ class Feature:
 
         See docstring of serialize_query_context for further context.
         """
-        class ProxyFeature(feature.__class__, do_not_index=True):
+
+        # if you change the name of this class, change the string in Feature.__init_subclass__
+        class ProxyFeature(feature.__class__):
 
             # override __class__ property
             # some instances of features accesses inst.__class__

siibra/features/image/__init__.py

@@ -21,7 +21,10 @@ from .volume_of_interest import (
     MRIVolumeOfInterest,
     XPCTVolumeOfInterest,
     LSFMVolumeOfInterest,
-    DTIVolumeOfInterest
-    # SegmentedVolumeOfInterest
+    DTIVolumeOfInterest,
+    MorphometryVolumeOfInterest,
+)
+from .sections import (
+    CellbodyStainedSection,
+    BigBrain1MicronPatch
 )
-from .sections import CellbodyStainedSection

siibra/features/image/image.py

@@ -14,15 +14,13 @@
 # limitations under the License.
 """Base type of features in volume format and related anatomical anchor."""
 
+from typing import List, TYPE_CHECKING
 from zipfile import ZipFile
-from .. import feature
 
+from .. import feature
 from .. import anchor as _anchor
-
 from ...volumes import volume as _volume
 
-from typing import List, TYPE_CHECKING
-
 if TYPE_CHECKING:
     from ...locations.boundingbox import BoundingBox
     from ...volumes.providers import provider

siibra/features/image/sections.py

@@ -14,13 +14,92 @@
 # limitations under the License.
 """Multimodal data features in 2D section."""
 
+from typing import TYPE_CHECKING
+
 from . import image
 
+if TYPE_CHECKING:
+    from ...locations import AxisAlignedPatch, Contour
+    from ...features.anchor import AnatomicalAnchor
+
 
 class CellbodyStainedSection(
     image.Image,
-    configuration_folder='features/images/sections/cellbody',
-    category="cellular"
+    configuration_folder="features/images/sections/cellbody",
+    category="cellular",
 ):
     def __init__(self, **kwargs):
         image.Image.__init__(self, **kwargs, modality="cell body staining")
+
+
+class BigBrain1MicronPatch(image.Image, category="cellular"):
+
+    _DESCRIPTION = """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,
+        patch: "AxisAlignedPatch",
+        profile: "Contour",
+        section: CellbodyStainedSection,
+        vertex: int,
+        relevance: float,
+        anchor: "AnatomicalAnchor",
+    ):
+        self._patch = patch
+        self._profile = profile
+        self._section = section
+        self.vertex = vertex
+        self.relevance = relevance
+        image.Image.__init__(
+            self,
+            name=f"Cortical patch in {section.name}",
+            modality=section.modality,
+            space_spec=section._space_spec,
+            providers=list(section._providers.values()),
+            region=None,
+            datasets=section.datasets,
+            bbox=patch.boundingbox,
+            id=None,
+        )
+        self._anchor_cached = anchor
+        self._description_cached = self._DESCRIPTION
+
+    def __repr__(self):
+        return (
+            f"<{self.__class__.__name__}(space_spec={self._space_spec}, "
+            f"name='{self.name}', "
+            f"section='{self._section.get_boundingbox().minpoint.bigbrain_section()}', "
+            f"vertex='{self.vertex}', providers={self._providers})>"
+        )
+
+    @property
+    def section(self) -> CellbodyStainedSection:
+        return self._section
+
+    def get_boundingbox(self, **fetch_kwargs):
+        """Enforce that the bounding box spans the full section thickness."""
+        bbox_section = self._section.get_boundingbox(**fetch_kwargs)
+        bbox = self._patch.boundingbox
+        bbox.minpoint[1] = bbox_section.minpoint[1]
+        bbox.maxpoint[1] = bbox_section.maxpoint[1]
+        return bbox
+
+    @property
+    def profile(self) -> "Contour":
+        return self._profile
+
+    @property
+    def bigbrain_section(self):
+        return self.get_boundingbox().minpoint.bigbrain_section()
+
+    def fetch(self, flip: bool = False, resolution_mm: float = -1, **kwargs):
+        assert len(kwargs) == 0
+        p = self._patch.flip() if flip else self._patch
+        return p.extract_volume(self._section, resolution_mm=resolution_mm).fetch()

siibra/features/image/volume_of_interest.py

@@ -79,10 +79,11 @@ class LSFMVolumeOfInterest(
     def __init__(self, modality, **kwargs):
         image.Image.__init__(self, **kwargs, modality=modality)
 
-# class SegmentedVolumeOfInterest(
-#     image.Image,
-#     configuration_folder="features/images/vois/segmentation",
-#     category="segmentation"
-# ):
-#     def __init__(self, **kwargs):
-#         image.Image.__init__(self, **kwargs, modality="segmentation")
+
+class MorphometryVolumeOfInterest(
+    image.Image,
+    configuration_folder="features/images/vois/morphometry",
+    category="macrostructural"
+):
+    def __init__(self, modality, **kwargs):
+        image.Image.__init__(self, **kwargs, modality=modality)

siibra/features/tabular/__init__.py

@@ -15,7 +15,7 @@
 """Multimodal data features in tabular formats."""
 
 from .bigbrain_intensity_profile import BigBrainIntensityProfile
-from .cell_density_profile import CellDensityProfile
+from .cell_density_profile import CellDensityProfile, cell_reader, layer_reader
 from .gene_expression import GeneExpressions
 from .layerwise_bigbrain_intensities import LayerwiseBigBrainIntensities
 from .layerwise_cell_density import LayerwiseCellDensity

siibra/features/tabular/bigbrain_intensity_profile.py

@@ -13,9 +13,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import List, TYPE_CHECKING
+
 from . import cortical_profile
 
-from typing import List, TYPE_CHECKING
 if TYPE_CHECKING:
     from ...features.anchor import AnatomicalAnchor
 

siibra/features/tabular/cell_density_profile.py

@@ -13,19 +13,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from . import cortical_profile
-
-from .. import anchor as _anchor
-from ...commons import logger
-from ...retrieval import requests
+from io import BytesIO
+from typing import Union, Tuple, Iterable
 
-from skimage.draw import polygon
-from skimage.transform import resize
 import numpy as np
 import pandas as pd
+from skimage.draw import polygon
+from skimage.transform import resize
 
-from io import BytesIO
-from typing import Union, Tuple, Iterable
+from . import cortical_profile
+from .. import anchor as _anchor
+from ...commons import logger
+from ...retrieval import requests
 
 
 def cell_reader(bytes_buffer: bytes):

siibra/features/tabular/cortical_profile.py

@@ -13,15 +13,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from . import tabular
-from ..feature import Compoundable
-
-from .. import anchor as _anchor
-
-import pandas as pd
 from typing import Union, Dict, Tuple, List
+
 from textwrap import wrap
 import numpy as np
+import pandas as pd
+
+from . import tabular
+from .. import anchor as _anchor
+from ..feature import Compoundable
 
 
 class CorticalProfile(tabular.Tabular, Compoundable):

siibra/features/tabular/gene_expression.py

@@ -13,11 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .. import anchor as _anchor
-from . import tabular
-from ...retrieval.datasets import GenericDataset
-
-import pandas as pd
 from textwrap import wrap
 from typing import List
 try:
@@ -25,6 +20,12 @@ try:
 except ImportError:
     from typing_extensions import TypedDict
 
+import pandas as pd
+
+from . import tabular
+from .. import anchor as _anchor
+from ...retrieval.datasets import GenericDataset
+
 
 class GeneExpressions(
     tabular.Tabular,
@@ -224,6 +225,7 @@ class GeneExpressions(
             datasets=datasets
         )
         self.unit = "expression level"
+        self._genes = list(set(genes))
 
     def plot(self, *args, backend="matplotlib", **kwargs):
         """
@@ -238,18 +240,34 @@ class GeneExpressions(
             Keyword arguments are passed on to the plot command.
         """
         wrapwidth = kwargs.pop("textwrap") if "textwrap" in kwargs else 40
-        kwargs["title"] = kwargs.pop("title", None) \
-            or "\n".join(wrap(f"{self.modality} measured in {self.anchor._regionspec or self.anchor.location}", wrapwidth))
-        kwargs["kind"] = "box"
+        kwargs["title"] = kwargs.pop(
+            "title",
+            "\n".join(wrap(
+                f"{self.modality}\n{self.anchor._regionspec or self.anchor.location}",
+                wrapwidth
+            ))
+        )
+        kwargs["kind"] = kwargs.get("kind", "box")
         if backend == "matplotlib":
-            for arg in ['yerr', 'y', 'ylabel', 'xlabel', 'width']:
-                assert arg not in kwargs
-            default_kwargs = {
-                "grid": True, "legend": False, 'by': "gene",
-                'column': ['level'], 'showfliers': False, 'ax': None,
-                'ylabel': 'expression level'
-            }
-            return self.data.plot(*args, **{**default_kwargs, **kwargs}, backend=backend)
+            if kwargs["kind"] == "box":
+                from matplotlib.pyplot import tight_layout
+
+                title = kwargs.pop("title")
+                default_kwargs = {
+                    "grid": True,
+                    'by': "gene",
+                    'column': ['level'],
+                    'showfliers': False,
+                    'ylabel': 'expression level',
+                    'xlabel': 'gene',
+                    'color': 'dimgray',
+                    'rot': 90 if len(self._genes) > 1 else 0,
+                }
+                ax, *_ = self.data.plot(*args, backend=backend, **{**default_kwargs, **kwargs})
+                ax.set_title(title)
+                tight_layout()
+                return ax
+            return self.data.plot(*args, backend=backend, **kwargs)
         elif backend == "plotly":
             kwargs["title"] = kwargs["title"].replace('\n', "<br>")
             return self.data.plot(y='level', x='gene', backend=backend, **kwargs)

siibra/features/tabular/layerwise_bigbrain_intensities.py

@@ -13,13 +13,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from . import cortical_profile
-from . import tabular
+from typing import TYPE_CHECKING
 
 import pandas as pd
 import numpy as np
 
-from typing import TYPE_CHECKING
+from . import tabular
+from . import cortical_profile
+
 if TYPE_CHECKING:
     from ...features.anchor import AnatomicalAnchor