Class LinearSegmentedColormap

lib/matplotlib/colors.py:1079–1288

Colormap objects based on lookup tables using linear segments. The lookup table is generated using linear interpolation for each primary color, with the 0-1 domain divided into any number of segments.

class LinearSegmentedColormap(Colormap):
    """
    Colormap objects based on lookup tables using linear segments.

    The lookup table is generated using linear interpolation for each
    primary color, with the 0-1 domain divided into any number of
    segments.
    """

    def __init__(self, name, segmentdata, N=256, gamma=1.0, *,
                 bad=None, under=None, over=None):
        """
        Create colormap from linear mapping segments.

        Parameters
        ----------
        name : str
            The name of the colormap.
        segmentdata : dict
            A dictionary with keys "red", "green", "blue" for the color channels.
            Each entry should be a list of *x*, *y0*, *y1* tuples, forming rows
            in a table. Entries for alpha are optional.

            Example: suppose you want red to increase from 0 to 1 over
            the bottom half, green to do the same over the middle half,
            and blue over the top half.  Then you would use::

                {
                    'red':   [(0.0,  0.0, 0.0),
                              (0.5,  1.0, 1.0),
                              (1.0,  1.0, 1.0)],
                    'green': [(0.0,  0.0, 0.0),
                              (0.25, 0.0, 0.0),
                              (0.75, 1.0, 1.0),
                              (1.0,  1.0, 1.0)],
                    'blue':  [(0.0,  0.0, 0.0),
                              (0.5,  0.0, 0.0),
                              (1.0,  1.0, 1.0)]
                }

            Each row in the table for a given color is a sequence of
            *x*, *y0*, *y1* tuples.  In each sequence, *x* must increase
            monotonically from 0 to 1.  For any input value *z* falling
            between *x[i]* and *x[i+1]*, the output value of a given color
            will be linearly interpolated between *y1[i]* and *y0[i+1]*::

                row i:   x  y0  y1
                               /
                              /
                row i+1: x  y0  y1

            Hence, y0 in the first row and y1 in the last row are never used.

        N : int
            The number of RGB quantization levels.
        gamma : float
            Gamma correction factor for input distribution x of the mapping.
            See also https://en.wikipedia.org/wiki/Gamma_correction.