lets-plot 4.8.1rc1__cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

lets_plot/bistro/corr.py

@@ -0,0 +1,448 @@
+#  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() <https://lets-plot.org/python/pages/api/lets_plot.element_blank.html>`__
+    to the ``axis_tooltip``, ``axis_tooltip_x`` or ``axis_tooltip_y`` parameter of the `theme() <https://lets-plot.org/python/pages/api/lets_plot.theme.html>`__.
+
+    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() <https://lets-plot.org/python/pages/api/lets_plot.scale_color_gradient2.html>`__ and
+        `scale_fill_gradient() <https://lets-plot.org/python/pages/api/lets_plot.scale_fill_gradient.html>`__ 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() <https://lets-plot.org/python/pages/api/lets_plot.scale_color_brewer.html>`__ 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() <https://lets-plot.org/python/pages/api/lets_plot.scale_color_brewer.html>`__ 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() <https://lets-plot.org/python/pages/api/lets_plot.scale_color_brewer.html>`__ 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() <https://lets-plot.org/python/pages/api/lets_plot.scale_color_brewer.html>`__ 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() <https://lets-plot.org/python/pages/api/lets_plot.scale_color_brewer.html>`__ 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() <https://lets-plot.org/python/pages/api/lets_plot.scale_color_brewer.html>`__ 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() <https://lets-plot.org/python/pages/api/lets_plot.scale_color_brewer.html>`__ 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() <https://lets-plot.org/python/pages/api/lets_plot.scale_color_brewer.html>`__ 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() <https://lets-plot.org/python/pages/api/lets_plot.scale_color_brewer.html>`__ 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,196 @@
+#
+# 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.ggbunch_ import ggbunch
+from lets_plot.plot.plot import ggplot, ggsize, GGBunch
+from lets_plot.plot.scale_position import scale_x_continuous, scale_y_continuous
+from lets_plot.plot.subplots import SupPlotsSpec
+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,
+                 spacer=1,
+                 ) -> SupPlotsSpec:
+    """
+    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.
+    spacer : number, default=1
+        Specify the number of pixels between images.
+
+    Returns
+    -------
+    ``SupPlotsSpec``
+        A specification describing the combined figure with all plots and their layout.
+
+    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])
+
+    # clear all plot decorations, reset plot margins
+    options += theme(axis='blank', panel_grid='blank')
+    options += theme(plot_inset=0, plot_margin=0, panel_inset=0)
+
+    figures = []
+    regions = []
+
+    bunch_width = cols * w_max + (cols - 1) * spacer
+    bunch_height = rows * h_max + (rows - 1) * spacer
+
+    for row in range(rows):
+        for col in range(cols):
+            figures.append(None)
+            regions.append((0, 0, 0, 0))
+
+            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
+            figures[len(figures) - 1] = p
+            regions[len(figures) - 1] = (
+                col * (w_max + spacer) / bunch_width,
+                row * (h_max + spacer) / bunch_height,
+                w / bunch_width,
+                h / bunch_height
+            )
+
+    return ggbunch(
+        plots=figures,
+        regions=regions
+    ) + ggsize(
+        bunch_width,
+        bunch_height
+    )
+
+
+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