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

siibra/features/tabular/layerwise_cell_density.py

@@ -13,17 +13,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from . import cortical_profile
-from .. import anchor as _anchor
-from . import tabular
-from ..tabular.cell_density_profile import cell_reader, layer_reader
+import numpy as np
+import pandas as pd
+from textwrap import wrap
 
+from . import tabular, cell_reader, layer_reader
+from .. import anchor as _anchor
 from ... import commons
 from ...retrieval import requests
 
-import pandas as pd
-import numpy as np
-
 
 class LayerwiseCellDensity(
     tabular.Tabular,
@@ -39,6 +37,7 @@ class LayerwiseCellDensity(
         "detected cells in that layer with the area covered by the layer. Therefore, each profile contains 6 measurement points. "
         "The cortical depth is estimated from the measured layer thicknesses."
     )
+    BIGBRAIN_VOLUMETRIC_SHRINKAGE_FACTOR = 1.931
 
     def __init__(
         self,
@@ -59,13 +58,13 @@ class LayerwiseCellDensity(
             id=id,
             prerelease=prerelease,
         )
-        self.unit = "# detected cells/0.1mm3"
+        self.unit = "# detected cells / $0.1mm^3$"
         self._filepairs = list(zip(segmentfiles, layerfiles))
         self._densities = None
 
     def _load_densities(self):
-        density_dict = {}
-        for i, (cellfile, layerfile) in enumerate(self._filepairs):
+        data = []
+        for cellfile, layerfile in self._filepairs:
             try:
                 cells = requests.HttpRequest(cellfile, func=cell_reader).data
                 layers = requests.HttpRequest(layerfile, func=layer_reader).data
@@ -74,22 +73,82 @@ class LayerwiseCellDensity(
                 commons.logger.error(f"Skipping to bootstrap a {self.__class__.__name__} feature, cannot access file resource.")
                 continue
             counts = cells.layer.value_counts()
-            areas = layers["Area(micron**2)"]
-            indices = np.intersect1d(areas.index, counts.index)
-            density_dict[i] = counts[indices] / areas * 100 ** 2 * 5
-        return pd.DataFrame(density_dict)
+            # compute the volumetric shrinkage corrections in the same ways as it was used
+            # for the pdf reports in the underlying dataset
+            shrinkage_volumetric = self.BIGBRAIN_VOLUMETRIC_SHRINKAGE_FACTOR
+            layer_volumes = (
+                layers["Area(micron**2)"]  # this is the number of pixels, shrinkage corrected from the dataset
+                * 20  # go to cube micrometer in one patch with 20 micron thickness
+                * np.cbrt(shrinkage_volumetric)  # compensate linear shrinkage for 3rd dimension
+                / 100 ** 3  # go to 0.1 cube millimeter
+            )
+            fields = cellfile.split("/")
+            for layer in layer_volumes.index:
+                data.append({
+                    'layer': layer,
+                    'layername': layers["Name"].loc[layer],
+                    'counts': counts.loc[layer],
+                    'area_mu2': layers["Area(micron**2)"].loc[layer],
+                    'volume': layer_volumes.loc[layer],
+                    'density': counts.loc[layer] / layer_volumes.loc[layer],
+                    'regionspec': fields[-5],
+                    'section': int(fields[-3]),
+                    'patch': int(fields[-2]),
+                })
+        return pd.DataFrame(data)
 
     @property
     def data(self):
         if self._data_cached is None:
-            densities = self._load_densities()
-            self._data_cached = pd.DataFrame(
-                np.array([
-                    list(densities.mean(axis=1)),
-                    list(densities.std(axis=1))
-                ]).T,
-                columns=['mean', 'std'],
-                index=[cortical_profile.CorticalProfile.LAYERS[_] for _ in densities.index]
-            )
-            self._data_cached.index.name = 'layer'
+            self._data_cached = self._load_densities()
+            # self._data_cached.index.name = 'layer'
         return self._data_cached
+
+    def plot(self, *args, backend="matplotlib", **kwargs):
+        wrapwidth = kwargs.pop("textwrap") if "textwrap" in kwargs else 40
+        kwargs["title"] = kwargs.pop(
+            "title",
+            "\n".join(wrap(
+                f"{self.modality} in {self.anchor._regionspec or self.anchor.location}",
+                wrapwidth
+            ))
+        )
+        kwargs["kind"] = kwargs.get("kind", "box")
+        kwargs["ylabel"] = kwargs.get(
+            "ylabel",
+            f"\n{self.unit}" if hasattr(self, 'unit') else ""
+        )
+        if backend == "matplotlib":
+            if kwargs["kind"] == "box":
+                from matplotlib.pyplot import tight_layout
+
+                np.random.seed(int(self.data["density"].mean()))
+
+                title = kwargs.pop("title")
+                default_kwargs = {
+                    "grid": True,
+                    'by': "layername",
+                    'column': ['density'],
+                    'showfliers': False,
+                    'xlabel': 'layer',
+                    'color': 'dimgray',
+                }
+                ax, *_ = self.data.plot(*args, backend=backend, **{**default_kwargs, **kwargs})
+                for i, (layer, d) in enumerate(self.data.groupby('layername')):
+                    ax.scatter(
+                        np.random.normal(i + 1, 0.05, len(d.density)),
+                        d.density,
+                        c='b', s=3
+                    )
+                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>")
+            yaxis_title = kwargs.pop("ylabel")
+            fig = self.data.plot(y='density', x='layer', points="all", backend=backend, **kwargs)
+            fig.update_layout(yaxis_title=yaxis_title)
+            return fig
+        else:
+            return self.data.plot(*args, backend=backend, **kwargs)

siibra/features/tabular/receptor_density_fingerprint.py

@@ -13,18 +13,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .. import anchor as _anchor
-from . import tabular
+from textwrap import wrap
+from typing import List
+
+import numpy as np
+import pandas as pd
 
+from . import tabular
+from .. import anchor as _anchor
 from ...commons import logger
 from ...vocabularies import RECEPTOR_SYMBOLS
 from ...retrieval import requests
 
-import pandas as pd
-import numpy as np
-from textwrap import wrap
-from typing import List
-
 
 class ReceptorDensityFingerprint(
     tabular.Tabular,
@@ -190,6 +190,31 @@ class ReceptorDensityFingerprint(
         else:
             raise NotImplementedError
 
-    def plot(self, *args, **kwargs):
+    def plot(
+        self,
+        *args,
+        receptors: List[str] = None,
+        backend: str = "matplotlib",
+        **kwargs
+    ):
+        """
+        Create a bar plot of receptor density fingerprint.
+
+        Parameters
+        ----------
+        receptors : List[str], optional
+            Plot a subset of receptors.
+        backend: str
+            "matplotlib", "plotly", or others supported by pandas DataFrame
+            plotting backend.
+        **kwargs
+            takes Matplotlib.pyplot keyword arguments
+        """
         kwargs['xlabel'] = ""
-        return super().plot(*args, **kwargs)
+        kwargs["backend"] = backend
+        og_data = self.data
+        if receptors is not None:
+            self._data_cached = og_data.loc[receptors]
+        fig = super().plot(*args, **kwargs)
+        self._data_cached = og_data
+        return fig

siibra/features/tabular/receptor_density_profile.py

@@ -13,9 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .. import anchor as _anchor
 from . import cortical_profile
-
+from .. import anchor as _anchor
 from ... import vocabularies
 from ...commons import create_key
 from ...retrieval import requests

siibra/features/tabular/regional_timeseries_activity.py

@@ -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):

siibra/features/tabular/tabular.py

@@ -15,15 +15,14 @@
 """Base type of features in tabular formats."""
 
 from zipfile import ZipFile
-from .. import feature
-
-from .. import anchor as _anchor
-
-from ...commons import logger
 
 import pandas as pd
 from textwrap import wrap
 
+from .. import feature
+from .. import anchor as _anchor
+from ...commons import logger
+
 
 class Tabular(feature.Feature):
     """
@@ -100,14 +99,20 @@ class Tabular(feature.Feature):
             if kwargs.get("error_y") is None:
                 kwargs["yerr"] = kwargs.get("yerr", 'std' if 'std' in self.data.columns else None)
                 yerr_label = f" \u00b1 {kwargs.get('yerr')}" if kwargs.get('yerr') else ''
-            kwargs["width"] = kwargs.get("width", 0.95)
+            if kwargs.get('kind') == 'bar':
+                kwargs["width"] = kwargs.get("width", 0.8)
+                kwargs["edgecolor"] = kwargs.get('edgecolor', 'black')
+                kwargs["linewidth"] = kwargs.get('linewidth', 1.0)
+                kwargs["capsize"] = kwargs.get('capsize', 4)
             kwargs["ylabel"] = kwargs.get(
                 "ylabel",
                 f"{kwargs['y']}{yerr_label}" + f"\n{self.unit}" if hasattr(self, 'unit') else ""
             )
             kwargs["grid"] = kwargs.get("grid", True)
             kwargs["legend"] = kwargs.get("legend", False)
-            xticklabel_rotation = kwargs.get("xticklabel_rotation", 60)
+            kwargs["color"] = kwargs.get('color', 'darkgrey')
+
+            xticklabel_rotation = kwargs.get("rot", 60)
             ax = self.data.plot(*args, backend=backend, **kwargs)
             ax.set_title(ax.get_title(), fontsize="medium")
             ax.set_xticklabels(
@@ -115,6 +120,8 @@ class Tabular(feature.Feature):
                 rotation=xticklabel_rotation,
                 ha='center' if xticklabel_rotation % 90 == 0 else 'right'
             )
+            ax.spines['top'].set_visible(False)
+            ax.spines['right'].set_visible(False)
             plt.tight_layout()
             return ax
         elif backend == "plotly":

siibra/livequeries/allen.py

@@ -14,21 +14,22 @@
 # 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 ..core.region import Region
 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 +52,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.
 
@@ -117,7 +118,7 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
         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 +145,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}"
@@ -175,6 +174,8 @@ class AllenBrainAtlasQuery(LiveQuery, args=['gene'], FeatureType=GeneExpressions
             explanation=explanation
         )]
         anchor._last_matched_concept = concept
+        if isinstance(concept, Region):
+            anchor._regionspec = concept.name
 
         return [GeneExpressions(
             anchor=anchor,