Pseudocouleurs avec OpenCV

Les fausses couleurs, ou pseudo-couleurs, sont utilisées pour rajouter une gamme de couleurs à une image en niveaux de gris.

Le processus est différent d'une recolorisation, où vous essayez de retrouver les couleurs les plus plausibles sur une vieille pellicule cinéma ou un cliché, pris lorsque seuls les systèmes noirs et blancs étaient disponibles facilement. La recolorisation est une étape mathématique complexe, alors que la pseudocolorisation est très simple : vous mettez en correspondance chaque intensité spécifique de chaque pixel de l'image d'origine avec un triplet de valeurs RGB provenant d'une échelle de couleurs fournie au préalable.

La technique est largement utilisée en photographie aérienne, en imagerie thermique et dans d'autres domaines. L'adjonction d'un nouveau canal d'information par l'utilisation de la couleur peut apporter une nouvelle lecture de l'information.

Différentes techniques sont possibles pour le choix du triplet des valeurs RGB.

Dans la suite de l'article, les exemples de code sont plus spécifiquement liés à l'utilisation d'OpenCV.
Ici, l'auteur utilise 3 sinusoides pour récupérer trois valeurs d'intensité différentes, une pour chaque canal. C'est rapide, mais ce n'est pas toujours facile de savoir à quelle couleur correspond telle ou telle intensité de blanc.

Je propose ici une mise en correspondance directe de la valeur d'intensité du pixel en niveau de gris à une couleur spécifique, choisie dans une table des couleurs. Cette table de couleurs est fournie en tant qu'image additionnelle.
L'intensité de blanc est dans l'espace [0..255] (image 8 bits), et la couleur est représentée comme un triplet classique R([0..255]),G([0..255]),B([0..255]).

Vous pouvez également utiliser les fonctions LUT d'OpenCV pour construire une table de lookup, mais je voulais essayer quelque chose de plus "manuel".

L'idée est très simple : vous tracez un gradient de couleur sur une image de 255 pixels de haut, et d'un pixel de large, qui sera notre colormap.

Sur l'image en niveaux de gris, vous prenez la valeur de chaque pixel, et vous regardez dans la colormap à la coordonnée (0,valeur_d_intensité). (En fait, vous devez faire l'opération trois fois, une pour chaque canal R,G et B).
Les 3 valeurs stockées à ces coordonnées sont celles du pixel nouvellement coloré !



J'ai élargi un peu l'image de la colormap en largeur, c'est ainsi plus facile de contrôler les couleurs. Seule la première colonne de pixels de l'image est utilisée par le code.

(Dans l'archive fournie comme exemple, la colormap est un fichier JPEG. Pour obtenir les meilleurs résultats, utilisez un format de fichier non-destructif, comme le PNG ou le BMP).

Avec OpenCV, vous pouvez utiliser cvSplit() pour obtenir trois images différentes, une par canal de couleur de l'image originale.




Vous pouvez trouver ici un exemple Visual Studio assez rapide, qui utilise OpenCV, pour coloriser une image en niveaux de gris passée en paramètre sur la ligne de commande, à l'aide d'une colormap. Vous devez également fournir le nom de la colormap. Le programme écrit l'image couleur résultant dans une image bitmap.

Sur l'exemple du babouin, vous pouvez vous rendre compte que les gris de l'image originale sont concentrés autour d'une couleur moyenne (proche de 128). Il n'y a pas beaucoup de gris très foncés ou très clairs dans l'image, l'image finale est donc principalement jaune, la couleur moyenne de la colormap. Pour obtenir de meilleurs résultats, vous pouvez effectuer quelques manipulation sur l'image d'origine (comme une équalisation de l'histogramme, pour couvrir de manière plus uniforme les couleurs du noir vers le blanc).


Voici un lien vers l'archive contenant le code, vous pouvez également parcourir le code sur GitHub.

J'ai utilisé la syntaxe C d'OpenCV. L'exemple se compile avec Visual Studio 2005 et plus récent (normalement).

(A propos, l'image de la Lune est dans le domain public, l'image du babouin provient du répertoire d'OpenCV).

OpenCV Pseudocolors

False colors, or pseudocolors, is the method you use when you want to augment grayscale pictures with predetermined colors. 

It is very different from recolorization, where you try to retrieve the plausible true colors of an old picture or movie, shot when only black & white recording systems where widely available. Recolorization is somewhat mathematically tricky, whereas pseudocoloring is very straightforward : you map every specific pixel intensity (the "whiteness" value of the pixel) of the original image to the triplet of RGB values from a given color scale.
It is widely used in aerial photography, in thermal imagery and other field where you can provide that new channel of information to literally shed a new light on the data (pun intended...).

You can use different technique to choose the triplet of RGB values.

From now, I'm going to give some code more specifically linked to OpenCV.
Here, for example, you can see the use of sine functions to retrieve three different values for each channel. It's quick, but it's not always easy to know which white intensity is going to match which color.

What I'm providing here is a straight mapping from pixel value in the grayscale range to a specific color, chosen from a color table. That color table is provided as an image.
The white intensity value is in the range 0 to 255 (8 bit depth image) and the color is represented as a classic R([0..255]),G([0..255]),B([0..255]) triplet.

You can use LUT functions in OpenCV to construct LookUp Tables, but I wanted to try something more handcrafted.

The idea is really simple : you draw a color gradient on an image of 255 pixels height, and with a width of 1 pixel, which is going to be your colormap. 

From the grayscale image, you take the value of each and every pixel, and you search in the colormap at the coordinates (0,intensity_value) (in fact, you must do that three times, one per color channel R,G and B).
The 3 values stored at those coordinates are your new colored pixel value !

I stretched a bit the width of the colormap, it's easier to visually check the colors, but only the first column of the image is really used by the code.

(In the provided example archive, the colormap is a JPEG file. For the best result, you need to use a non-destructive file format, like PNG or BMP).

In OpenCV, you use cvSplit() to get three different images as color channel from the original.

I provide a quick Visual Studio example, using OpenCV, to color a grayscale picture given on the command line to a new color mapped picture. You must also provide the name of the colormap. The program writes the produced colored image as a bitmap.

On the baboon example, you can see that since the grays in the original image are centered around a midpoint (close to 128). There isn't a lot of very dark or very bright gray in the image, so the resulting picture is mostly yellow, the middle color of the color map. It can be interesting to do some small image enhancement on the original before using the recoloring (something like Histogram Stretching, to cover more evenly the range from black to white).

Here's a link to the code archive, you can also browse the code on GitHub.
I used OpenCV's C syntax. The example can be compiled from Visual Studio 2005, and should work with more recent builds.

(And by the way, the moon picture is public domain, the baboon picture is coming from the OpenCV install directory).