lets-plot 4.5.0__cp313-cp313-macosx_10_15_x86_64.whl

lets_plot/bistro/_plot2d_common.py

@@ -0,0 +1,93 @@
+#
+#  Copyright (c) 2023. JetBrains s.r.o.
+#  Use of this source code is governed by the MIT license that can be found in the LICENSE file.
+#
+from ..plot.core import DummySpec, aes
+from ..plot.geom import *
+from ..plot.marginal_layer import ggmarginal
+
+_BINS_DEF = 30
+_COLOR_DEF = "pen"
+
+_MARGINAL_ALPHA = .1
+
+
+def _get_bin_params_2d(xs, ys, binwidth, bins):
+    if isinstance(bins, int):
+        bins = [bins, bins]
+    if isinstance(binwidth, int) or isinstance(binwidth, float):
+        binwidth = [binwidth, binwidth]
+    if binwidth is not None or bins is not None or len(xs) == 0:
+        return binwidth, bins
+    binwidth_x = (max(xs) - min(xs)) / _BINS_DEF
+    binwidth_y = (max(ys) - min(ys)) / _BINS_DEF
+    binwidth_max = max(binwidth_x, binwidth_y)
+
+    return [binwidth_max, binwidth_max], bins
+
+
+def _get_geom2d_layer(geom_kind, binwidth2d, bins2d, color, color_by, size, alpha, show_legend):
+    if geom_kind == 'point':
+        return geom_point(color=color, size=size, alpha=alpha, show_legend=show_legend)
+    if geom_kind == 'tile':
+        return geom_bin2d(
+            aes(fill=('..count..' if color_by is None else color_by)),
+            bins=bins2d, binwidth=binwidth2d,
+            color=color, size=size, alpha=alpha,
+            show_legend=show_legend
+        )
+    if geom_kind == 'density2d':
+        return geom_density2d(
+            aes(color=('..group..' if color_by is None else color_by)),
+            color=color, size=size, alpha=alpha,
+            show_legend=show_legend
+        )
+    if geom_kind == 'density2df':
+        return geom_density2df(
+            aes(fill=('..group..' if color_by is None else color_by)),
+            color=color, size=size, alpha=alpha,
+            show_legend=show_legend
+        )
+    if geom_kind == 'none':
+        return None
+    raise Exception("Unknown geom '{0}'".format(geom_kind))
+
+
+def _get_marginal_layers(marginal, binwidth2d, bins2d, color, color_by, show_legend):
+    marginal_color = None if color_by is not None else (color or _COLOR_DEF)
+
+    def bin_param_to_1d(param2d, side):
+        if param2d is None:
+            return None
+        else:
+            if side in ['t', 'b']:
+                return param2d[0]
+            else:
+                return param2d[1]
+
+    def _get_marginal_layer(geom_kind, side, size):
+        if geom_kind in ['dens', 'density']:
+            layer = geom_area(stat='density', position='identity', color=marginal_color, fill=marginal_color,
+                              alpha=_MARGINAL_ALPHA, show_legend=show_legend)
+        elif geom_kind in ['hist', 'histogram']:
+            binwidth = bin_param_to_1d(binwidth2d, side)
+            bins = bin_param_to_1d(bins2d, side)
+            layer = geom_histogram(bins=bins, binwidth=binwidth,
+                                   color=marginal_color, fill=marginal_color, alpha=_MARGINAL_ALPHA,
+                                   show_legend=show_legend)
+        elif geom_kind in ['box', 'boxplot']:
+            layer = geom_boxplot(color=marginal_color, fill=marginal_color, alpha=_MARGINAL_ALPHA, show_legend=show_legend)
+        else:
+            raise Exception("Unknown geom '{0}'".format(geom_kind))
+
+        return ggmarginal(side, size=size, layer=layer)
+
+    result = DummySpec()
+    for layer_description in filter(bool, marginal.split(",")):
+        params = layer_description.strip().split(":")
+        geom_kind, sides = params[0].strip(), params[1].strip()
+        size = float(params[2].strip()) if len(params) > 2 else None
+        for side in sides:
+            result += _get_marginal_layer(geom_kind, side, size)
+
+    return result

lets_plot/bistro/corr.py

@@ -0,0 +1,447 @@
+#  Copyright (c) 2020. JetBrains s.r.o.
+#  Use of this source code is governed by the MIT license that can be found in the LICENSE file.
+#
+
+"""Correlation matrix implementation module"""
+from typing import Any
+
+from lets_plot.plot.util import is_pandas_data_frame
+
+try:
+    import numpy
+except ImportError:
+    numpy = None
+
+try:
+    import pandas
+except ImportError:
+    pandas = None
+
+from lets_plot.plot.core import PlotSpec
+
+__all__ = ['corr_plot']
+
+
+def _is_corr_matrix(data: Any):
+    if is_pandas_data_frame(data):
+        if data.shape[0] != data.shape[1]:
+            return False
+
+        if not (all(col_type == 'float64' for col_type in data.dtypes)):
+            return False
+
+        for column in data:
+            import math
+            if not all(math.isnan(v) or (1.0 >= v >= -1.0) for v in data[column]):
+                return False
+
+        return True
+
+    elif isinstance(data, dict):
+        m = len(data.keys())
+        for column in data.values():
+            if not isinstance(column, (list, tuple)):
+                return False
+
+            if len(column) != m:
+                return False
+
+            import math
+            for v in column:
+                if not isinstance(v, float):
+                    return False
+
+                if math.isnan(v):
+                    return True
+
+                if 1.0 >= v >= -1.0:
+                    return True
+
+                return False
+
+            return True
+    else:
+        return False
+
+
+class corr_plot:
+    """
+    This class is intended to build correlation matrix plot.
+
+    Notes
+    -----
+    To hide axis tooltips, set 'blank' or the result of `element_blank()`
+    to the `axis_tooltip`, `axis_tooltip_x` or `axis_tooltip_y` parameter of the `theme()`.
+
+    Examples
+    --------
+    .. jupyter-execute::
+        :linenos:
+        :emphasize-lines: 7
+
+        import numpy as np
+        from lets_plot import *
+        from lets_plot.bistro.corr import *
+        LetsPlot.setup_html()
+        np.random.seed(42)
+        data = {var: np.random.poisson(size=10) for var in 'abcdef'}
+        corr_plot(data).tiles().build()
+
+    |
+
+    .. jupyter-execute::
+        :linenos:
+        :emphasize-lines: 7-9
+
+        import numpy as np
+        from lets_plot import *
+        from lets_plot.bistro.corr import *
+        LetsPlot.setup_html()
+        np.random.seed(42)
+        data = {var: np.random.uniform(size=10) for var in 'abcd'}
+        corr_plot(data).tiles(type='upper', diag=True)\\
+            .labels(type='upper', diag=True, map_size=True, color='black')\\
+            .palette_RdBu().build()
+
+    |
+
+    .. jupyter-execute::
+        :linenos:
+        :emphasize-lines: 7-9
+
+        import numpy as np
+        from lets_plot import *
+        from lets_plot.bistro.corr import *
+        LetsPlot.setup_html()
+        np.random.seed(42)
+        data = {var: np.random.normal(size=10) for var in 'abcdef'}
+        corr_plot(data, flip=False, threshold=.4).points().labels()\\
+            .palette_gradient(low='#d73027', mid='#ffffbf', high='#1a9850')\\
+            .build()
+
+    """
+
+    def _duplicate(self):
+        dup = corr_plot(
+            data=self._data,
+            show_legend=self._show_legend,
+            flip=self._reverse_y,
+            threshold=self.threshold
+        )
+
+        dup._color_scale = self._color_scale
+        dup._fill_scale = self._fill_scale
+        dup._points_params = self._points_params
+        dup._tiles_params = self._tiles_params
+        dup._labels_params = self._labels_params
+        dup._labels_map_size = self._labels_map_size
+        dup._palette = self._palette
+        dup._low = self._low
+        dup._mid = self._mid
+        dup._high = self._high
+
+        return dup
+
+    def __init__(self, data, show_legend=True, flip=True, threshold=None):
+        """
+        Parameters
+        ----------
+        data : dict or Pandas or Polars `DataFrame`
+            Correlation matrix or data (correlation will be calculated for each variable pair).
+            Data will be recognized as correlation matrix if it has a square shape and all values are
+            in range -1.0..+1.0 or NaN.
+        show_legend : bool, default=True
+            If True legend is shown.
+        flip : bool, default=True
+            If True the y axis is flipped.
+        threshold : float, default=0.0
+            Minimal correlation abs value to be included in result.
+            Accept values between 0 and 1.
+
+        """
+
+        self._data = data
+        self._show_legend = show_legend
+        self._reverse_y = flip if flip else False
+        self.threshold = threshold
+        self._color_scale = None
+        self._fill_scale = None
+        self._points_params = None
+        self._tiles_params = None
+        self._labels_params = None
+        self._labels_map_size = None
+        self._palette = None
+        self._low = None
+        self._mid = None
+        self._high = None
+
+    def points(self, type=None, diag=None):
+        """
+        Method defines correlation matrix layer drawn by points to the plot.
+
+        Parameters
+        ----------
+        type : {'upper', 'lower', 'full'}
+            Type of matrix. Default - contextual.
+        diag : bool
+            Determines whether to fill the main diagonal with values or not.
+            Default - contextual.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_points(type, diag)
+
+    def labels(self, type=None, diag=None, map_size=None, color=None):
+        """
+        Method defines correlation matrix layer drawn with geom_text to the plot.
+
+        Parameters
+        ----------
+        type : {'upper', 'lower', 'full'}
+            Type of matrix. Default - contextual.
+        diag : bool
+            Determines whether to fill the main diagonal with values or not.
+            Default - contextual.
+        map_size : bool
+            If True, then absolute value of correlation is mapped to text size.
+            If False - the text size is constant. Default - contextual.
+        color : str
+            Set text color.
+            For more info see `Color and Fill <https://lets-plot.org/python/pages/aesthetics.html#color-and-fill>`__.
+            Default - contextual.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_labels(type, diag, map_size, color)
+
+    def tiles(self, type=None, diag=None):
+        """
+        Method defines correlation matrix layer drawn as square tiles to the plot.
+
+        Parameters
+        ----------
+        type : {'upper', 'lower', 'full'}
+            Type of matrix. Default - contextual.
+        diag : bool
+            Determines whether to fill the main diagonal with values or not.
+            Default - contextual.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_tiles(type, diag)
+
+    def palette_gradient(self, low, mid, high):
+        """
+        Set `scale_color_gradient2()` and `scale_fill_gradient()` for corr plot.
+
+        Parameters
+        ----------
+        low : str
+            Color for low end of gradient (correlation -1).
+        mid : str
+            Color for mid point (correlation 0).
+        high : str
+            Color for high end of gradient (correlation 1).
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_gradient_palette(low, mid, high)
+
+    def palette_BrBG(self):
+        """
+        Set `scale_color_brewer()` with BrBG palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._set_brewer_palette('BrBG')
+
+    def palette_PiYG(self):
+        """
+        Set `scale_color_brewer()` with PiYG palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_brewer_palette('PiYG')
+
+    def palette_PRGn(self):
+        """
+        Set `scale_color_brewer()` with PRGn palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_brewer_palette('PRGn')
+
+    def palette_PuOr(self):
+        """
+        Set `scale_color_brewer()` with PuOr palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_brewer_palette('PuOr')
+
+    def palette_RdBu(self):
+        """
+        Set `scale_color_brewer()` with RdBu palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_brewer_palette('RdBu')
+
+    def palette_RdGy(self):
+        """
+        Set `scale_color_brewer()` with RdGy palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_brewer_palette('RdGy')
+
+    def palette_RdYlBu(self):
+        """
+        Set `scale_color_brewer()` with RdYlBu palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_brewer_palette('RdYlBu')
+
+    def palette_RdYlGn(self):
+        """
+        Set `scale_color_brewer()` with RdYlGn palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_brewer_palette('RdYlGn')
+
+    def palette_Spectral(self):
+        """
+        Set `scale_color_brewer()` with Spectral palette for corr plot.
+
+        Returns
+        -------
+        `corr_plot`
+            Correlation plot specification.
+        """
+        return self._duplicate()._set_brewer_palette('Spectral')
+
+    def _set_points(self, type=None, diag=None):
+        self._points_params = {'type': type, 'diag': diag, 'threshold': self.threshold}
+        return self
+
+    def _set_labels(self, type=None, diag=None, map_size=None, color=None):
+        self._labels_params = {'type': type, 'diag': diag, 'color': color, 'threshold': self.threshold}
+        self._labels_map_size = map_size
+        return self
+
+    def _set_tiles(self, type=None, diag=None):
+        self._tiles_params = {'type': type, 'diag': diag, 'threshold': self.threshold}
+        return self
+
+    def _set_gradient_palette(self, low, mid, high):
+        self._palette = 'gradient'
+        self._low = low
+        self._mid = mid
+        self._high = high
+        return self
+
+    def _set_brewer_palette(self, palette):
+        self._palette = palette
+        self._low = None
+        self._mid = None
+        self._high = None
+        return self
+
+    def build(self) -> PlotSpec:
+        """
+        This method creates PlotSpec object.
+
+        Returns
+        -------
+        `PlotSpec`
+            Plot specification.
+        """
+
+        if self._points_params is not None:
+            point_params = {
+                'type': self._points_params['type'],
+                'diag': self._points_params['diag']
+            }
+        else:
+            point_params = None
+
+        if self._labels_params is not None:
+            label_params = {
+                'type': self._labels_params['type'],
+                'diag': self._labels_params['diag'],
+                'color': self._labels_params['color'],
+                'map_size': self._labels_map_size
+            }
+        else:
+            label_params = None
+
+        if self._tiles_params is not None:
+            tile_params = {
+                'type': self._tiles_params['type'],
+                'diag': self._tiles_params['diag']
+            }
+        else:
+            tile_params = None
+
+        data = self._data
+        if _is_corr_matrix(data):
+            coefficients = True
+        else:
+            if is_pandas_data_frame(data):
+                data = data.corr(numeric_only=True)
+                coefficients = True
+            else:
+                coefficients = False
+
+        return PlotSpec(data=data, mapping=None, scales=[], layers=[], bistro={
+            'name': 'corr',
+            'coefficients': coefficients,
+            'show_legend': self._show_legend,
+            'flip': self._reverse_y,
+            'threshold': self.threshold,
+            'palette': self._palette,
+            'low': self._low,
+            'mid': self._mid,
+            'high': self._high,
+            'point_params': point_params,
+            'tile_params': tile_params,
+            'label_params': label_params
+        })

lets_plot/bistro/im.py

@@ -0,0 +1,165 @@
+#
+# Copyright (c) 2019. JetBrains s.r.o.
+# Use of this source code is governed by the MIT license that can be found in the LICENSE file.
+#
+from typing import Any
+
+from lets_plot._type_utils import is_ndarray
+from lets_plot.plot.geom_imshow_ import geom_imshow
+from lets_plot.plot.plot import ggplot, GGBunch
+from lets_plot.plot.scale_position import scale_x_continuous, scale_y_continuous
+from lets_plot.plot.theme_ import theme
+
+__all__ = ['image_matrix']
+
+
+def image_matrix(image_data_array, cmap=None, *, norm=None, vmin=None, vmax=None, scale=1) -> GGBunch:
+    """
+    Display a set of images in a grid.
+    Dimensions of the grid are determined by the shape of the input Numpy 2D array.
+
+    Each element of the input 2D array is an 2D or 3D Numpy array itself
+    specifying either a grayscale image (2D array) or a color RGB(A) image (3D array).
+    For more information on image arrays please see the documentation of geom_imshow() function.
+
+    Parameters
+    ----------
+    image_data_array : `ndarray`
+        2D `numpy.ndarray` containing images.
+    cmap : str, optional
+        Name of colormap. For example "viridis", "magma", "plasma", "inferno", or any other colormap
+        which is supported by the Palettable package (https://github.com/jiffyclub/palettable)
+        This parameter is ignored for RGB(A) images.
+    norm : bool, optional, default=True
+        True - luminance values in grey-scale image will be scaled to [0-255] range using a linear scaler.
+        False - disables scaling of luminance values in grey-scale image.
+        This parameter is ignored for RGB(A) images.
+    vmin, vmax : number, optional
+        Define the data range used for luminance normalization in grey-scale images.
+        This parameter is ignored for RGB(A) images or if parameter `norm=False`.
+    scale : float, default=1.0
+        Specify the image size magnification factor.
+
+    Returns
+    -------
+    `GGBunch`
+        Plot bunch object.
+
+    Examples
+    --------
+    .. jupyter-execute::
+        :linenos:
+        :emphasize-lines: 9
+
+        import numpy as np
+        from lets_plot import *
+        from lets_plot.bistro.im import *
+        LetsPlot.setup_html()
+        np.random.seed(42)
+        image = np.random.randint(256, size=(64, 64, 3))
+        matrix = np.empty((2, 3), dtype=object)
+        matrix.fill(image)
+        image_matrix(matrix)
+
+    |
+
+    .. jupyter-execute::
+        :linenos:
+        :emphasize-lines: 12
+
+        import numpy as np
+        from lets_plot import *
+        from lets_plot.bistro.im import *
+        LetsPlot.setup_html()
+        rows, cols = 3, 3
+        matrix = np.empty((rows, cols), dtype=object)
+        for r in range(rows):
+            for c in range(cols):
+                w, h = 32 + 16 * c, 32 + 16 * r
+                matrix[r][c] = 256 * np.linspace(np.linspace(0, .5, w), \\
+                                                 np.linspace(.5, .5, w), h)
+        image_matrix(matrix, norm=False, scale=1.5)
+
+    """
+
+    if not is_ndarray(image_data_array):
+        raise Exception("Invalid image_data_array: 2d ndarray is expacted but was {}".format(type(image_data_array)))
+
+    if image_data_array.ndim != 2:
+        raise Exception("Invalid image_data_array: 2-dimentional ndarray is expacted but was {}-dimentional".format(
+            image_data_array.ndim))
+
+    rows, cols = image_data_array.shape
+    if cols * rows <= 0:
+        return
+
+    w_max = 0
+    h_max = 0
+    for row in range(rows):
+        for col in range(cols):
+            image_data = image_data_array[row][col]
+            if image_data is None:
+                continue
+
+            _assert_image_data(image_data)
+            h, w = image_data.shape[0:2]
+            h, w = _expand_h_w(h, w, scale)
+            w_max = max(w_max, w)
+            h_max = max(h_max, h)
+
+    # no gaps between image and plot edges
+    options = scale_x_continuous(expand=[0, 0])
+    options += scale_y_continuous(expand=[0, 0])
+
+    # show no axis
+    options += theme(axis_line='blank', axis_title='blank', axis_ticks='blank', axis_text='blank')
+
+    ggbunch = GGBunch()
+
+    for row in range(rows):
+        for col in range(cols):
+            image_data = image_data_array[row][col]
+            if image_data is None:
+                continue
+
+            h, w = image_data.shape[0:2]
+            h, w = _expand_h_w(h, w, scale)
+            p = ggplot() + geom_imshow(
+                image_data=image_data,
+                cmap=cmap,
+                norm=norm,
+                vmin=vmin,
+                vmax=vmax,
+                show_legend=False
+            )
+            p += options
+            ggbunch.add_plot(p, col * w_max, row * h_max, w, h)
+
+    return ggbunch
+
+
+def _assert_image_data(image_data: Any) -> None:
+    try:
+        import numpy as np
+        if not isinstance(image_data, np.ndarray):
+            raise Exception("Invalid image_data: ndarray is expacted but was {}".format(type(image_data)))
+
+        if image_data.ndim not in (2, 3):
+            raise Exception(
+                "Invalid image_data: 2d or 3d array is expacted but was {}-dimentional".format(image_data.ndim))
+    except ImportError:
+        pass
+
+
+def _expand_h_w(h, w, scale):
+    if scale:
+        h *= scale
+        w *= scale
+
+    # Mininum plot geom area size: 50 x 50
+    h = 50 if h < 50 else h
+    w = 50 if w < 50 else w
+
+    # Currently plot has not customizable 10px padding on the right and the bottom
+    # return h + 10, w + 10
+    return h, w