siibra 0.5a2__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

siibra/features/image/image.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -21,17 +21,18 @@ from .. import anchor as _anchor
 
 from ...volumes import volume as _volume
 
-from typing import List
+from typing import List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...locations.boundingbox import BoundingBox
+    from ...volumes.providers import provider
 
 
 class ImageAnchor(_anchor.AnatomicalAnchor):
 
     def __init__(self, volume: _volume.Volume, region: str = None):
         _anchor.AnatomicalAnchor.__init__(
-            self,
-            species=volume.space.species,
-            location=None,
-            region=region
+            self, species=volume.space.species, location=None, region=region
         )
         self.volume = volume
 
@@ -41,7 +42,9 @@ class ImageAnchor(_anchor.AnatomicalAnchor):
         Loads the bounding box only if required, since it demands image data access.
         """
         if self._location_cached is None:
-            self._location_cached = self.volume.boundingbox
+            self._location_cached = self.volume.get_boundingbox(
+                clip=False
+            )  # use unclipped to preseve exisiting behaviour
         return self._location_cached
 
     @property
@@ -59,16 +62,21 @@ class Image(feature.Feature, _volume.Volume):
         name: str,
         modality: str,
         space_spec: dict,
-        providers: List[_volume.VolumeProvider],
+        providers: List["provider.VolumeProvider"],
         region: str = None,
         datasets: List = [],
+        bbox: "BoundingBox" = None,
+        id: str = None,
+        prerelease: bool = False,
     ):
         feature.Feature.__init__(
             self,
             modality=modality,
             description=None,  # lazy implementation below!
             anchor=None,  # lazy implementation below!
-            datasets=datasets
+            datasets=datasets,
+            id=id,
+            prerelease=prerelease,
         )
 
         _volume.Volume.__init__(
@@ -77,14 +85,15 @@ class Image(feature.Feature, _volume.Volume):
             providers=providers,
             name=name,
             datasets=datasets,
+            bbox=bbox,
         )
 
         self._anchor_cached = ImageAnchor(self, region=region)
         self._description_cached = None
         self._name_cached = name
 
-    def _export(self, fh: ZipFile):
-        super()._export(fh)
+    def _to_zip(self, fh: ZipFile):
+        super()._to_zip(fh)
         # How, what do we download?
         # e.g. for marcel's volume, do we download at full resolution?
         # cannot implement until Volume has an export friendly method
@@ -101,7 +110,6 @@ class Image(feature.Feature, _volume.Volume):
     def description(self):
         if self._description_cached is None:
             self._description_cached = (
-                f"Image feature with modality {self.modality} "
-                f"at {self.anchor}"
+                f"Image feature with modality {self.modality} " f"at {self.anchor}"
             )
         return self._description_cached

siibra/features/image/sections.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");

siibra/features/image/volume_of_interest.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");

siibra/features/tabular/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");

siibra/features/tabular/bigbrain_intensity_profile.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -15,7 +15,9 @@
 
 from . import cortical_profile
 
-from ...locations import point
+from typing import List, TYPE_CHECKING
+if TYPE_CHECKING:
+    from ...features.anchor import AnatomicalAnchor
 
 
 class BigBrainIntensityProfile(
@@ -28,7 +30,7 @@ class BigBrainIntensityProfile(
         "as described in the publication 'Wagstyl, K., et al (2020). BigBrain 3D atlas of "
         "cortical layers: Cortical and laminar thickness gradients diverge in sensory and "
         "motor cortices. PLoS Biology, 18(4), e3000678. "
-        "http://dx.doi.org/10.1371/journal.pbio.3000678'."
+        "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."
@@ -38,18 +40,11 @@ class BigBrainIntensityProfile(
 
     def __init__(
         self,
-        regionname: str,
+        anchor: "AnatomicalAnchor",
         depths: list,
         values: list,
-        boundaries: list,
-        location: point.Point
+        boundaries: list
     ):
-        from ..anchor import AnatomicalAnchor
-        anchor = AnatomicalAnchor(
-            location=location,
-            region=regionname,
-            species='Homo sapiens'
-        )
         cortical_profile.CorticalProfile.__init__(
             self,
             description=self.DESCRIPTION,
@@ -63,4 +58,20 @@ class BigBrainIntensityProfile(
                 for b in cortical_profile.CorticalProfile.BOUNDARIES
             }
         )
-        self.location = location
+
+    @property
+    def location(self):
+        return self.anchor.location
+
+    @classmethod
+    def _merge_anchors(cls, anchors: List['AnatomicalAnchor']):
+        from ...locations.pointcloud import from_points
+        from ...features.anchor import AnatomicalAnchor
+
+        location = from_points([anchor.location for anchor in anchors])
+        regions = {anchor._regionspec for anchor in anchors}
+        return AnatomicalAnchor(
+            location=location,
+            region=", ".join(regions),
+            species='Homo sapiens'
+        )

siibra/features/tabular/cell_density_profile.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,15 +16,77 @@
 from . import cortical_profile
 
 from .. import anchor as _anchor
-from ...commons import PolyLine, logger, create_key
+from ...commons import logger
 from ...retrieval import requests
 
 from skimage.draw import polygon
 from skimage.transform import resize
-from io import BytesIO
 import numpy as np
 import pandas as pd
 
+from io import BytesIO
+from typing import Union, Tuple, Iterable
+
+
+def cell_reader(bytes_buffer: bytes):
+    return pd.read_csv(BytesIO(bytes_buffer[2:]), delimiter=" ", header=0).astype(
+        {"layer": int, "label": int}
+    )
+
+
+def layer_reader(bytes_buffer: bytes):
+    return pd.read_csv(BytesIO(bytes_buffer[2:]), delimiter=" ", header=0, index_col=0)
+
+
+def poly_srt(poly):
+    return poly[poly[:, 0].argsort(), :]
+
+
+def poly_rev(poly):
+    return poly[poly[:, 0].argsort()[::-1], :]
+
+
+class PolyLine:
+    """Simple polyline representation which allows equidistant sampling."""
+
+    def __init__(self, pts):
+        self.pts = pts
+        self.lengths = [
+            np.sqrt(np.sum((pts[i, :] - pts[i - 1, :]) ** 2))
+            for i in range(1, pts.shape[0])
+        ]
+
+    def length(self):
+        return sum(self.lengths)
+
+    def sample(self, d: Union[Iterable[float], np.ndarray, float]):
+        # if d is interable, we assume a list of sample positions
+        try:
+            iter(d)
+        except TypeError:
+            positions = [d]
+        else:
+            positions = d
+
+        samples = []
+        for s_ in positions:
+            s = min(max(s_, 0), 1)
+            target_distance = s * self.length()
+            current_distance = 0
+            for i, length in enumerate(self.lengths):
+                current_distance += length
+                if current_distance >= target_distance:
+                    p1 = self.pts[i, :]
+                    p2 = self.pts[i + 1, :]
+                    r = (target_distance - current_distance + length) / length
+                    samples.append(p1 + (p2 - p1) * r)
+                    break
+
+        if len(samples) == 1:
+            return samples[0]
+        else:
+            return np.array(samples)
+
 
 class CellDensityProfile(
     cortical_profile.CorticalProfile,
@@ -43,25 +105,7 @@ class CellDensityProfile(
 
     BIGBRAIN_VOLUMETRIC_SHRINKAGE_FACTOR = 1.931
 
-    _filter_attrs = cortical_profile.CorticalProfile._filter_attrs + ["section", "patch"]
-
-    @classmethod
-    def CELL_READER(cls, b):
-        return pd.read_csv(BytesIO(b[2:]), delimiter=" ", header=0).astype(
-            {"layer": int, "label": int}
-        )
-
-    @classmethod
-    def LAYER_READER(cls, b):
-        return pd.read_csv(BytesIO(b[2:]), delimiter=" ", header=0, index_col=0)
-
-    @staticmethod
-    def poly_srt(poly):
-        return poly[poly[:, 0].argsort(), :]
-
-    @staticmethod
-    def poly_rev(poly):
-        return poly[poly[:, 0].argsort()[::-1], :]
+    _filter_attrs = cortical_profile.CorticalProfile._filter_attrs + ["location"]
 
     def __init__(
         self,
@@ -69,7 +113,9 @@ class CellDensityProfile(
         patch: int,
         url: str,
         anchor: _anchor.AnatomicalAnchor,
-        datasets: list = []
+        datasets: list = [],
+        id: str = None,
+        prerelease: bool = False,
     ):
         """
         Generate a cell density profile from a URL to a cloud folder
@@ -79,15 +125,17 @@ class CellDensityProfile(
             self,
             description=self.DESCRIPTION,
             modality="Segmented cell body density",
-            unit="detected cells / 0.1mm3",
+            unit="cells / 0.1mm3",
             anchor=anchor,
             datasets=datasets,
+            id=id,
+            prerelease=prerelease,
         )
         self._step = 0.01
         self._url = url
-        self._cell_loader = requests.HttpRequest(url, self.CELL_READER)
+        self._cell_loader = requests.HttpRequest(url, cell_reader)
         self._layer_loader = requests.HttpRequest(
-            url.replace("segments", "layerinfo"), self.LAYER_READER
+            url.replace("segments", "layerinfo"), layer_reader
         )
         self._density_image = None
         self._layer_mask = None
@@ -95,49 +143,55 @@ class CellDensityProfile(
         self.section = section
         self.patch = patch
 
+    @property
+    def location(self):
+        return self.anchor.location
+
     @property
     def shape(self):
-        return tuple(self.cells[["y", "x"]].max().astype("int") + 1)
+        """(y,x)"""
+        return tuple(np.ceil(self.cells[["y", "x"]].max()).astype("int"))
 
-    def boundary_annotation(self, boundary):
+    def boundary_annotation(self, boundary: Tuple[int, int]) -> np.ndarray:
         """Returns the annotation of a specific layer boundary."""
-        y1, x1 = self.shape
+        shape_y, shape_x = self.shape
 
         # start of image patch
         if boundary == (-1, 0):
-            return np.array([[0, 0], [x1, 0]])
+            return np.array([[0, 0], [shape_x, 0]])
 
         # end of image patch
         if boundary == (7, 8):
-            return np.array([[0, y1], [x1, y1]])
+            return np.array([[0, shape_y], [shape_x, shape_y]])
 
         # retrieve polygon
         basename = "{}_{}.json".format(
             *(self.LAYERS[layer] for layer in boundary)
         ).replace("0_I", "0")
-        url = self._url.replace("segments.txt", basename)
-        poly = self.poly_srt(np.array(requests.HttpRequest(url).get()["segments"]))
+        poly_url = self._url.replace("segments.txt", basename)
+        poly = poly_srt(np.array(requests.HttpRequest(poly_url).get()["segments"]))
 
-        # ensure full width
+        # ensure full width and trim to the image shape
         poly[0, 0] = 0
-        poly[-1, 0] = x1
+        poly[poly[:, 0] > shape_x, 0] = shape_x
+        poly[poly[:, 1] > shape_y, 1] = shape_y
 
         return poly
 
-    def layer_annotation(self, layer):
+    def layer_annotation(self, layer: int) -> np.ndarray:
         return np.vstack(
             (
                 self.boundary_annotation((layer - 1, layer)),
-                self.poly_rev(self.boundary_annotation((layer, layer + 1))),
+                poly_rev(self.boundary_annotation((layer, layer + 1))),
                 self.boundary_annotation((layer - 1, layer))[0, :],
             )
         )
 
     @property
-    def layer_mask(self):
+    def layer_mask(self) -> np.ndarray:
         """Generates a layer mask from boundary annotations."""
         if self._layer_mask is None:
-            self._layer_mask = np.zeros(np.array(self.shape).astype("int") + 1)
+            self._layer_mask = np.zeros(np.array(self.shape, dtype=int) + 1, dtype="int")
             for layer in range(1, 8):
                 pl = self.layer_annotation(layer)
                 X, Y = polygon(pl[:, 0], pl[:, 1])
@@ -145,20 +199,20 @@ class CellDensityProfile(
         return self._layer_mask
 
     @property
-    def depth_image(self):
+    def depth_image(self) -> np.ndarray:
         """Cortical depth image from layer boundary polygons by equidistant sampling."""
 
         if self._depth_image is None:
-
+            logger.info("Calculating cell densities from cell and layer data...")
             # compute equidistant cortical depth image from inner and outer contour
             scale = 0.1
-            D = np.zeros((np.array(self.density_image.shape) * scale).astype("int") + 1)
+            depth_arr = np.zeros(np.ceil(np.array(self.shape) * scale).astype("int") + 1)
 
             # determine sufficient stepwidth for profile sampling
             # to match downscaled image resolution
-            vstep, hstep = 1.0 / np.array(D.shape) / 2.0
+            vstep, hstep = 1.0 / np.array(depth_arr.shape) / 2.0
             vsteps = np.arange(0, 1 + vstep, vstep)
-            hsteps = np.arange(0, 1 + vstep, hstep)
+            hsteps = np.arange(0, 1 + hstep, hstep)
 
             # build straight profiles between outer and inner cortical boundary
             s0 = PolyLine(self.boundary_annotation((0, 1)) * scale).sample(hsteps)
@@ -167,16 +221,16 @@ class CellDensityProfile(
 
             # write sample depths to their location in the depth image
             for prof in profiles:
-                XY = prof.sample(vsteps).astype("int")
-                D[XY[:, 1], XY[:, 0]] = vsteps
+                prof_samples_as_index = prof.sample(vsteps).astype("int")
+                depth_arr[prof_samples_as_index[:, 1], prof_samples_as_index[:, 0]] = vsteps
 
             # fix wm region, account for rounding error
             XY = self.layer_annotation(7) * scale
-            D[polygon(XY[:, 1] - 1, XY[:, 0])] = 1
-            D[-1, :] = 1
+            depth_arr[polygon(XY[:, 1] - 1, XY[:, 0])] = 1
+            depth_arr[-1, :] = 1
 
             # rescale depth image to original patch size
-            self._depth_image = resize(D, self.density_image.shape)
+            self._depth_image = resize(depth_arr, self.density_image.shape)
 
         return self._depth_image
 
@@ -192,7 +246,7 @@ class CellDensityProfile(
         return self._boundary_positions
 
     @property
-    def density_image(self):
+    def density_image(self) -> np.ndarray:
         if self._density_image is None:
             logger.debug("Computing density image for", self._url)
             # we integrate cell counts into 2D bins
@@ -201,9 +255,7 @@ class CellDensityProfile(
             counts, xedges, yedges = np.histogram2d(
                 self.cells.y,
                 self.cells.x,
-                bins=(np.array(self.layer_mask.shape) / pixel_size_micron + 0.5).astype(
-                    "int"
-                ),
+                bins=np.round(np.array(self.shape) / pixel_size_micron).astype("int"),
             )
 
             # rescale the counts from count / pixel_size**2  to count / 0.1mm^3,
@@ -221,19 +273,20 @@ class CellDensityProfile(
         return self._density_image
 
     @property
-    def cells(self):
+    def cells(self) -> pd.DataFrame:
         return self._cell_loader.get()
 
     @property
-    def layers(self):
+    def layers(self) -> pd.DataFrame:
         return self._layer_loader.get()
 
     @property
     def _depths(self):
-        return [d + self._step / 2 for d in np.arange(0, 1, self._step)]
+        return np.arange(0, 1, self._step) + self._step / 2
 
     @property
     def _values(self):
+        # TODO: release a dataset update instead of on the fly computation
         densities = []
         delta = self._step / 2.0
         for d in self._depths:
@@ -241,16 +294,5 @@ class CellDensityProfile(
             if np.sum(mask) > 0:
                 densities.append(self.density_image[mask].mean())
             else:
-                densities.append(np.NaN)
-        return densities
-
-    @property
-    def key(self):
-        assert len(self.species) == 1
-        return create_key("{}_{}_{}_{}_{}".format(
-            self.id,
-            self.species[0]['name'],
-            self.regionspec,
-            self.section,
-            self.patch
-        ))
+                densities.append(np.nan)
+        return np.asanyarray(densities)

siibra/features/tabular/cortical_profile.py

@@ -1,4 +1,4 @@
-# Copyright 2018-2021
+# Copyright 2018-2024
 # Institute of Neuroscience and Medicine (INM-1), Forschungszentrum Jülich GmbH
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,7 +19,7 @@ from ..feature import Compoundable
 from .. import anchor as _anchor
 
 import pandas as pd
-from typing import Union, Dict, Tuple
+from typing import Union, Dict, Tuple, List
 from textwrap import wrap
 import numpy as np
 
@@ -56,7 +56,9 @@ class CorticalProfile(tabular.Tabular, Compoundable):
         values: Union[list, np.ndarray] = None,
         unit: str = None,
         boundary_positions: Dict[Tuple[int, int], float] = None,
-        datasets: list = []
+        datasets: list = [],
+        id: str = None,
+        prerelease: bool = False,
     ):
         """Initialize profile.
 
@@ -96,21 +98,23 @@ class CorticalProfile(tabular.Tabular, Compoundable):
             description=description,
             anchor=anchor,
             data=None,  # lazy loader below
-            datasets=datasets
+            datasets=datasets,
+            id=id,
+            prerelease=prerelease,
         )
 
     def _check_sanity(self):
         # check plausibility of the profile
-        assert isinstance(self._depths, (list, np.ndarray))
-        assert isinstance(self._values, (list, np.ndarray))
-        assert len(self._values) == len(self._depths)
-        assert all(0 <= d <= 1 for d in self._depths)
+        assert isinstance(self._depths, (list, np.ndarray)), "Some depths are not valid"
+        assert isinstance(self._values, (list, np.ndarray)), "Some values are not valid"
+        assert len(self._values) == len(self._depths), "There exist uneven number of depths and values"
+        assert all(0 <= d <= 1 for d in self._depths), "Some depths is not between 0 and 1"
         if self.boundaries_mapped:
-            assert all(0 <= d <= 1 for d in self.boundary_positions.values())
+            assert all(0 <= d <= 1 for d in self.boundary_positions.values()), "Some boundary positions are not between 0 and 1"
             assert all(
                 layerpair in self.BOUNDARIES
                 for layerpair in self.boundary_positions.keys()
-            )
+            ), "Some value in BOUNDARIES are not mapped in boundary_positions"
 
     @property
     def unit(self) -> str:
@@ -159,8 +163,32 @@ class CorticalProfile(tabular.Tabular, Compoundable):
     def data(self):
         """Return a pandas Series representing the profile."""
         self._check_sanity()
-        return pd.DataFrame(
-            self._values, index=self._depths, columns=[f"{self.modality} ({self.unit})"]
+        iscompound = len(self._values.shape) > 1 and self._values.shape[1] == 2
+        if iscompound:
+            columns = [f"{self.modality} mean ({self.unit})", "std"]
+        else:
+            columns = [f"{self.modality} ({self.unit})"]
+        return pd.DataFrame(self._values, index=self._depths, columns=columns)
+
+    @classmethod
+    def _merge_elements(
+        cls,
+        elements: List["CorticalProfile"],
+        description: str,
+        modality: str,
+        anchor: _anchor.AnatomicalAnchor,
+    ):
+        assert all(np.array_equal(elements[0]._depths, f._depths) for f in elements)
+        assert len({f.unit for f in elements}) == 1
+        values_stacked = np.stack([f._values for f in elements])
+        return CorticalProfile(
+            description=description,
+            modality=modality,
+            anchor=anchor,
+            depths=np.stack([f._depths for f in elements]).mean(0),
+            values=np.stack([values_stacked.mean(0), values_stacked.std(0)]).T,
+            unit=elements[0].unit,
+            boundary_positions=None,
         )
 
     def plot(self, *args, backend="matplotlib", **kwargs):
@@ -180,12 +208,17 @@ class CorticalProfile(tabular.Tabular, Compoundable):
         kwargs["title"] = kwargs.get("title", "\n".join(wrap(self.name, wrapwidth)))
         layercolor = kwargs.pop("layercolor", "gray")
 
+        iscompound = len(self._values.shape) > 1 and self._values.shape[1] == 2
+        ymax = max(
+            0,
+            sum(self._values.max(axis=0)) if iscompound else self._values.max()
+        )
         if backend == "matplotlib":
             kwargs["xlabel"] = kwargs.get("xlabel", "Cortical depth")
             kwargs["ylabel"] = kwargs.get("ylabel", self.unit)
             kwargs["grid"] = kwargs.get("grid", True)
-            kwargs["ylim"] = kwargs.get("ylim", (0, max(self._values)))
-            axs = self.data.plot(*args, **kwargs, backend=backend)
+            axs = self.data.iloc[:, 0].plot(*args, **kwargs, backend=backend)
+            axs.set_ylim(kwargs.get("ylim", (0, ymax)))
 
             if self.boundaries_mapped:
                 bvals = list(self.boundary_positions.values())
@@ -201,14 +234,22 @@ class CorticalProfile(tabular.Tabular, Compoundable):
                         axs.axvspan(d1, d2, color=layercolor, alpha=0.3)
 
             axs.set_title(axs.get_title(), fontsize="medium")
+
+            if iscompound:
+                axs.set_ylabel(f"average {kwargs['ylabel']} \u00b1 std")
+                av = self.data.values[:, 0]
+                std = self.data.values[:, 1]
+                axs.fill_between(self.data.index.values, av - std, av + std, alpha=0.5)
+
             return axs
+
         elif backend == "plotly":
             kwargs["title"] = kwargs["title"].replace("\n", "<br>")
             kwargs["labels"] = {
                 "index": kwargs.pop("xlabel", None) or kwargs.pop("index", "Cortical depth"),
                 "value": kwargs.pop("ylabel", None) or kwargs.pop("value", self.unit)
             }
-            fig = self.data.plot(*args, **kwargs, backend=backend)
+            fig = self.data.iloc[:, 0].plot(*args, **kwargs, backend=backend)
             if self.boundaries_mapped:
                 bvals = list(self.boundary_positions.values())
                 for i, (d1, d2) in enumerate(list(zip(bvals[:-1], bvals[1:]))):
@@ -219,12 +260,29 @@ class CorticalProfile(tabular.Tabular, Compoundable):
                     )
             fig.update_layout(
                 showlegend=False,
-                yaxis_range=(0, max(self._values)),
+                yaxis_range=(0, ymax),
                 title=dict(
                     automargin=True, yref="container", xref="container",
                     pad=dict(t=40), xanchor="left", yanchor="top"
                 )
             )
+            if iscompound:
+                from plotly.graph_objects import Scatter
+                x = self.data.index.values
+                av = self.data.values[:, 0]
+                std = self.data.values[:, 1]
+                fig.update_layout(yaxis_title=f"average {kwargs['labels']['value']} &plusmn; std")
+                fig.add_traces(
+                    Scatter(
+                        x=np.concatenate((x, x[::-1])),  # x, then x reversed
+                        y=np.concatenate((av + std, (av - std)[::-1])),  # upper, then lower reversed
+                        fill='toself',
+                        fillcolor='rgba(0,100,80,0.5)',
+                        line=dict(color='rgba(255,255,255,0)'),
+                        hoverinfo="skip",
+                        showlegend=False
+                    )
+                )
             return fig
         else:
             return self.data.plot(*args, **kwargs, backend=backend)
@@ -254,3 +312,11 @@ class CorticalProfile(tabular.Tabular, Compoundable):
                 f"'_values' not available for {self.__class__.__name__}."
             )
         return self._values_cached
+
+    @property
+    def name(self):
+        if hasattr(self, "receptor"):
+            return super().name + f": {self.receptor}"
+        if hasattr(self, "location"):
+            return super().name + f": {self.location.coordinate}"
+        return super().name