mergechannels 0.7.0

Apply and merge colormaps

mergechannels

This project was originally conceived because I often find myself wanting to apply and blend colormaps to images while working from Python, and many of my favorite colormaps are distributed as FIJI lookup tables. I also care about things like speed and memory usage, so I was interested in seeing if I could at least match matplotlib's colormapping performance with my own hand-rolled colorizer in Rust (success! mergechannels is typically several times faster than matplotlib).

The current goal of this library is to be a simple, fast, and memory-efficient way to apply and blend colormaps to images. The api should be intuitive, flexible, and simple. If this is not the case in your hands, please open an issue.

Installation

Install pre-compiled binaries from PyPI:

pip install mergechannels

Build from source on your own machine (requires Rust toolchain):

pip install git+https://github.com/zacswider/mergechannels.git

Usage

NOTE: skimage, matplotlib, and cmap are not dependencies of this project, but are used in the examples below to fetch data/colormaps, and display images.

Apply a different colormap to each channel

The primary entrypoint for merging multiple channels is with mergechannels.merge. This function expects a sequence of arrays, a sequence of colormaps, a blending approach, and optionally a sequence of pre-determined saturation limits. The arrays are expected to be either u8 or u16 and 2 or 3D.

from skimage import data
import matplotlib.pyplot as plt
import mergechannels as mc

cells, nuclei = data.cells3d().max(axis=0)

fig, axes = plt.subplots(1, 3)
for ax in axes: ax.axis('off')
a, b, c = axes
a.imshow(cells, cmap='gray')
b.imshow(nuclei, cmap='gray')
c.imshow(mc.merge([cells, nuclei], ['Orange Hot', 'Cyan Hot']))

Using external colormaps

Colormaps can be the literal name of one of the colormaps compiled into the mergechannels binary (see a list as the bottom of the page), a matplotlib colormap, or a cmap colormap. The example below creates a similar blending as above, but by explicitly passing pre-generated colormaps (one from the matplotlib library, one from the cmap library). These can also be combined with string literals.

import cmap
import matplotlib.pyplot as plt
from skimage import data
import mergechannels as mc

cells, nuclei = data.cells3d().max(axis=0)
blue = cmap.Colormap('seaborn:mako')
copper = plt.get_cmap('copper')

fig, axes = plt.subplots(1, 3)
for ax in axes: ax.axis('off')
a, b, c = axes
a.imshow(mc.apply_color_map(nuclei, blue))
b.imshow(mc.apply_color_map(cells, copper))
c.imshow(mc.merge([nuclei, cells], [blue, copper]))

Blending options

The blending argument to mergechannels.merge can be one of the following:

• 'max': the maximum RGB value of each pixel is used. This is the default (and intuitive) behavior.
• 'min': the minimum RGB value of each pixel is used. This is useful when combining inverted colormaps.
• 'mean': the mean RGB value of each pixel is used. This is typically most useful when combining fluorescence with brightfield, but can often require re-scaling the images after blending.
• 'sum': the sum of the RGB values of each pixel is used (saturating). Results in high saturation images but can often be overwhelming and difficult to interpret.

The default and intuitive behavior is the use 'max' blending, but oftentimes minimum blending is desired when combining inverted colormaps.

from skimage import data
import matplotlib.pyplot as plt
import mergechannels as mc

cells, nuclei = data.cells3d().max(axis=0)
fig, axes = plt.subplots(1, 3, dpi=200)
for ax in axes: ax.axis('off')
a, b, c = axes
a.imshow(cells, cmap='gray')
b.imshow(nuclei, cmap='gray')
c.imshow(mc.merge([cells, nuclei],['I Blue', 'I Forest'], blending='min'))

Control display brightness

If desired, pre-determined saturation limits can be passed to apply_color_map or merge to clip the images values to a range that best represents the contents of the image. These can be explicit pixel values passed with the saturation_limits argument, or as percentile values passed with the percentiles argument. If the latter, the percentile values will be used to calculate the saturation limits based on the distribution of pixel values in the images (this is sometimes referred to as "autoscaling"). The default behavior is to calculate use the 1.1th percentile value as the dark point and the 99.9th percentile as the bright point.

from skimage import data
import matplotlib.pyplot as plt
import mergechannels as mc

cells, nuclei = data.cells3d().max(axis=0)
channels = [cells, nuclei]
colormaps = ['I Blue', 'I Forest']
fig, axes = plt.subplots(1, 3, dpi=300)
for ax in axes: ax.axis('off')
(a, b, c) = axes
a.imshow(mc.merge(channels, colormaps, blending='min'))  # use the default autoscaling
b.imshow(
    mc.merge(
        channels,
        colormaps,
        blending='min',
        saturation_limits=[
            (1000, 20_000), # pre-determined dark and light points for ch1
            (1000, 50_000), # pre-determined dark and light points for ch2
        ],
    ),
)
c.imshow(
    mc.merge(
        channels,
        colormaps,
        blending='min',
        percentiles=[(
            1,  # bottom 1% of pixels set to black point
            97,  # top 3% of pixels set to white point
        )]*len(channels), # apply this to all channels
    ),
)

NOTE: if you are already working with appropriately scaled u8 images, you will see ~10X performance improvements (relative to the mergechannels and matplotlib naive default implementations) by passing saturation_limits=(0, 255) as this significantly reduces the amount of arithmetic done per pixel.

apply a colormap to a whole stack

from skimage import data
from matplotlib import pyplot as plt
import mergechannels as mc

volume = data.cells3d()
cells = volume[:, 0]
nuclei = volume[:, 1]
merged = mc.merge([cells, nuclei],['Orange Hot', 'Cyan Hot'])
plt.imshow(merged[24]); plt.show()

colorize a single image

The primary entrypoint to applying a colormap to a single image is with apply_color_map. this function takes an array, a colormap, and an optional percentiles argument. The array is expected to be either u8 or u16 and 2 or 3D.

from skimage import data
import matplotlib.pyplot as plt
import mergechannels as mc

img = data.camera()
colorized = mc.apply_color_map(img, 'Red/Green')

fig, axes = plt.subplots(1, 2)
for ax in axes: ax.axis('off')
(a, b) = axes
a.imshow(img, cmap='gray')
b.imshow(colorized)
plt.show()
print(colorized.shape, colorized.dtype)
>> (512, 512, 3) uint8

Similar to mergechannels.merge, apply_color_map will also accept colormaps directly from matplotlib and cmap, explicit saturation limits, or percentile values for autoscaling.

export colormaps to matplotlib

If you want to use mergechannels' built-in colormaps with matplotlib directly, you can export them as matplotlib.colors.ListedColormap objects using get_mpl_cmap. This requires matplotlib to be installed, which can be done with the optional dependency:

uv pip install matplotlib

or:

uv pip install "mergechannels[matplotlib]>=0.5.5"

from skimage import data
import matplotlib.pyplot as plt
import mergechannels as mc

img = data.camera()

# Get a mergechannels colormap as a matplotlib ListedColormap
cmap = mc.get_mpl_cmap('Red/Green')

# Use it directly with matplotlib
fig, axes = plt.subplots(1, 2)
for ax in axes: ax.axis('off')
(a, b) = axes
a.imshow(img, cmap='gray')
b.imshow(img, cmap=cmap)
plt.show()

You can also retrieve the raw colormap data as a numpy array using get_cmap_array:

import mergechannels as mc

# Get the raw (256, 3) uint8 array of RGB values
cmap_array = mc.get_cmap_array('betterBlue')
print(cmap_array.shape, cmap_array.dtype)
>> (256, 3) uint8

Overlay segmentation masks on top of colorized/merged channels

Both apply_color_map and merge support overlaying binary or instance masks on top of the colorized images. The examples below use apply_color_map but the arguments are identical for merge. If the boundaries_only argument is set to True, an intermediate boolean array of just the mask boundaries is created and used for the overlay. This array can also be created and returned to Python with mc.create_mask_boundaries.

from skimage import data
from skimage.filters import threshold_otsu
import matplotlib.pyplot as plt

# get an image and create some masks
_, nuclei = data.cells3d().max(axis=0)
thresh = nuclei > threshold_otsu(nuclei)
thresh = ndimage.binary_fill_holes(thresh)

# overlay the masks with mergechannels
import mergechannels as mc

fig, (a, b, c) = plt.subplots(1, 3, dpi=300)
for ax in (a, b, c): ax.axis('off')
a.imshow(mc.apply_color_map(nuclei, 'betterBlue'))  # no overlay
b.imshow(mc.apply_color_map(nuclei, 'betterBlue', masks=[thresh]))  # add mask overlay
c.imshow(mc.apply_color_map(nuclei, 'betterBlue', masks=[thresh], mask_colors=['#f00'], boundaries_only=True))  # non-default color
plt.show()

Multiple masks can be overlaid with different color or alpha-blending values.

from skimage import (
    data,
    measure,
)
from scipy import ndimage
from skimage.filters import threshold_otsu
import numpy as np
import matplotlib.pyplot as plt

# get an image and create some masks
cells, nuclei = data.cells3d().max(axis=0)
thresh = nuclei > threshold_otsu(nuclei)
labels = np.asarray(measure.label(ndimage.binary_fill_holes(thresh)))
bright_nuclei_threshold = threshold_otsu(nuclei[thresh])
label_vals = [l for l in np.unique(labels) if l!=0]

# categorize two different types of nuclei masks
def only_keep_these_labels(arr, labels):
    out = arr.copy()
    mask = np.isin(out, labels)
    out[~mask] = 0
    return out

bright_nuclei_labels = [lv for lv in label_vals if nuclei[labels == lv].mean() > bright_nuclei_threshold ]
bright_nuclei_masks = only_keep_these_labels(
    arr=labels,
    labels=bright_nuclei_labels,
)
dim_nuclei_masks = only_keep_these_labels(
    arr=labels,
    labels=[lv for lv in label_vals if lv not in bright_nuclei_labels],
)

# overlay the masks with mergechannels
import mergechannels as mc

fig, (a, b, c) = plt.subplots(1, 3, dpi=300)
for ax in (a, b, c):
    ax.axis('off')

a.imshow(bright_nuclei_masks, cmap=mc.get_mpl_cmap('glasbey'))
b.imshow(dim_nuclei_masks, cmap=mc.get_mpl_cmap('glasbey'))
c.imshow(
    mc.apply_color_map(
        arr=nuclei,
        color='Grays',  # colormap for the image
        masks=[bright_nuclei_masks, dim_nuclei_masks],  # overlay each mask array individually
        mask_colors=['betterOrange', 'betterBlue'],  # the max value of these cmaps are used
        mask_alphas=[0.8, 0.2],  # show bright nuclei in bold while dim nuclei are faded
        boundaries_only=[True, False]  # show outlines of bright nuclei, whole-masks for dim nuclei
    )
)  # add mask overlay
plt.show()

Mask color specifications accept:

• Colormap names (see an exhaustive list at the bottom of README or print mergechannels.COLORMAPS)
• Hex strings (e.g., '#FF0000')
• RGB tuples or sequences (e.g., (255, 0, 0) or [255, 0, 0])

Dependencies

Mergechannels only depends on numpy, a matrix of compatible versions is shown below. Mergechannels can also interop with matplotlib and cmap (see the Usage sections below), but these dependencies are optional for core functionality.

Python	1.25.0	1.26.0	2.0.0	2.1.0	2.2.0	2.3.0	2.4.0
3.9	✅	✅	✅	❌	❌	❌	❌
3.10	✅	✅	✅	✅	✅	❌	❌
3.11	✅	✅	✅	✅	✅	✅	✅
3.12	❌	✅	✅	✅	✅	✅	✅
3.13	❌	❌	✅	✅	✅	✅	✅
3.14	❌	❌	❌	❌	❌	❌	✅
3.14t	❌	❌	❌	❌	❌	❌	✅

Threading and Parallelism

Mergechannels is fully compatible with free-threaded Python (3.13t/3.14t). The extension declares itself thread-safe (gil_used(false)), so it won't re-enable the GIL in no-GIL builds, enabling true parallelism with Python's ThreadPoolExecutor.

By default, parallel=True uses Rayon for internal parallelization across image rows/planes. This also works well alongside Python threading.

To configure Rayon's thread count, set the RAYON_NUM_THREADS environment variable before importing mergechannels:

import os
os.environ['RAYON_NUM_THREADS'] = '4'  # Must be set before import
import mergechannels as mc

Performance

Benchmarks show that with appropriately scaled images, (i.e., if pre-determined saturation limits are passed to mc.merge or mc.apply_color_map) mergechannel is either on par or significantly faster than the underlying numpy operations used by Matplotlib. Note: you can run the benchmarks on your own machine by creating a virtual environment with the dev dependencies uv sync --dev && source .venv/bin/activate and running the benchmark code py.test --benchmark-only

Roadmap

• Add support to u8 and u16 images
• Add support for any numerical dtype
• Add option to return any colormap as a matplotlib colormap
• Add option to pass external colormaps to mergechannels
• Parallelize colormap application on large images (it is helpful!)
• Add option to overlay binary or instance masks onto colorized images
• Add support for free-threaded Python

Acknowledgements

There are other great colormapping libraries available (e.g., microfilm, cmap) that are more feature-rich than this one, but which don't address my goals. My hope is that this project can fill an un-met niche and otherwise maintain full compatibility with these and similar libraries.

This project incorporates a number of colormaps that were hand-crafted by Christophe Leterrier and James Manton which were originally distributed here and here respectively.

Colormaps

FIJI built-in LUTs

16_colors:

3-3-2 RGB:

5_ramps:

6_shades:

Blue:

Cyan:

Cyan Hot:

Fire:

Grays:

Green:

Green Fire Blue:

HiLo:

ICA:

ICA2:

ICA3:

Ice:

Magenta:

Magenta Hot:

Orange Hot:

Rainbow RGB:

Red:

Red Hot:

Red/Green:

Spectrum:

Thermal:

Yellow:

Yellow Hot:

blue_orange_icb:

brgbcmyw:

cool:

edges:

gem:

glasbey:

glasbey_inverted:

glasbey_on_dark:

glow:

mpl-inferno:

mpl-magma:

mpl-plasma:

mpl-viridis:

phase:

physics:

royal:

sepia:

smart:

thal:

thallium:

unionjack:

My custom LUTs

OIMB1:

OIMB2:

OIMB3:

betterBlue:

betterCyan:

betterGreen:

betterOrange:

betterRed:

betterYellow:

Christophe Leterrier's LUTs

3color-BMR:

3color-CGY:

3color-RMB:

3color-YGC:

BOP blue:

BOP orange:

BOP purple:

I Blue:

I Bordeaux:

I Cyan:

I Forest:

I Green:

I Magenta:

I Purple:

I Red:

I Yellow:

OPF fresh:

OPF orange:

OPF purple:

Turbo:

James Manton's LUTs

Circus Cherry:

Circus Cyan:

Circus Green:

Circus Ink Black:

Circus Ink Cherry:

Circus Ink Cyan:

Circus Ink Green:

Circus Ink Mint:

Circus Ink Purple:

Circus Ink Yellow:

Circus Mint:

Circus Purple:

Circus Yellow:

Duo Cherry:

Duo Cyan:

Duo Green:

Duo Intense Cherry:

Duo Intense Cyan:

Duo Intense Green:

Duo Intense Mint:

Duo Intense Purple:

Duo Intense Yellow:

Duo Mint:

Duo Purple:

Duo Yellow:

Grays g=0.25:

Grays g=0.25 inverted:

Grays g=0.50:

Grays g=0.50 inverted:

Grays g=0.75:

Grays g=0.75 inverted:

Grays g=1.00 inverted:

Grays g=1.25:

Grays g=1.25 inverted:

Grays g=1.50:

Grays g=1.50 inverted:

Grays g=1.75:

Grays g=1.75 inverted:

Grays g=2.00:

Grays g=2.00 inverted:

Ink Black:

Ink Cherry:

Ink Cyan:

Ink Green:

Ink Mint:

Ink Purple:

Ink Wash Black:

Ink Wash Cherry:

Ink Wash Cyan:

Ink Wash Green:

Ink Wash Mint:

Ink Wash Purple:

Ink Wash Yellow:

Ink Yellow:

Parabolic RGB:

Phase Bold Green-Magenta:

Phase Bold Ink Green-Magenta:

Phase Bold Ink Mint-Cherry:

Phase Bold Ink Yellow-Cyan:

Phase Bold Mint-Cherry:

Phase Bold Yellow-Cyan:

Phase Green-Magenta:

Phase Ink Green-Magenta:

Phase Ink Mint-Cherry:

Phase Ink Yellow-Cyan:

Phase Mint-Cherry:

Phase Yellow-Cyan:

Pop blue:

Pop blue inverted:

Pop cherry:

Pop cherry inverted:

Pop cyan:

Pop cyan inverted:

Pop green:

Pop green inverted:

Pop lavender inverted:

Pop magenta:

Pop magenta inverted:

Pop mint:

Pop mint inverted:

Pop purple:

Pop purple inverted:

Pop red:

Pop red inverted:

Pop yellow:

Pop yellow inverted:

Quartetto MYGB Blue:

Quartetto MYGB Green:

Quartetto MYGB Magenta:

Quartetto MYGB Yellow:

Quartetto RYGB Blue:

Quartetto RYGB Green:

Quartetto RYGB Red:

Quartetto RYGB Yellow: