5

In this following code, I only see, an image is read and written again. But how do the image pixel values get changed so drastically? Apparently, converting the PIL image object to numpy array causes this but don't know why. I have read the doc for PIL images but didn't see any reasonable explanation for this to happen.

import numpy as np
from PIL import Image


def _remove_colormap(filename):
  return np.array(Image.open(filename))


def _save_annotation(annotation, filename):
  pil_image = Image.fromarray(annotation.astype(dtype=np.uint8))
  pil_image.save(filename)


def main():
  raw_annotation = _remove_colormap('2007_000032.png')
  _save_annotation(raw_annotation, '2007_000032_output.png')


if __name__ == '__main__':
  main()

Input image is,

Input image

Here is the output,

Output image

Note: The value at the red area in the input image is [128,0,0] and in the output image it's [1,1,1].

The actual source of the code is here.

Edit: As @taras made it clear in his comment,

Basically, palette is a list of 3 * 256 values in form 256 red values, 256 green values and 256 blue values. Your pil_image is an array of greyscale pixels each taking a single value in 0..255 range. When using 'P' mode the pixel value k is mapped to a color (pallette[k], palette[256 + k], palette[2*256 + k]). When using 'L' mode the color is simply k or (k, k, k) in RGB

The segmentation image annotations use a unique color for each object type. So we don't need the actual color palette for the visualization, we get rid of the unnecessary color palette.

Sumsuddin Shojib
  • 3,583
  • 3
  • 26
  • 45
  • It has something to do with 'P' (8-bit pixels, mapped to any other mode using a color palette) mode. When you write your output image this information is lost and you get greyscale image instead. – taras Aug 06 '18 at 08:17
  • 1
    I have explained it quite thoroughly here... https://stackoverflow.com/a/51677796/2836621 – Mark Setchell Aug 06 '18 at 08:20
  • Possible duplicate of [Python: Use PIL to load png file gives strange results](https://stackoverflow.com/questions/51676447/python-use-pil-to-load-png-file-gives-strange-results) – Alistair Carscadden Aug 06 '18 at 08:47

2 Answers2

3

A quick check of the opened image mode with

Image.open(filename).mode

shows the input file is opened with 'P' mode which stands for

8-bit pixels, mapped to any other mode using a color palette

So, when you generate image with Image.fromarray the palette is simply lost and you are left with a greyscale image in 'L' mode.

You simply need to provide the palette info when creating the output array.

The palette can be extracted with Image.getpalette(): 

def _remove_colormap(filename):
    img = Image.open(filename)
    palette = img.getpalette()
    return np.array(img), palette

Once you created your pil_image you can set the palette back with Image.putpalette(palette) 

def _save_annotation(annotation, palette, filename):
    pil_image = Image.fromarray(annotation.astype(dtype=np.uint8))
    pil_image.putpalette(palette)
    pil_image.save(filename)

And your main changed accordingly: 

def main():
    raw_annotation, palette = _remove_colormap('SqSbn.png')
    _save_annotation(raw_annotation, palette, '2007_000032_output.png')

Edit:

palette is a list of 3 * 256 values in the following form:
256 red values, 256 green values and 256 blue values.

pil_image is an array of greyscale pixels each taking a single value in 0..255 range. When using 'P' mode the pixel value k is mapped to an RGB color (pallette[k], palette[256 + k], palette[2*256 + k]). When using 'L' mode the color is simply k or (k, k, k) in RGB.

taras
  • 6,566
  • 10
  • 39
  • 50
  • Thanks for your answer. But as I don't want to change the code. I just want to know how the values are changed here. Does it follow any defined rule to convert the palette? I mean how [128,0,0] turns into [1,1,1] – Sumsuddin Shojib Aug 06 '18 at 09:51
  • Basically, palette is a list of 3 * 256 values in form 256 red values, 256 green values and 256 blue values. Your `pil_image` is an array of greyscale pixels each taking a single value in 0..255 range. When using `'P'` mode the pixel value `k` is mapped to a color `(pallette[k], palette[256 + k], palette[2*256 + k])`. When using `'L'` mode the color is simply `k` or `(k, k, k)` in RGB. – taras Aug 06 '18 at 10:27
  • I think in `P` mode, the pixel value `k` is mapped to color `(pallette[3*k], palette[3*k+1], palette[3*k+2])` instead of `(pallette[k], palette[256 + k], palette[2*256 + k])` Reference: https://pillow.readthedocs.io/en/5.1.x/handbook/image-file-formats.html#saving – pratsJ Nov 14 '19 at 02:11
1

Mode conversion is missing in _remove_colormap(filename). As it's defined in the question (and the answer from @taras), remove_colormap converts a PIL image into a numpy array. _save_annotation() further converts the numpy array into a PIL image. RGB image is saved as such. convert('L') should be used for converting to grayscale. Modified function definition is as under:

def _remove_colormap(filename):
    img = Image.open(filename).convert('L')
    palette = img.getpalette()
    print("palette: ", type(palette))
    return np.array(img), palette
Abhishek Saurabh
  • 119
  • 1
  • 4