Je sais déjà que je vais me retrouver comme avec mon post sur le goto avec des 10aines de commentaires de défenseur des principes divins du .NET, mais çà m'est égal, j'adore vous voir dans cet état :)
Je me lance, dans ce post je vais vous montrer comment manipuler le contenu d'une image en .NET de la manière la plus rapide qu'il me semble faisable de faire: l'utilisation de code unsafe (pointeurs) mais toujours dans le but de gagner en performance et non d'obscurcir le code.
En effet, il existe une méthode de traitement dans la classe Bitmap qui permet de récupérer les données de l'image en mémoire. Il s'agit de la méthode LockBits :
Rectangle bmpRect = new Rectangle(0, 0, bmp.Width, bmp.Height); // bmp est de type Bitmap
BitmapData bmpData = bmp.LockBits(bmpRect, ImageLockMode.ReadOnly, bmp.PixelFormat);
L'objet BitmapData contient les données internes de l'image et notament un pointeur vers le début des données de l'image en mémoire. La propriété Scan0 remplit ce rôle:
byte* data = (byte*)bmpData.Scan0;
Inutile de préciser qu'à partir de ce moment, nous passons en mode non managé car nous faisons un accès direct à la mémoire via data. C'est pourquoi la méthode contenant ce code doit comporter le mot clé unsafe (Le projet doit également être compilé avec l'attribut /unsafe afin d'accepter ce code, voir les propriétés du projet dans VS.NET).
Nous avons donc accès à une zone mémoire linéaire qu'il va falloir comprendre comme un tableau à deux dimensions contenant les pixels aux coordonnées x,y de notre image. Voici comment est stockée l'image en mémoire et la relation entre cette représentation et les propriétés Stride et Scan0 de la classe BitmapData:
(source: http://www.bobpowell.net/lockingbits.htm)
On utilisera donc le code suivant pour parcourir les pixels de notre image:
int
i = 0;
for (int x=0; x<bmp.Width; x++)
{
for (int y=0; y<bmp.Height; y++)
{
i = y * bmpData.Stride + x * 3;
// manipulation du pixel ;)
}
}
Il suffit donc d'indexer notre pointeur que l'on peut considérer comme un tableau afin d'obtenir les nuances rouge, vert et bleu (et alpha éventuellement) de notre pixel. Dans le cas présent mon image est enregistré en 24bpp donc les pixels se trouvent tous les x * 3 bytes.
data[i+2] // rouge
data[i+1] // vert
data[i] // bleu
Remarque: Lorsque vous créez une image avec l'instruction new Bitmap(...) sans préciser le paramètre PixelFormat, l'image est créée en 32bpp et il faut donc utiliser x * 4 pour parcourir l'image dans la formule précédente pour i (data[i+3] représente alors la nuance alpha).
Si vous souhaitez changer le contenu de data, cela est possible, il faut préciser le paramètre ImageLockMode de LockBits à ImageLockMode.ReadWrite ou ImageLockMode.WriteOnly.
Une fois que vous avez fini votre traitement, n'oubliez surtout pas d'appeler la méthode UnlockBits afin de permettre au Garbage Collector de disposer de cet espace mémoire à sa guise pour sa gestion.
bmp.UnlockBits(bmpData);
Voici la manière la plus simple en code managé pour parcourir une image:
for
(int x=0; x<bmp.Width; x++)
{
for (int y=0; y<bmp.Height; y++)
{
Color c = bmp.GetPixel(x, y);
// code de manipulation
}
}
Le problème avec cette méthode se pose lorsque l'on doit manipuler des images de grande taille. On se trouve alors à effectuer bmp.Width * bmp.Height appels à la méthode GetPixel() ce qui ralentit considérablement l'éxécution de la routine.
Une autre méthode encore consiste à parcourir les informations accessibles par Scan0 via la méthode System.Runtime.InteropServices.Marshal.ReadByte(bmpData.Scan0, i). Mais vous voyez que le problème de GetPixel se retrouve ici car pour chaque nuance il va falloir faire appel à cette méthode.
N'hésitez pas à me soumettre vos idées sur le sujet.