marsilea 0.4.2__py3-none-any.whl → 0.4.3__py3-none-any.whl

marsilea/plotter/_images.py

@@ -2,98 +2,292 @@
 # issues across different rendering backend at different DPI. Currently
 # not a public API.
 from functools import partial
+from hashlib import sha256
+from numbers import Number
+from pathlib import Path
 
 import numpy as np
+from PIL import Image as PILImage
 from matplotlib.image import imread, BboxImage
 from matplotlib.transforms import Bbox
-from pathlib import Path
 from platformdirs import user_cache_dir
-from urllib.request import urlretrieve
 
 from .base import RenderPlan
 
-TWEMOJI_CDN = "https://cdn.jsdelivr.net/gh/twitter/twemoji/assets/72x72/"
-
 
 def _cache_remote(url, cache=True):
+    try:
+        import requests
+    except ImportError:
+        raise ImportError("Required requests, try `pip install requests`.")
     data_dir = Path(user_cache_dir(appname="Marsilea"))
     data_dir.mkdir(exist_ok=True, parents=True)
 
-    fname = url.split("/")[-1]
+    hasher = sha256()
+    hasher.update(url.encode("utf-8"))
+    fname = hasher.hexdigest()
+
     dest = data_dir / fname
     if not (cache and dest.exists()):
-        urlretrieve(url, dest)
+        r = requests.get(url, headers={"User-Agent": "Mozilla/5.0"})
+        r.raise_for_status()
+        with open(dest, "wb") as f:
+            f.write(r.content)
 
     return dest
 
 
-class Emoji(RenderPlan):
-    def __init__(self, images, lang="en", scale=1, mode="filled"):
-        try:
-            import emoji
-        except ImportError:
-            raise ImportError("Required emoji, try `pip install emoji`.")
+class Image(RenderPlan):
+    """Plot static images
 
-        codes = []
-        for i in images:
-            i = emoji.emojize(i, language=lang)
-            if not emoji.is_emoji(i):
-                raise ValueError(f"{i} is not a valid emoji")
-            codes.append(f"{ord(i):X}".lower())
+    Parameters
+    ----------
+    images : array of image
+        You can input either path to the image, URL, or numpy array.
+    align : {"center", "top", "bottom", "left", "right"}, default: "center"
+        The alignment of the images.
+    scale : float, default: 1
+        The scale of the images.
+    spacing : float, default: 0.1
+        The spacing between images, a value between 0 and 1,
+        relative to the image container size.
+    resize : int or tuple, default: None
+        The size to resize the images.
+
+    Examples
+    --------
+
+    .. plot::
+        :context: close-figs
 
-        self.set_data(np.asarray(codes))
-        self.emoji_caches = {}
-        for c in codes:
-            cache_image = _cache_remote(f"{TWEMOJI_CDN}{c}.png")
-            self.emoji_caches[c] = imread(cache_image)
+        >>> import numpy as np
+        >>> import marsilea as ma
+        >>> c = ma.ZeroWidth(height=2)
+        >>> c.add_right(
+        ...     ma.plotter.Image(
+        ...         [
+        ...             "https://www.iconfinder.com/icons/4375050/download/png/512",
+        ...             "https://www.iconfinder.com/icons/8666426/download/png/512",
+        ...             "https://www.iconfinder.com/icons/652581/download/png/512",
+        ...         ],
+        ...         align="right",
+        ...     ),
+        ...     pad=0.1,
+        ... )
+        >>> c.add_right(
+        ...     ma.plotter.Labels(["Python", "Rust", "JavaScript"], fontsize=20), pad=0.1
+        ... )
+        >>> c.render()
 
+    """
+
+    def __init__(
+        self,
+        images,
+        align="center",
+        scale=1,
+        spacing=0.1,
+        resize=None,
+    ):
+        self.images_mapper = {}
+
+        for i, img in enumerate(images):
+            if isinstance(img, str):
+                # Read from URL
+                if img.startswith("http") or img.startswith("https"):
+                    img = imread(_cache_remote(img))
+                else:
+                    # Read from string path
+                    img = imread(img)
+            # Read from Path
+            elif isinstance(img, Path):
+                img = imread(img)
+            else:
+                # Read from array interface
+                img = np.asarray(img)
+
+            self.images_mapper[i] = img
+
+        self.images_codes = np.asarray(list(self.images_mapper.keys()))
+
+        self.images = images
+        self.align = align
         self.scale = scale
-        self.mode = mode
+        if not 0 <= spacing <= 1:
+            raise ValueError("spacing should be between 0 and 1")
+        self.spacing = spacing
+        if resize is not None:
+            if isinstance(resize, Number):
+                resize = (int(resize), int(resize))
+            for i, img in self.images_mapper.items():
+                self.images_mapper[i] = img.resize(resize, PILImage.Resampling.LANCZOS)
+        for i, img in self.images_mapper.items():
+            self.images_mapper[i] = np.asarray(img)
+        self.set_data(self.images_codes)
+
+    def _get_bbox_imges(
+        self, ax, imgs, scale=1, align="center", ax_height=None, ax_width=None
+    ):
+        locs = np.linspace(0, 1, len(imgs) + 1)
+        slot_size = locs[1] - locs[0]
+        locs = locs[:-1] + slot_size * self.spacing / 2
+
+        xmin, ymin = ax.transAxes.transform((0, 0))
+        xmax, ymax = ax.transAxes.transform((1, 1))
+
+        if ax_width is None or ax_width == 0:
+            ax_width = xmax - xmin
+        if ax_height is None or ax_height == 0:
+            ax_height = ymax - ymin
+
+        base_dpi = ax.get_figure().get_dpi()
+
+        bbox_images = []
+        imgaes_sizes = []
+
+        if self.is_body:
+            fit_width = ax_width / len(imgs) * (1 - self.spacing)
+            for loc, img in zip(locs, imgs):
+                height, width = img.shape[:2]
+                fit_height = height / width * fit_width
 
-    def _get_images_bbox(self, figure, imgs):
-        for img in imgs:
-            width, height = img.shape[:2]
+                fit_scale_width = fit_width * scale
+                fit_scale_height = fit_height * scale
 
-        return Bbox.from_bounds(0, 0, width, height)
+                offset = (fit_width - fit_scale_width) / 2 / ax_width
+                loc += offset
+
+                if align == "top":
+                    loc_y = 1 - fit_scale_height / ax_height
+                elif align == "bottom":
+                    loc_y = 0
+                else:
+                    loc_y = 0.5 - fit_scale_height / 2 / ax_height
+
+                def img_bbox(renderer, loc, loc_y, width, height, base_dpi):
+                    factor = renderer.dpi / base_dpi
+                    x0, y0 = ax.transData.transform((loc, loc_y))
+                    return Bbox.from_bounds(x0, y0, width * factor, height * factor)
+
+                memorized_img_bbox = partial(
+                    img_bbox,
+                    loc=loc,
+                    loc_y=loc_y,
+                    width=fit_scale_width,
+                    height=fit_scale_height,
+                    base_dpi=base_dpi,
+                )
+
+                i1 = BboxImage(memorized_img_bbox, data=img)
+                bbox_images.append(i1)
+                imgaes_sizes.append(fit_scale_height)
+        else:
+            fit_height = ax_height / len(imgs) * (1 - self.spacing)
+            for loc, img in zip(locs, imgs[::-1]):
+                height, width = img.shape[:2]
+                fit_width = width / height * fit_height
+
+                fit_scale_width = fit_width * scale
+                fit_scale_height = fit_height * scale
+
+                offset = (fit_height - fit_scale_height) / 2 / ax_height
+                loc += offset
+
+                if align == "right":
+                    loc_x = 1 - fit_scale_width / ax_width
+                elif align == "left":
+                    loc_x = 0
+                else:
+                    loc_x = 0.5 - fit_scale_width / 2 / ax_width
+
+                def img_bbox(renderer, loc_x, loc, width, height, base_dpi):
+                    factor = renderer.dpi / base_dpi
+                    x0, y0 = ax.transData.transform((loc_x, loc))
+                    return Bbox.from_bounds(x0, y0, width * factor, height * factor)
+
+                memorized_img_bbox = partial(
+                    img_bbox,
+                    loc_x=loc_x,
+                    loc=loc,
+                    width=fit_scale_width,
+                    height=fit_scale_height,
+                    base_dpi=base_dpi,
+                )
+
+                i1 = BboxImage(memorized_img_bbox, data=img)
+                bbox_images.append(i1)
+                imgaes_sizes.append(fit_scale_width)
+
+        return bbox_images, max(imgaes_sizes)
 
     def render_ax(self, spec):
         ax = spec.ax
-        data = spec.data
+        imgs = [self.images_mapper[i] for i in spec.data]
+        bbox_images, _ = self._get_bbox_imges(ax, imgs)
+        for i in bbox_images:
+            ax.add_artist(i)
+        ax.set_axis_off()
 
-        # TODO: Does not work for orient = "v"
-        locs = np.linspace(0, 1, len(data) + 1)
-        for loc, d in zip(locs, data):
-            img = self.emoji_caches[d]
-            width, height = img.shape[:2]
+    def get_canvas_size(
+        self, figure, main_height=None, main_width=None, **kwargs
+    ) -> float:
+        ax = figure.add_subplot(111)
+        imgs = [self.images_mapper[i] for i in self.images_codes]
+        _, size = self._get_bbox_imges(
+            ax, imgs, ax_width=main_width, ax_height=main_height
+        )
+        ax.remove()
+        return size
 
-            xmin, ymin = ax.transAxes.transform((0, 0))
-            xmax, ymax = ax.transAxes.transform((1, 1))
 
-            ax_width = xmax - xmin
-            ax_height = ymax - ymin
+# ======== EMOJI Plotter ========
 
-            fit_width = ax_width / len(data)
-            fit_height = height / width * fit_width
+TWEMOJI_CDN = "https://cdn.jsdelivr.net/gh/twitter/twemoji/assets/72x72/"
 
-            fit_scale_width = fit_width * self.scale
-            fit_scale_height = fit_height * self.scale
 
-            offset = (fit_width - fit_scale_width) / 2 / ax_width
-            loc += offset
+class Emoji(Image):
+    """Have fun with emoji images
 
-            loc_y = 0.5 - fit_scale_height / 2 / ax_height
+    The emoji images are from `twemoji <https://twemoji.twitter.com/>`_.
 
-            def get_emoji_bbox(renderer, loc, loc_y, width, height):
-                x0, y0 = ax.transData.transform((loc, loc_y))
-                return Bbox.from_bounds(x0, y0, width, height)
+    You can will all twemoji from `here <https://twemoji-cheatsheet.vercel.app/>`_
 
-            partial_get_emoji_bbox = partial(
-                get_emoji_bbox,
-                loc=loc,
-                loc_y=loc_y,
-                width=fit_scale_width,
-                height=fit_scale_height,
-            )
+    Parameters
+    ----------
+    codes : array of str
+        The emoji codes. You can input either unicode or short code.
+    lang : str, default: "en"
+        The language of the emoji.
+    scale : float, default: 1
+        The scale of the emoji.
+    spacing : float, default: 0.1
+        The spacing between emoji, a value between 0 and 1,
+        relative to the emoji container size.
+
+    Examples
+    --------
+
+    .. plot::
+
+        >>> import marsilea as ma
+        >>> c = ma.ZeroHeight(width=2)
+        >>> c.add_top(ma.plotter.Emoji("😆😆🤣😂😉😇🐍🦀🦄"))
+        >>> c.render()
+
+    """
+
+    def __init__(self, codes, lang="en", scale=1, spacing=0.1, **kwargs):
+        try:
+            import emoji
+        except ImportError:
+            raise ImportError("Required emoji, try `pip install emoji`.")
+
+        urls = []
+        for i in codes:
+            i = emoji.emojize(i, language=lang)
+            if not emoji.is_emoji(i):
+                raise ValueError(f"{i} is not a valid emoji")
+            c = f"{ord(i):X}".lower()
+            urls.append(f"{TWEMOJI_CDN}{c}.png")
 
-            i1 = BboxImage(partial_get_emoji_bbox, data=img)
-            ax.add_artist(i1)
+        super().__init__(urls, scale=scale, spacing=spacing, **kwargs)

marsilea/plotter/_seaborn.py

@@ -195,7 +195,7 @@ def _seaborn_doc(obj: _SeabornBase):
         >>> sdata = {sdata}
         >>> plot = {cls_name}(sdata, {kws})
         >>> h = ma.Heatmap(data)
-        >>> h.hsplit(cut=[3, 7])
+        >>> h.cut_rows(cut=[3, 7])
         >>> h.add_right(plot)
         >>> h.render()
     """
@@ -208,7 +208,7 @@ def _seaborn_doc(obj: _SeabornBase):
         
         >>> plot = {cls_name}({hue_data}, {kws})
         >>> h = ma.Heatmap(data)
-        >>> h.hsplit(cut=[3, 7])
+        >>> h.cut_rows(cut=[3, 7])
         >>> h.add_right(plot)
         >>> h.render()
         
@@ -222,7 +222,7 @@ def _seaborn_doc(obj: _SeabornBase):
         >>> anno = ma.plotter.Chunk(['C1', 'C2', 'C3'], colors, padding=10)
         >>> cb = ma.ClusterBoard(data, height=2, margin=.5)
         >>> cb.add_layer(plot)
-        >>> cb.vsplit(cut=[3, 7])
+        >>> cb.cut_cols([3, 7])
         >>> cb.add_bottom(anno)
         >>> cb.render()
         
@@ -233,9 +233,10 @@ def _seaborn_doc(obj: _SeabornBase):
         
         >>> plot = {cls_name}(sdata, orient='h',
         ...                   {h_kws})
+        >>> anno = ma.plotter.Chunk(['C1', 'C2', 'C3'], colors, padding=10)
         >>> cb = ma.ClusterBoard(data.T, width=2)
         >>> cb.add_layer(plot)
-        >>> cb.hsplit(cut=[3, 7])
+        >>> cb.cut_rows([3, 7])
         >>> cb.add_left(anno)
         >>> cb.render()
         

marsilea/plotter/arc.py

@@ -141,8 +141,7 @@ class Arc(StatsBase):
         >>> colors = ["C0", "C1", "C2", "C3", "C4", "C5", "C6"]
         >>> labels = ["A", "B", "C", "D", "E", "F", "G"]
         >>> h = ma.Heatmap(np.random.rand(10, 10))
-        >>> h.add_top(Arc(anchors, links, weights=weights,
-        ...               colors=colors, labels=labels))
+        >>> h.add_top(Arc(anchors, links, weights=weights, colors=colors, labels=labels))
         >>> h.render()
 
 

marsilea/plotter/bar.py

@@ -276,13 +276,13 @@ class CenterBar(_BarBase):
 class StackBar(_BarBase):
     """Stacked Bar
 
-     Parameters
-     ----------
-     data : np.ndarray, pd.DataFrame
+    Parameters
+    ----------
+    data : np.ndarray, pd.DataFrame
         2D data, index of dataframe is used as the name of items.
-     items : list of str
+    items : list of str
         The name of items.
-     colors : list of colors, mapping of (item, color)
+    colors : list of colors, mapping of (item, color)
         The colors of the bar for each item.
     orient : {"v", "h"}
         The orientation of the plot
@@ -309,8 +309,9 @@ class StackBar(_BarBase):
         :context: close-figs
 
         >>> from marsilea.plotter import StackBar
-        >>> stack_data = pd.DataFrame(data=np.random.randint(1, 10, (5, 10)),
-        ...                           index=list("abcde"))
+        >>> stack_data = pd.DataFrame(
+        ...     data=np.random.randint(1, 10, (5, 10)), index=list("abcde")
+        ... )
         >>> _, ax = plt.subplots()
         >>> StackBar(stack_data).render(ax)
 

marsilea/plotter/base.py

@@ -14,6 +14,13 @@ from .._deform import Deformation
 from ..exceptions import DataError, SplitConflict
 
 
+# class DataValidator:
+#
+#     @singledispatch(np.ndarray)
+#     def parse(self, data):
+#         pass
+
+
 class DataLoader:
     """Handle user data"""
 
@@ -397,7 +404,8 @@ class RenderPlan:
                 return self._get_intact_render_spec(axes)
         except Exception as _:
             raise DataError(
-                f"Please check your data input with {self.__class__.__name__}"
+                f"Please check your data input "
+                f"with {self.__class__.__name__} at '{self.side}'"
             )
 
     # def get_render_data(self):
@@ -508,7 +516,9 @@ class RenderPlan:
             if self._plan_label is not None:
                 self._plan_label.add(axes, self.side)
 
-    def get_canvas_size(self, figure) -> float:
+    def get_canvas_size(
+        self, figure, main_height=None, main_width=None, **kwargs
+    ) -> float:
         """
         If the size is unknown before rendering, this function must be
         implemented to return the canvas size in inches.

marsilea/plotter/bio.py

@@ -102,8 +102,9 @@ class SeqLogo(StatsBase):
 
         >>> import pandas as pd
         >>> from marsilea.plotter import SeqLogo
-        >>> matrix = pd.DataFrame(data=np.random.randint(1, 10, (4, 10)),
-        ...                       index=list("ACGT"))
+        >>> matrix = pd.DataFrame(
+        ...     data=np.random.randint(1, 10, (4, 10)), index=list("ACGT")
+        ... )
         >>> _, ax = plt.subplots()
         >>> colors = {"A": "r", "C": "b", "G": "g", "T": "black"}
         >>> SeqLogo(matrix, color_encode=colors).render(ax)

marsilea/plotter/mesh.py

@@ -103,7 +103,7 @@ class ColorMesh(MeshBase):
 
         >>> import marsilea as ma
         >>> from marsilea.plotter import ColorMesh
-        >>> _, ax = plt.subplots(figsize=(5, .5))
+        >>> _, ax = plt.subplots(figsize=(5, 0.5))
         >>> ColorMesh(np.arange(10), cmap="Blues").render(ax)
 
     .. plot::
@@ -111,13 +111,13 @@ class ColorMesh(MeshBase):
 
         >>> data = np.random.randn(10, 8)
         >>> h = ma.Heatmap(data)
-        >>> h.hsplit(cut=[5])
+        >>> h.cut_rows(cut=[5])
         >>> h.add_dendrogram("left")
         >>> cmap1, cmap2 = "Purples", "Greens"
-        >>> colors1 = ColorMesh(np.arange(10)+1, cmap=cmap1, label=cmap1, annot=True)
-        >>> colors2 = ColorMesh(np.arange(10)+1, cmap=cmap2, label=cmap2)
-        >>> h.add_right(colors1, size=.2, pad=.05)
-        >>> h.add_right(colors2, size=.2, pad=.05)
+        >>> colors1 = ColorMesh(np.arange(10) + 1, cmap=cmap1, label=cmap1, annot=True)
+        >>> colors2 = ColorMesh(np.arange(10) + 1, cmap=cmap2, label=cmap2)
+        >>> h.add_right(colors1, size=0.2, pad=0.05)
+        >>> h.add_right(colors2, size=0.2, pad=0.05)
         >>> h.render()
 
 
@@ -280,7 +280,7 @@ class Colors(MeshBase):
 
         >>> import marsilea as ma
         >>> from marsilea.plotter import Colors
-        >>> _, ax = plt.subplots(figsize=(5, .5))
+        >>> _, ax = plt.subplots(figsize=(5, 0.5))
         >>> data = np.random.choice(["A", "B", "C"], 10)
         >>> Colors(data).render(ax)
 
@@ -288,10 +288,10 @@ class Colors(MeshBase):
         :context: close-figs
 
         >>> h = ma.Heatmap(np.random.randn(10, 8))
-        >>> h.hsplit(cut=[5])
+        >>> h.cut_rows(cut=[5])
         >>> h.add_dendrogram("left")
         >>> color = Colors(data, label="Colors")
-        >>> h.add_right(color, size=.2, pad=.05)
+        >>> h.add_right(color, size=0.2, pad=0.05)
         >>> h.render()
 
 
@@ -467,7 +467,7 @@ class SizedMesh(MeshBase):
 
         >>> import marsilea as ma
         >>> from marsilea.plotter import SizedMesh
-        >>> _, ax = plt.subplots(figsize=(5, .5))
+        >>> _, ax = plt.subplots(figsize=(5, 0.5))
         >>> size, color = np.random.rand(1, 10), np.random.rand(1, 10)
         >>> SizedMesh(size, color).render(ax)
 
@@ -475,10 +475,10 @@ class SizedMesh(MeshBase):
         :context: close-figs
 
         >>> h = ma.Heatmap(np.random.randn(10, 8))
-        >>> h.hsplit(cut=[5])
+        >>> h.cut_rows(cut=[5])
         >>> h.add_dendrogram("left")
         >>> mesh = SizedMesh(size, color, marker="*", label="SizedMesh")
-        >>> h.add_right(mesh, size=.2, pad=.05)
+        >>> h.add_right(mesh, size=0.2, pad=0.05)
         >>> h.render()
 
 
@@ -668,6 +668,8 @@ class MarkerMesh(MeshBase):
         See :mod:`matplotlib.markers`
     size : int
         The of marker in fontsize unit
+    frameon : bool
+        Whether to draw the border of the plot
     label : str
         The label of the plot, only show when added to the side plot
     label_loc : {'top', 'bottom', 'left', 'right'}
@@ -698,6 +700,7 @@ class MarkerMesh(MeshBase):
         color="black",
         marker="*",
         size=35,
+        frameon=False,
         label=None,
         label_loc=None,
         label_props=None,
@@ -706,9 +709,10 @@ class MarkerMesh(MeshBase):
         self.set_data(np.asarray(data))
         self.color = color
         self.marker = marker
+        self.marker_size = size
+        self.frameon = frameon
         self.set_label(label, label_loc, label_props)
         self.kwargs = kwargs
-        self.marker_size = size
 
     def get_legends(self):
         return CatLegend(
@@ -737,6 +741,8 @@ class MarkerMesh(MeshBase):
         ax.set_xlim(0, xticks[-1] + 0.5)
         ax.set_ylim(0, yticks[-1] + 0.5)
         ax.invert_yaxis()
+        if not self.frameon:
+            ax.set_axis_off()
 
 
 class TextMesh(MeshBase):
@@ -748,6 +754,8 @@ class TextMesh(MeshBase):
         The text to draw
     color : color
         The color of the text
+    frameon : bool
+        Whether to draw the border of the plot
     label : str
         The label of the plot, only show when added to the side plot
     label_loc : {'top', 'bottom', 'left', 'right'}
@@ -765,6 +773,7 @@ class TextMesh(MeshBase):
         self,
         texts,
         color="black",
+        frameon=False,
         label=None,
         label_loc=None,
         label_props=None,
@@ -772,6 +781,7 @@ class TextMesh(MeshBase):
     ):
         self.set_data(self.data_validator(texts))
         self.color = color
+        self.frameon = frameon
         self.set_label(label, label_loc, label_props)
         self.kwargs = kwargs
 
@@ -797,3 +807,5 @@ class TextMesh(MeshBase):
         ax.set_xlim(0, xticks[-1] + 0.5)
         ax.set_ylim(0, yticks[-1] + 0.5)
         ax.invert_yaxis()
+        if not self.frameon:
+            ax.set_axis_off()