siibra 0.4a33__py3-none-any.whl → 0.4a46__py3-none-any.whl

siibra/features/{basetypes → tabular}/cortical_profile.py

@@ -13,7 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from . import feature
+from . import tabular
 
 from .. import anchor as _anchor
 
@@ -23,7 +23,7 @@ from textwrap import wrap
 import numpy as np
 
 
-class CorticalProfile(feature.Feature):
+class CorticalProfile(tabular.Tabular):
     """
     Represents a 1-dimensional profile of measurements along cortical depth,
     measured at relative depths between 0 representing the pial surface,
@@ -56,38 +56,28 @@ class CorticalProfile(feature.Feature):
     ):
         """Initialize profile.
 
-        Args:
-            description (str):
-                Human-readable of the modality of the measurements.
-            modality (str):
-                Short textual description of the modaility of measurements
-            anchor: AnatomicalAnchor
-            depths (list, optional):
-                List of cortical depthh positions corresponding to each
-                measurement, all in the range [0..1].
-                Defaults to None.
-            values (list, optional):
-                List of the actual measurements at each depth position.
-                Length must correspond to 'depths'.
-                Defaults to None.
-            unit (str, optional):
-                Textual identifier for the unit of measurements.
-                Defaults to None.
-            boundary_positions (dict, optional):
-                Dictionary of depths at which layer boundaries were identified.
-                Keys are tuples of layer numbers, e.g. (1,2), values are cortical
-                depth positions in the range [0..1].
-                Defaults to None.
-            datasets : list
-                list of datasets corresponding to this feature
+        Parameters
+        ----------
+        description: str
+            Human-readable of the modality of the measurements.
+        modality: str
+            Short textual description of the modality of measurements.
+        anchor: AnatomicalAnchor
+        depths: list, default: None
+            List of cortical depth positions corresponding to each
+            measurement, all in the range [0..1]
+        values: list, default: None
+            List of the actual measurements at each depth position.
+            Length must correspond to 'depths'.
+        unit: str, default: None
+            Textual identifier for the unit of measurements.
+        boundary_positions: dict, default: None
+            Dictionary of depths at which layer boundaries were identified.
+            Keys are tuples of layer numbers, e.g. (1,2), and values are
+            cortical depth positions in the range [0..1].
+        datasets : list[Dataset]
+            list of datasets corresponding to this feature
         """
-        feature.Feature.__init__(
-            self,
-            modality=modality,
-            description=description,
-            anchor=anchor,
-            datasets=datasets
-        )
 
         # cached properties will be revealed as property functions,
         # so derived classes may choose to override for lazy loading.
@@ -96,6 +86,15 @@ class CorticalProfile(feature.Feature):
         self._values_cached = values
         self._boundary_positions = boundary_positions
 
+        tabular.Tabular.__init__(
+            self,
+            modality=modality,
+            description=description,
+            anchor=anchor,
+            data=None,  # lazy loader below
+            datasets=datasets
+        )
+
     def _check_sanity(self):
         # check plausibility of the profile
         assert isinstance(self._depths, (list, np.ndarray))
@@ -117,7 +116,7 @@ class CorticalProfile(feature.Feature):
         return self._unit
 
     @property
-    def boundary_positions(self):
+    def boundary_positions(self) -> Dict[Tuple[int, int], float]:
         if self._boundary_positions is None:
             return {}
         else:
@@ -156,12 +155,14 @@ class CorticalProfile(feature.Feature):
     def data(self):
         """Return a pandas Series representing the profile."""
         self._check_sanity()
-        return pd.Series(
-            self._values, index=self._depths, name=f"{self.modality} ({self.unit})"
+        return pd.DataFrame(
+            self._values, index=self._depths, columns=[f"{self.modality} ({self.unit})"]
         )
 
     def plot(self, **kwargs):
-        """Plot the profile.
+        """
+        Plot the profile.
+
         Keyword arguments are passed on to the plot command.
         'layercolor' can be used to specify a color for cortical layer shading.
         """
@@ -194,8 +195,11 @@ class CorticalProfile(feature.Feature):
 
     @property
     def _depths(self):
-        """Returns a list of the relative cortical depths of the measured values in the range [0..1].
-        To be implemented in derived class."""
+        """
+        Returns a list of the relative cortical depths of the measured values in the range [0..1].
+
+        To be implemented in derived class.
+        """
         if self._depths_cached is None:
             raise NotImplementedError(
                 f"'_depths' not available for {self.__class__.__name__}."
@@ -204,8 +208,11 @@ class CorticalProfile(feature.Feature):
 
     @property
     def _values(self):
-        """Returns a list of the measured values per depth.
-        To be implemented in derived class."""
+        """
+        Returns a list of the measured values per depth.
+
+        To be implemented in derived class.
+        """
         if self._values_cached is None:
             raise NotImplementedError(
                 f"'_values' not available for {self.__class__.__name__}."

siibra/features/{molecular → tabular}/gene_expression.py

@@ -14,7 +14,7 @@
 # limitations under the License.
 
 from .. import anchor as _anchor
-from ..basetypes import tabular
+from . import tabular
 
 from ... import commons
 
@@ -27,7 +27,10 @@ except ImportError:
     from typing_extensions import TypedDict
 
 
-class GeneExpressions(tabular.Tabular):
+class GeneExpressions(
+    tabular.Tabular,
+    category='molecular'
+):
     """
     A set gene expressions for different candidate genes
     measured inside a brain structure.

siibra/features/{cellular → tabular}/layerwise_bigbrain_intensities.py

@@ -13,13 +13,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from ..basetypes import cortical_profile, tabular
+from . import cortical_profile
+from . import tabular
 
 import pandas as pd
 import numpy as np
 
 
-class LayerwiseBigBrainIntensities(tabular.Tabular):
+class LayerwiseBigBrainIntensities(
+    tabular.Tabular,
+    category='cellular'
+):
 
     DESCRIPTION = (
         "Layerwise averages and standard deviations of of BigBrain staining intensities "

siibra/features/{cellular → tabular}/layerwise_cell_density.py

@@ -13,8 +13,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from . import cortical_profile
 from .. import anchor as _anchor
-from ..basetypes import cortical_profile, tabular
+from . import tabular
 
 from ... import commons
 from ...retrieval import requests
@@ -24,7 +25,11 @@ import numpy as np
 from io import BytesIO
 
 
-class LayerwiseCellDensity(tabular.Tabular, configuration_folder="features/fingerprints/celldensity"):
+class LayerwiseCellDensity(
+    tabular.Tabular,
+    configuration_folder="features/tabular/layerstatistics/celldensity",
+    category='cellular'
+):
 
     DESCRIPTION = (
         "Layerwise estimated densities of detected cell bodies  (in detected cells per 0.1 cube millimeter) "
@@ -76,7 +81,8 @@ class LayerwiseCellDensity(tabular.Tabular, configuration_folder="features/finge
                 continue
             counts = cells.layer.value_counts()
             areas = layers["Area(micron**2)"]
-            density_dict[i] = counts[areas.index] / areas * 100 ** 2 * 5
+            indices = np.intersect1d(areas.index, counts.index)
+            density_dict[i] = counts[indices] / areas * 100 ** 2 * 5
         return pd.DataFrame(density_dict)
 
     @property

siibra/features/{molecular → tabular}/receptor_density_fingerprint.py

@@ -14,7 +14,7 @@
 # limitations under the License.
 
 from .. import anchor as _anchor
-from ..basetypes import tabular
+from . import tabular
 
 from ... import commons, vocabularies
 from ...retrieval import requests
@@ -27,7 +27,8 @@ from typing import List
 
 class ReceptorDensityFingerprint(
     tabular.Tabular,
-    configuration_folder="features/fingerprints/receptor"
+    configuration_folder="features/tabular/fingerprints/receptor",
+    category='molecular'
 ):
 
     DESCRIPTION = (

siibra/features/{molecular → tabular}/receptor_density_profile.py

@@ -14,14 +14,18 @@
 # limitations under the License.
 
 from .. import anchor as _anchor
-from ..basetypes import cortical_profile
+from . import cortical_profile
 
 from ... import vocabularies
 from ...commons import create_key
 from ...retrieval import requests
 
 
-class ReceptorDensityProfile(cortical_profile.CorticalProfile, configuration_folder="features/profiles/receptor"):
+class ReceptorDensityProfile(
+    cortical_profile.CorticalProfile,
+    configuration_folder="features/tabular/corticalprofiles/receptor",
+    category='molecular'
+):
 
     DESCRIPTION = (
         "Cortical profile of densities (in fmol/mg protein) of receptors for classical neurotransmitters "

siibra/features/tabular/regional_timeseries_activity.py

@@ -0,0 +1,213 @@
+# Copyright 2018-2021
+# Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+
+from . import tabular
+
+from .. import anchor as _anchor
+
+from ...commons import logger, QUIET, siibra_tqdm
+from ...core import region as _region
+from ...locations import pointset
+from ...retrieval.repositories import RepositoryConnector
+
+from typing import Callable, Dict, Union
+import pandas as pd
+import numpy as np
+
+
+class RegionalTimeseriesActivity(tabular.Tabular):
+    """
+    Datasets that provide regional activity over time.
+    """
+
+    DESCRIPTION = (
+        ""
+    )
+
+    def __init__(
+        self,
+        cohort: str,
+        modality: str,
+        regions: list,
+        connector: RepositoryConnector,
+        decode_func: Callable,
+        files: Dict[str, str],
+        anchor: _anchor.AnatomicalAnchor,
+        timestep: str,
+        description: str = "",
+        datasets: list = [],
+        paradigm: str = ""
+    ):
+        """
+        """
+        tabular.Tabular.__init__(
+            self,
+            modality=modality,
+            description=description,
+            anchor=anchor,
+            datasets=datasets,
+            data=None  # lazy loading below
+        )
+        self.cohort = cohort.upper()
+        self._connector = connector
+        self._files = files
+        self._decode_func = decode_func
+        self.regions = regions
+        self._tables = {}
+        self.paradigm = paradigm
+        self.timestep = timestep
+
+    @property
+    def subjects(self):
+        """
+        Returns the subject identifiers for which signal tables are available.
+        """
+        return list(self._files.keys())
+
+    @property
+    def name(self):
+        supername = super().name
+        return f"{supername} with paradigm {self.paradigm}"
+
+    def get_table(self, subject: str = None):
+        """
+        Returns a pandas dataframe where the column headers are regions and the
+        indcies indicate disctrete timesteps.
+
+        Parameters
+        ----------
+        subject: str, default: None
+            Name of the subject (see RegionalTimeseriesActivity.subjects for available names).
+            If None, the mean is taken in case of multiple available data tables.
+        Returns
+        -------
+        pd.DataFrame
+            A table with region names as the column and timesteps as indices.
+        """
+        assert len(self) > 0
+        if (subject is None) and (len(self) > 1):
+            # multiple signal tables available, but no subject given - return mean table
+            logger.info(
+                f"No subject name supplied, returning mean signal table across {len(self)} subjects. "
+                "You might alternatively specify an individual subject."
+            )
+            if "mean" not in self._tables:
+                all_arrays = [
+                    self._connector.get(fname, decode_func=self._decode_func)
+                    for fname in siibra_tqdm(
+                        self._files.values(),
+                        total=len(self),
+                        desc=f"Averaging {len(self)} signal tables"
+                    )
+                ]
+                self._tables['mean'] = self._array_to_dataframe(np.stack(all_arrays).mean(0))
+            return self._tables['mean'].copy()
+        if subject is None:
+            subject = next(iter(self._files.keys()))
+        if subject not in self._files:
+            raise ValueError(f"Subject name '{subject}' not known, use one of: {', '.join(self._files)}")
+        if subject not in self._tables:
+            self._tables[subject] = self._load_table(subject)
+        return self._tables[subject].copy()
+
+    def _load_table(self, subject: str):
+        """
+        Extract the timeseries table.
+        """
+        assert subject in self.subjects
+        array = self._connector.get(self._files[subject], decode_func=self._decode_func)
+        return self._array_to_dataframe(array)
+
+    def __len__(self):
+        return len(self._files)
+
+    def __str__(self):
+        return "{} with paradigm {} for {} from {} cohort ({} signal tables)".format(
+            self.modality, self.paradigm,
+            "_".join(p.name for p in self.anchor.parcellations),
+            self.cohort,
+            len(self._files),
+        )
+
+    def compute_centroids(self, space):
+        """
+        Computes the list of centroid coordinates corresponding to
+        dataframe columns, in the given reference space.
+
+        Parameters
+        ----------
+        space: Space, str
+
+        Returns
+        -------
+        list[tuple(float, float, float)]
+        """
+        result = []
+        parcellations = self.anchor.represented_parcellations()
+        assert len(parcellations) == 1
+        parcmap = next(iter(parcellations)).get_map(space)
+        all_centroids = parcmap.compute_centroids()
+        for regionname in self.regions:
+            region = parcmap.parcellation.get_region(regionname, allow_tuple=True)
+            if isinstance(region, tuple):  # deal with sets of matched regions
+                found = [c for r in region for c in r if c.name in all_centroids]
+            else:
+                found = [r for r in region if r.name in all_centroids]
+            assert len(found) > 0
+            result.append(
+                tuple(pointset.PointSet(
+                    [all_centroids[r.name] for r in found], space=space
+                ).centroid)
+            )
+        return result
+
+    def _array_to_dataframe(self, array: np.ndarray) -> pd.DataFrame:
+        """
+        Convert a numpy array with the regional activity data to
+        a DataFrame with regions as column headers and timesteps as indices.
+        """
+        df = pd.DataFrame(array)
+        parcellations = self.anchor.represented_parcellations()
+        assert len(parcellations) == 1
+        parc = next(iter(parcellations))
+        with QUIET:
+            indexmap = {
+                i: parc.get_region(regionname, allow_tuple=True)
+                for i, regionname in enumerate(self.regions)
+            }
+        ncols = array.shape[1]
+        if len(indexmap) == ncols:
+            remapper = {
+                label - min(indexmap.keys()): region
+                for label, region in indexmap.items()
+            }
+            df = df.rename(columns=remapper)
+        return df
+
+    def plot(self, subject: str = None, **kwargs):
+        table = self.get_table(subject)
+        return table.mean().plot(kind="bar", **kwargs)
+
+
+class RegionalBOLD(
+    RegionalTimeseriesActivity,
+    configuration_folder="features/tabular/activity_timeseries/bold",
+    category="activity_timeseries"
+):
+    """
+    Blood-oxygen-level-dependent (BOLD) signals per region.
+    """
+
+    pass

siibra/features/{basetypes → tabular}/tabular.py

@@ -13,7 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from . import feature
+from .. import feature
 
 from .. import anchor as _anchor
 
@@ -27,14 +27,13 @@ class Tabular(feature.Feature):
     """
     Represents a table of different measures anchored to a brain location.
 
-    Columns represent different types of values, while rows represent
-    different samples. The number of columns might thus be intrepreted
-    as the feature dimension.
+    Columns represent different types of values, while rows represent different
+    samples. The number of columns might thus be interpreted as the feature
+    dimension.
 
-    As an example, receptor fingerprints use rows
-    to represent different neurotransmitter receptors, and separate
-    columns for the mean and standard deviations measure across multiple
-    tissue samples.
+    As an example, receptor fingerprints use rows to represent different
+    neurotransmitter receptors, and separate columns for the mean and standard
+    deviations measure across multiple tissue samples.
     """
 
     def __init__(
@@ -59,7 +58,13 @@ class Tabular(feature.Feature):
         return self._data_cached
 
     def plot(self, **kwargs):
-        """ Create a bar plot of a columns of the data."""
+        """
+        Create a bar plot of a columns of the data.
+        Parameters
+        ----------
+        **kwargs
+            takes Matplotlib.pyplot keyword arguments
+        """
 
         try:
             import matplotlib.pyplot as plt

siibra/livequeries/allen.py

@@ -17,7 +17,7 @@ from .query import LiveQuery
 
 from ..core import space as _space
 from ..features import anchor as _anchor
-from ..features.molecular.gene_expression import GeneExpressions
+from ..features.tabular.gene_expression import GeneExpressions
 from ..commons import logger, Species, MapType
 from ..locations import Point, PointSet
 from ..core.region import Region

siibra/livequeries/bigbrain.py

@@ -15,8 +15,7 @@
 
 from . import query
 
-from ..features.cellular import bigbrain_intensity_profile, layerwise_bigbrain_intensities
-
+from ..features.tabular import bigbrain_intensity_profile, layerwise_bigbrain_intensities
 from ..commons import logger
 from ..locations import point, pointset
 from ..core import space, region
@@ -158,7 +157,7 @@ class LayerwiseBigBrainIntensityQuery(query.LiveQuery, args=[], FeatureType=laye
             region_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
-            ]).squeeze()
+            ]).reshape((-1, 200))
 
             fp = layerwise_bigbrain_intensities.LayerwiseBigBrainIntensities(
                 regionname=subregion.name,

siibra/livequeries/ebrains.py

@@ -13,10 +13,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from ..features.external import ebrains as _ebrains
+from ..features.dataset import ebrains as _ebrains
 from . import query
 
-from ..commons import logger
+from ..commons import logger, siibra_tqdm
 from ..features import anchor as _anchor
 from ..retrieval import requests, datasets
 from ..core import parcellation, region
@@ -24,7 +24,6 @@ from ..core import parcellation, region
 from collections import defaultdict
 import re
 from distutils.version import LooseVersion
-from tqdm import tqdm
 from tempfile import NamedTemporaryFile
 
 
@@ -48,11 +47,6 @@ class EbrainsFeatureQuery(query.LiveQuery, args=[], FeatureType=_ebrains.Ebrains
             requests.GitlabProxy(
                 flavour=requests.GitlabProxyEnum.PARCELLATIONREGION_V1,
             ),
-            requests.EbrainsKgQuery(
-                query_id="siibra-kg-feature-summary-0_0_4",
-                schema="parcellationregion",
-                params={"vocab": "https://schema.hbp.eu/myQuery/"},
-            )
         ]
     )
 
@@ -75,7 +69,7 @@ class EbrainsFeatureQuery(query.LiveQuery, args=[], FeatureType=_ebrains.Ebrains
         invalid_species_datasets = {}
         results = self.loader.data.get("results", [])
 
-        for r in tqdm(results, total=len(results)):
+        for r in siibra_tqdm(results, total=len(results)):
 
             regionname = r.get("name", None)
             alias = r.get("alias", None)

siibra/livequeries/query.py

@@ -14,7 +14,7 @@
 # limitations under the License.
 
 from ..commons import logger
-from ..features.basetypes.feature import Feature
+from ..features.feature import Feature
 from ..core.concept import AtlasConcept
 
 from abc import ABC, abstractmethod

siibra/locations/location.py

@@ -17,6 +17,7 @@
 import numpy as np
 from abc import ABC, abstractmethod
 from nibabel import Nifti1Image
+from typing import Union
 
 
 class Location(ABC):
@@ -48,14 +49,14 @@ class Location(ABC):
         pass
 
     @abstractmethod
-    def intersects(self, mask: Nifti1Image):
+    def intersects(self, other: Union[Nifti1Image, 'Location']) -> bool:
         """
         Verifies wether this 3D location intersects the given mask.
 
         NOTE: The affine matrix of the image must be set to warp voxels
         coordinates into the reference space of this Bounding Box.
         """
-        pass
+        raise NotImplementedError
 
     @abstractmethod
     def warp(self, space):
@@ -114,7 +115,7 @@ class WholeBrain(Location):
     def __init__(self, space=None):
         Location.__init__(self, space)
 
-    def intersects(self, mask: Nifti1Image):
+    def intersects(self, *_args, **_kwargs):
         """Always true for whole brain features"""
         return True