vendredi 18 juillet 2014

Concatenate images with OpenCV

Concatenate images with OpenCV

 The PDF file format has several advantages. When generating a PDF file, you have the certainty that it will be displayed the same way on every platform. On print, it's going to be the same everywhere.

Meanwhile, the PDF format isn't easily editable. The choices made by the file viewer can also be counter productive in some specific scenarios (when displaying full paged images from comics for example, the reoslution of the image has nothing to do with the resolution of the PDF and the display, meaning that you can have some pixelization occuring...)
Scientific publications in PDF (or those same comics) embed sometimes infographies, charts and pictures that you may need to reuse.

The pdfimages tool can extract JPEG images embedded inside a PDF file (doing it also for other image file format that we aren't going to use here). You can find a precompiled binary for Win32 there : http://www.foolabs.com/xpdf/download.html. You can choose to keep only the pdfimages.exe file and delete everything else. When it's saving the images, the tool doesn't 'reinterpret' them, which is important for JPEG images : there's no loss of quality when doing a new compression/decompression cycle.

The syntax to extract the files in JPEG is -j :


 pdfimages.exe -j "nom_du_fichier_pdf" 0


To keep the numerotation of the file the same as in the file, youneed to provide a prefix to the saved files. You can use what you want obviously. Here, I use '0'.

OpenCV to the rescue

Some tools split the image when embedding them inside the PDF. You can't see it onscreen but when the images are dumped from the PDF, they are extracting in several pieces.

I coded a little tool with OpenCV that takes all the images of a folder and concatenate them in logical 'pages'. OpenCV is overkill for a work like that, but by using it you can later add some effects (for example) on the images.

To read the folders and files in a multiplatform way (for a future port on Linux, for example), I use a simple header : tinydir.h (by Cong Xu and Baudoin Feildel, from here : https://github.com/cxong/tinydir).

To handle different cases of image splitting, the tool accept as a parameter the number of successive images to reassemble. Forexample, if you want to concatenate the images 5 by 5, here's the commandline :


OpenCVConcat.exe 5


By default, the tool is going to save the pictures sequentially from 000.jpg to 999.jpg (you can edit the code if you need to go over that).

For the moement, the tool works only with JPEG (with the .jpg extension). You need to add the checks for other file formats if you need to concatenate PNG or others.

The code isn't completely clean, but it's providing a good codebase to start with. For exemple, the proper way to handle memory would be to free the temporary images in RAM, handled by the vector. However the tool is fast and is only made to run for a short (it shoudln't stay in memory for too long). The memory segment allocated for the program is going to be properly freed at the end of the execution by the OS.

The code compile with OpenCV 2.4.9 and Visual Studio 2012, but it should works with any OpenCV install above 2.0+ and a fairly recent VS install (something above VS 2005). The linked libraries are declared as #pragma comment(lib,"") at the head of the main cpp file. You need to change those lines to match your installation.(This way of declaring the libraries is helpful when dealing with different version of OpenCV installed concurrently on the system...).

The code is available on GitHub : https://github.com/Pseudopode/OpenCVConcat, with an archive containing the compiled binary. The same archive is available here : https://dl.dropboxusercontent.com/u/1412774/Blog/BlogSpot/OpenCV_Concat/OpenCVConcat.1.0.7z.

Concatenation d'images avec OpenCV

Concatenation d'images avec OpenCV

pdfimages.exe


Le format PDF présente plusieurs avantages : en générant un fichier PDF vous avez la garantie qu'il sera affichée de la même manière sur toutes les plateformes. A l'impression le rendu sera identique partout.

En contrepartie, le format PDF n'est pas fait pour être édité facilement. De plus les choix d'affichages effectués par le lecteur de fichier peuvent se révéler mauvais dans certains cas (notamment lors de l'affichage d'images A4 pleine page dans le cas de bande dessinées ou de comics par exemple).
Les publications scientifiques en PDF (ou ces même comics) embarquent souvent des infographies que vous voudriez peut-être récupérer.

L'outil pdfimages permet d'extraire les images JPG embarquées dans un fichier PDF (ainsi que d'autres formats qui ne nous intéressent pas ici). Pour Win32, vous pouvez trouver l'outil précompilé là : http://www.foolabs.com/xpdf/download.html . Vous pouvez ne garder que pdfimages.exe présent dans l'archive.
Lorsqu'il enregistre les images, l'outil ne les "réinterprète" pas, ce qui est important pour les images JPEG : il n'y a pas de perte de qualité avec une nouvelle compression/décompression.

La syntaxe pour extraire les fichiers au format JPEG est -j :


 pdfimages.exe -j "nom_du_fichier_pdf" 0


Afin de garder la numérotation des images identique à celle du fichier, il faut donner un préfixe au fichiers qui seront sauvegardé. Vous pouvez utiliser ce que vous voulez, évidemment. Ici, j'utilise '0'. 

OpenCV à la rescousse 

Certains outils découpent les images lors de l'intégration des fichiers dans le fichier PDF. Cela ne se voit pas à l'écran lors de la visualisation du PDF, mais lors de la sauvegarde des images elles seront extraites en plusieurs morceaux.

J'ai programmé un petit outil avec OpenCV qui récupère toutes les images d'un dossier et les réassemble en pages logiques. OpenCV est surdimensionné pour une tâche de ce type, mais son utilisation permet d'appliquer d'éventuels traitement ultérieurs sur les images.

 Afin de pouvoir lire facilement les dossiers et les fichiers de manière multiplateforme (en prévision d'un portage éventuel sous Linux, par exemple), j'utilise un simple fichier d'en-tête, tinydir.h (par Cong Xu et Baudouin Feildel, venant d'ici https://github.com/cxong/tinydir).
 Afin de gérer plusieurs cas de découpe d'image, l'outil accepte en paramètre le nombre d'images successives à assembler. Par exemple, si vous désirer réunir les images 5 par 5, voici la ligne de commande :


OpenCVConcat.exe 5


Par défaut, l'outil va sauvegarder les images séquentiellement en partant de 000.jpg, jusqu'à 999.jpg

Pour l'instant, l'outil n'assemble que les fichiers .jpg . Il faut rajouter la vérification pour les autres formats de fichiers si vous voulez assembler des PNG ou autres.

Le code n'est pas complètement propre, mais cela donne une bonne base pour commencer. Par exemple, il faudrait pour la gestion des images temporaires en RAM désallouer proprement les images stockées dans le vecteur. Malgré tout, l'outil tournant rapidement et n'étant pas destiné à tourner en mémoire vive, le segment mémoire associé sera libéré proprement par l'OS à la fin de l'exécution.

Le code compile avec OpenCV 2.4.9 et Visual Studio 2012, mais cela devrait fonctionner avec n'importe quelle installation d'OpenCV en branche 2.0+ et un VS récent (certainement depuis VS2005). Les bibliothèques à lier par le compilateur sont déclarées en #pragma comment(lib,""), il faut changer ces lignes pour qu'elles correspondent à votre installation. (Cette manière de déclarer les librairies permet de changer facilement de version lorsque vous utilisez plusieurs version d'OpenCV en parallèle sur la même machine).

Le code est disponible sur GitHub : https://github.com/Pseudopode/OpenCVConcat, ainsi qu'une archive contenant l'exécutable et ses DLLs. Cette même archive est disponible également ici : https://dl.dropboxusercontent.com/u/1412774/Blog/BlogSpot/OpenCV_Concat/OpenCVConcat.1.0.7z.

lundi 3 décembre 2012

Pseudocolorisation en javascript

Dans le dernier billet, j'ai parlé de pseudo-colorisation. L'exemple proposé était écrit en C, avec OpenCV.
Je vais maintenant vous détailler une solution pour faire de même en javascript, dans un navigateur.

(Si l'explication est trop longue, vous pouvez aller directement à la démonstration, à la fin de ce billet).
Pour résumer :

1) charger une image dans un <canvas>
2) charger une colormap dans un <canvas>
3) appliquer l'algorithme de recolorisation (rechercher la valeur de l'image en niveaux de gris dans la colormap)



Javascript & l'objet <canvas>

En "HTML5", quoi que veuille réellement impliquer le nom aujourd'hui, si vous avez un navigateur récent (Opéra, Chrome, Firefox, Safari...), vous pouvez travailler avec un élément bien particulier : le <canvas>.
Un canvas 2D contient tous les pixels d'une image rastérisée (bitmap), tout en étant un élément d'une page web. Le bénéfice d'un <canvas> sur un <img> vient de la possibilité d'accéder à tous les pixels qui composent le canvas (l'élément <img> est lui strictement passif, il ne sert qu'à afficher une image).

A sa création, le Javascript était lent. Maintenant, les navigateurs grand public utilisent tous, sous une forme ou l'autre, différentes améliorations et accélérations (machine virtuelle de type JIT, fonctions inline, etc...). Cela permet d'effectuer des calculs uniquement possibles sur machine fixe jusque là.

Le code javascript présenté ici va implémenter l'algorithme codé avec OpenCV dans le billet précédent.

Représentation en mémoire des images couleurs


Vous avez besoin du tableau de pixels de l'image et du tableau de pixels en provenance de la colormap  (une unique colonne de 256 pixels de haut).


Ensuite, il vous suffit d'itérer sur tous les pixels de l'image d'origine, récupérer la luminosité des pixels, chercher dans la colormap le triplet R,G,B associé à cette valeur, et l'écrire au final dans le tableau d'origine (vous pouvez trouver un schéma pour illustrer ce fonctionnement dans le billet précédent : http://podeplace.blogspot.fr/2012/11/pseudocouleurs-avec-opencv.html)

Image Couleur vue par OpenCV : 3 plans de couleurs (Rouge, Vert, Bleu)
OpenCV travaille avec deux concepts d'image : couleur et niveaux de gris. Une image en niveaux de gris utilise un seul plan de couleur (l'intensité du gris), mais les images couleurs ont trois plans de couleurs (rouge, vert, bleu). Ainsi, la bibliothèque peut gérer la mémoire plus efficacement.




Image en niveaux de gris : OpenCV ne voit qu'un seul plan de couleur en mémoire

Par contre,  l'élément <canvas> ne connaît qu'un seul type d'image : 4 plans de couleurs - rouge, vert, bleu, alpha (pour la transparence).
Cela signifie que pour travailler avec. une "vraie" image en noir et blanc, nous devons stocker la valeur en niveaux de gris dans un des plans de couleurs, et la recopier dans les deux autres canaux (en laissant le canal de transparence complètement opaque).


Image en mémoire pour un <canvas> : 4 pixels de couleurs consécutifs (Rouge, Vert, Bleu, Alpha) pour chaque pixel coloré
Nous ne pouvons pas charger une image JPEG ou PNG directement dans le canvas, car nous ne savons pas vraiment quels sont les choix effectués par le logiciel qui a servi a sauvegarder ces images. On ne sait pas si le logiciel a choisi de ne stocker qu'un seul plan de couleur (en niveaux de gris) ou plusieurs plans (même pour une image noire & blanche !). De plus, certains formats de fichiers n'autorisent pas le choix du nombre de plans de couleurs lors de l'enregistrement.
Dès lors, nous devons partir d'un canvas dans lequel une image a été enregistrée, et convertir ce ces couleurs en niveaux de gris, au sein de l'objet <canvas>.

Conversion d'un canvas couleurs en niveau de gris

Mélange RGB vers Gris par simple moyenne


Le processus de conversion d'une couleur RGB peut être aussi simple que prendre la moyenne des 3 canaux de couleurs, divisée par 3. Dans ce cas, le niveau de gris obtenu n'est pas la meilleure approximation possible du gris correspondant à la couleur d'origine. L’œil humain est plus sensible au vert, et moins sensible au bleu ( ceci étant du aux fonctionnement des cellules de la rétine),. Nous pouvons alors attribuer un poids à chaque canal, de manière à ce qu'il contribue plus ou moins au. niveau de gris final.

Vous pouvez trouver en ligne plusieurs méthodes pour définir ce mélange des trois valeurs RGB. Par exemple, avec le format PAL/NTSC (utilisé par la télévision analogique), le niveau de luminance est défini comme ceci :
Mélange RGB vers Gris (plus proche de la perception humaine)

lum = 0.299 * rouge + 0.587 * vert + 0.114 * bleu

La luminance est définie dans la norme CIE 1931 comme suit :

Y = 0.2126 * rouge + 0.7152 * vert + 0.0722 * bleu


(Les  valeurs utilisées par OpenCV sont Rouge : 0.212671, Vert : 0.715160, et Bleu : 0.072169).

Comme pour d'autres exemples accessibles sur internet, j'ai utilisé les valeurs suivantes :

 luminosité = 0.34 * rouge + 0.5 * vert + 0.16 * bleu 

Tous ces modèles prennent en compte la sensibilité de l’œil humain pour le vert.

Différence entre gris obtenu par moyenne et gris obtenu par le modèle physiologique précédent.
La différence entre les valeurs de gris calculée par les deux méthodes est subtile mais suffisante pour être remarquée.

L'algorithme en javascript


Dans notre exemple, nous pouvons transformer l'image en niveaux de gris au chargement de la page, et travailler ensuite avec cette image modifiée pour lui appliquer notre colormap.

Quand vous travaillez avec un canvas cvs et son contexte associé ctx, vous pouvez récupérer un tableau d'informations spécifiques à cette image via


 var myImageData = ctx.getImageData(0, 0, cvs.width, cvs.height);
 

Cette variable contient un tableau de données , contenant les pixels de couleurs, dans l'ordre suivant : [rouge, vert, bleu, alpha, rouge, vert, bleu, alpha,...].

En javascript, pour éviter de traverser le DOM, qui est une opération lente (lors de l'accès de myImageData.data, vous pouvez détacher le tableau de pixels en tant que nouvelle variable :


 var dataSrc = myImageData.data;
 


et accéder ce qui est contenu dans dataSrc, pour un accès plus rapide.

Ce tableau étant à une dimension, vous pouvez accéder aux différents pixels du tableau avec une boucle comme celle-ci :


for(var y = 0; y < height; y++){         
    for(var x = 0; x < width; x++){
        index = (x + y * width) * 4;
        dataSrc[index+0] = ROUGE;
        dataSrc[index+1] = VERT;
        dataSrc[index+2] = BLEU;

        //dataSrc[index+3] = ALPHA;  //pas de modifications
    }
}

Ici, pas besoin de changer la valeur alpha. Le  *4  permet d'atteindre le pixel suivant en mémoire (car il faut sauter dessus des 4 valeurs RGBA).

Si vous voulez appliquer une conversion en niveaux de gris sur cette image, vous pouvez maintenant écrire la nouvelle valeur de gris dans les canaux rouge, vert et bleu, pour des raisons d'affichage (attention, l'image sera 3 fois plus lumineuse que la vraie conversion RGB->Gris, bien que ce ne soit le cas que lors de l'affichage sur un écran d'ordinateur).



Ne vous inquiétez pas, quand vous allez travailler avec ces pixels à l'étape suivante, pour appliquer la colormap, vous allez utiliser la valeur de gris d'un seul des canaux, puisque c'est la même valeur sur les 3.
Si nous avions choisi de ne stocker la valeur de gris que dans un seul canal, le rouge par exemple, l'image affichée serait seulement en teintes de rouge (et cela peut paraître un peu étrange de considérer une image intégralement en niveau de rouge, vert ou bleu comme une image "en niveaux de gris").


Ce genre d'accès aux pixels est la base de toutes les opérations et filtres sur les images en javascript (et plus généralement dans tous les langages de programmation quand on traite avec des images).

Quand toutes les modifications sont effectuées, n'oubliez pas d'écrire ces pixels à nouveau dans l'image d'origine !


 myImageData.data = dataRes; //ré-attacher la variable
 ctx.putImageData(myImageData,0,0); //l'écrire dans le canvas

Dans l'exemple fourni, nous chargeons une image JPEG classique, la transformons en niveaux de gris au clic d'un bouton, et la recolorisons quand l'utilisateur clique sur une des colormaps. Vous devez recharger la page si vous voulez utiliser une autre couleur, vous redéclencher la conversion couleurs -> niveaux de gris d'origine. Si vous ne le faites pas, vous allez appliquer différentes colormaps successives sur une image déjà modifiée, ce qui va amener une saturation colorée de l'image à la fin.

Démonstration javascript :



Lien pour le projet sur GitHub : https://github.com/Pseudopode/javascript_pseudocolors et l'archive .zip du projet.

Pseudocolorisation with Javascript

In the last post, I spoke about pseudo-colorization. That particular example was done in C, with OpenCV.
I'm going to show you now how to do the same thing in Javascript, inside a browser.

(If the explanation is too long, you can scroll down directly to the demo, at the end of this post).
To sum it up :
1) grayscale an image in a <canvas>
2) load a colormap in another <canvas>
3) apply recolor algorithm (lookup from the grayscaled image in the colormap)


Javascript & the <canvas> object

In "HTML5" (whatever the name really implies), with a recent browser (Opera, Chrome, Firefox, Safari...), you can work with a special element : the <canvas>.
A 2D canvas hold all the pixels of a raster image, as an element inside a webpage. The benefits of using a <canvas> object instead an <img> is the ability to access all the pixels of the image stored inside (the <img> is strictly passive, it can just display an image).

At the beginning, Javascript was slow. But now, you the common browsers are using some optimized JIT Javascript VM, allowing you to do some tasks previously only doable on desktop.
Image processing tasks are now possible on a (somewhat) recent computer, inside a web app.
The javascript code shwon here is going to implement the OpenCV algorithm in the previous post.

Representing color images in memory


First, you retrieve an array of all the pixels of the image, you then get a second array, the array of the pixels from the colormap (a pixel wide column of 256 pixels).


After that, it's simply a matter of iterating over all the pixels of the image, getting the luminosity level, seeking in the colormap the R,G,B triplet associated to that value, and writing it back in the array (you can find a descriptive image in the previous post : http://podeplace.blogspot.fr/2012/11/opencv-pseudocolors.html)

Color Image as seen by OpenCV : 3 colorplanes (Red, Green, Blue)
OpenCV has two different image concept : grayscale and color. A grayscale image has only one colorplane (the gray intensity), but color images have three colorplanes (one for each Red, Green & Blue). This way, the library can handle memory more efficiently.




Grayscale Image : OpenCV is using only one colorplane in memory

The pixel array of the element, however, only knows 4 colorplanes images. Red, green, blue, and Alpha (for transparency).
That means that if we want to work with a "true" grayscale image, we need to calculate the grayscale value in one colorplane and copy that colorplane over in the two other color channel (leaving the transparency channel fully opaque).


Image en mémoire pour un <canvas> : 4 pixels de couleurs consécutifs (Rouge, Vert, Bleu, Alpha) pour chaque pixel coloré
We can't load a grayscale image in JPEG or PNG inside the canvas, since we don't really know how the software, used to save that image, choose to store the grayscale value inside. We don't know if the software choose to save only one colorplane (grayscale) or several planes (even for a black & white image !). Furthermore, some file formats doesn't allow the choice for the number of colorplanes when saving files. We then need to start with a canvas on which an image has been saved, and convert those colors in grayscale, inside the <canvas> object.


Convert a color canvas to grayscale

RGB to Gray Mix, via averaging
The grayscale conversion process of an RGB color can be as simple as the mean of the 3 color channels, divided by 3. But the resulting grayscale isn't the best match for the original color. Since the human eye is the most sensitive to green, and less sensitive to blue (due to the biological innards of the retina cells), we can weight each channel to contribute more or less to the final luminosity level.

You can find online several values to define the blending of the three values. For example, in the PAL/NTSC format(used by the analog TV), the luminance channel is defined as is :

RGB to Gray mix (closer to human perception)

lum = 0.299 * red + 0.587 * green + 0.114 * blue

The CIE 1931 luminance is defined as :

Y = 0.2126 * red + 0.7152 * green + 0.0722 * blue

(The values used by OpenCV are Red : 0.212671, Green : 0.715160, and Blue : 0.072169).

As some other Javascript example over the web, I choose the following values :

 brightness = 0.34 * red + 0.5 * green + 0.16 * blue 

All those models take into account the human sensitivity for green.

Difference between the gray from averaging and gray from the previous physiological model.
The difference between the gray values calculated by the two methods is small but noticeable.

Algorithm in javascript

In our example, we can now grayscale the image at startup, and then work with that image to apply the colormap.

When working with a canvas cvs and its associated context ctx,  you can retrieve the array of specific image data via


 var myImageData = ctx.getImageData(0, 0, cvs.width, cvs.height);
 

Inside that variable, there's a data array, storing the colored pixels in the following order [red, green, blue, alpha, red, green, blue, alpha,...].

In javascript, to avoid a slow DOM traversal when accessing the myImageData.data, you can detach that pixel array as a new var


 var dataSrc = myImageData.data;
 

and access what's inside that dataSrc, for a quicker access.

Since that array is a flat 1-dimensional one, you can access the various pixel with a regular loop like that :


for(var y = 0; y < height; y++){         
    for(var x = 0; x < width; x++){
        index = (x + y * width) * 4;
        dataSrc[index+0] = ROUGE;
        dataSrc[index+1] = VERT;
        dataSrc[index+2] = BLEU;

        //dataSrc[index+3] = ALPHA;  //no modifications
    }
}

Don't change the alpha value here. The  *4  is there because to get to the next pixel in memory, you need to jump over 4 values (RGBA).

If you want to apply a grayscale conversion on that image, you can write back the new luminosity value in all the red, green and blue channel, for display purpose (however, the image is going to be three time more luminous than the true RGB->Grayscale conversion, although only on a computer display).



Don't worry, when you work with that pixel array on the next stage, to apply the colormap, you are going to use the luminosity value of only one channel, since it's the same value on all three (and that's why, although the displayed image is not the "true" grayscaled one, you are going to have the true colored image in the end).
If we choose to only store the grayscale value in one channel, the red one for example, the displayed image would be only in tint of red (and it feels a bit strange to consider a red-only, or blue-only or green-only image as "grayscale").


That kind of pixel access is the basis to all image operations and filters in Javascript (and more generally in all general purpose language when dealing with images).
After all the modifications are done, don't forget to write back those pixel in the image !


 myImageData.data = dataRes; //reattache the variable
 ctx.putImageData(myImageData,0,0); //write it back in the canvas


In the provided example, we load a regular JPEG picture, grayscale it on the click of a button, and then recolor it when the user click on one colormap. You need to reload the page if you want to use another colormap, to trigger the proper color -> grayscale conversion. If not, you are going to apply various colormap on already modified pictures, leading to some unpleasant effects in the end.

Demonstration in javascript :



Link of the project on GitHub : https://github.com/Pseudopode/javascript_pseudocolors and the .zip archive of the project.

dimanche 11 novembre 2012

Pseudocouleurs avec OpenCV

La Lune en niveaux de gris (photo)

Les fausses couleurs, ou pseudo-couleurs, sont utilisées pour rajouter une gamme de couleurs à une image en niveaux de gris.
La Lune en pseudo-couleurs, colorisée avec OpenCV

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]).




Explication du processus de recolorisation

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

Grayscale Moon

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

Pseudocolored Moon with OpenCV

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.

Recolorization process explanation


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

Colormap used by OpenCV

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.
Grayscale Baboon
(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.
Pseudocolored Baboon

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).