Find the maximum of R,G,B in a ndarray according to their group stored in a different ndarray

Question

I'm currently working on image superpixel SLIC segmentation with the package skimage.segmentation .

My original image is 3042*4032 (12Mpx). In skimage , the array's shape is (3042,4023,3) . After the segmentation, I have around 3000 superpixels represented in a 3042*4032 array.

My goal is to find for each superpixel, the proportion of pixel which have their maximum value on the Red channel, the Blue channel and the Green channel .

I already have a function which give me the index of the maximum in the entire image:

def proportion_majoritaire_rgb_image(img):
    """ In a pixel, which channel [R,G,B] has the maximum value ?

    :param img: image (N,m) skimage rgb
    :return: (N,m) array with indexes [0,1,2]
    """

    return np.argmax(img, axis=2)

And by filtering the image on a single label, i can get the proportion of max RGB in a single label:

def proportion_majoritaire_rgb_label(img, matrice_label):
    """ 
    :param img: image (N,m) skimage rgb
    :param matrice_label: ndarray (N,m) labels SLIC
    :return: (K, 3) array of K labels and 3 proportions
    """

    indice_max_rgb = proportion_majoritaire_rgb_image(img)

    n_pixel_max_rgb = []

for k in np.unique(image_grains_ble_slic).flat:
    label_data = indice_max_rgb[matrice_label == k]
    n_pixel_max_rgb.append(np.unique(label_data, return_counts=True)[1] / np.shape(label_data)[0])

    return n_pixel_max_rgb

The issue is how to get this information for all my 3000 labels without this for loop? It takes too much time to compute, is there any other way?

The final output should be a ndarray (K,3) with K labels and for each channel RGB the proportion of pixels which have the maximum value.

Thanks in advance !

EDIT: Using np.unique(image_grains_ble_slic).flat as an iterator for the loop seems to be faster, but my goal of avoiding the for loop still stands

Answer 1

It's a little hacky because of a long-standing feature request for skimage.measure.regionprops to allow measuring multichannel images. But, we can hack it together with some repeated calls to regionprops_table , which gives us vectorised output:

from skimage import measure

index_max_rgb = np.argmax(image, axis=2)
max_index_images = [
    (index_max_rgb == i).astype(float) for i in range(3)
]
proportions_per_channel = [
    measure.regionprops_table(
        image_grains_ble_slic,
        intensity_image=intensity,
        properties=('mean_intensity',),
    )['mean_intensity']
    for intensity in max_index_images
]
proportions = np.stack(proportions, axis=1)

By the way, be sure that you use start_label=1 with SLIC because regionprops ignores the 0 label as belonging to the background.