[Feature] Adjust color scale gradient

[samagpt2-boop]

I have a range of values to show that ranges from 0.5 to 80 and I would like to show them without using a logaritmic scale

Is it possible to define a set of breaks for reshape the color scale? For example, using a Blue to White to Red palette, having 0,5 to 1 blue, around 1 white then get to max red at 6 and constant until 80?

Thank you

[IgorTatarnikov]

Hi @samagpt2-boop,

You can use the vmin and vmax parameters to clip the colour map at a chosen point. If you want everything greater than 6 to be a constant colour, you would pass vmax=6 when creating the heatmap. However, the scale stays centered around the midpoint between vmin and vmax (3.25 in this case).

values = dict(  # scalar values for each region
    AI=1.5,
    SS=0.5,
    MO=60,
    STR=3,
    HIP=100,
)


f = bgh.Heatmap(
    values,
    # when using a named orientation, you can pass a single value!
    position=5000,
    # 'frontal' or 'sagittal,' or 'horizontal' or a tuple (x,y,z)
    orientation="frontal",
    cmap="RdBu_r",
    vmin=0.5,
    vmax=6,
    format="2D",
).show()

To create a linear scale centred around a different centre you would normally pass a different Norm when plotting. I don't think this is exposed with how we currently generate the colours. One way around this might be to create a custom Colormap class and pass it as the cmap argument.

import matplotlib.pyplot as plt
import matplotlib.colors as mcolors
import numpy as np


class NormedColormap(mcolors.Colormap):
    """
    A Colormap that internally applies a norm, so no norm needs to be
    passed at the call site. The norm is baked into __call__.
    """
    def __init__(self, cmap, norm, name="normed"):
        super().__init__(name=name, N=256)
        self.cmap = plt.get_cmap(cmap) if isinstance(cmap, str) else cmap
        self.norm = norm

    def __call__(self, X, alpha=None, bytes=False):
        # X arrives as already-normalised [0,1] values from the 
        # internal linear norm — invert that, then apply our real norm
        vmin, vmax = self.norm.vmin, self.norm.vmax
        data = np.asarray(X) * (vmax - vmin) + vmin  # invert linear norm
        mapped = self.norm(data)                       # apply real norm
        return self.cmap(mapped, alpha=alpha, bytes=bytes)

    def reversed(self):
        return NormedColormap(self.cmap.reversed(), self.norm, name=self.name + "_r")


norm       = mcolors.TwoSlopeNorm(vmin=0.5, vcenter=1, vmax=6)
cmap_adjusted = NormedColormap("RdBu_r", norm, name="RdBu_r_twoSlope")


values = dict(  # scalar values for each region
    AI=1.5,
    SS=0.5,
    MO=60,
    STR=3,
    HIP=100,
)


f = bgh.Heatmap(
    values,
    # when using a named orientation, you can pass a single value!
    position=5000,
    # 'frontal' or 'sagittal,' or 'horizontal' or a tuple (x,y,z)
    orientation="frontal",
    cmap=cmap_adjusted,
    vmin=0.5,
    vmax=6,
    format="2D",
).show()

The above code generates:

[alessandrofelder]

As discussed in dev meeting, maybe we should aim to convert this into an advanced heatmap example file/tutorial.