Discussion :

[benj63]

Bonjour,

Je rencontre actuellement un problème lors de la manipulation d'images sous C++ Builder 6. Je cherche à faire le produit entre 2 images, c'est à dire la multiplication des couleurs de chacun des pixels de 2 images afin de réaliser un "fondu" entre les 2.

Jusqu'à présent, j'utilisais une méthode manuelle : le parcours de chaque pixel composant les 2 images, et la multiplication des couleurs obtenues afin d'obtenir une nouvelle couleur mélangeant les 2. Cette méthode fonctionne très bien, mais elle a un inconvénient, elle est longue si les images sont très grandes.

J'ai découvert une méthode plus aisée avec C++ Builder et la classe TGraphics::TBitmap : les masques, et l'utilisation de cmSrcAnd, qui permet de faire cette multiplication. C'est quasiment instantané. Or, il advient que certaines couleurs sont mal multipliées entre elles ! (cf images ci-dessous comparant le résultat de cmSrcAnd, en haut, et mon image, en bas)



Code utilisant cmSrcAnd :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
image1 = new TBitmap();
image1->LoadFromFile("image1.bmp");
 
sortie = new TBitmap();
sortie->LoadFromFile("image2.bmp");
source = Rect(0, 0, 100, 200);
dest = Rect(0, 0, 100, 200);
sortie->Canvas->CopyMode = cmSrcAnd;
sortie->Canvas->CopyRect(dest, image1->Canvas, source);
sortie->SaveToFile("fusion.bmp");
delete sortie;
 
delete image1;

Code perso multipliant chaque pixel :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
BYTE bR,bR1,bR2;
BYTE bG,bG1,bG2;
BYTE bB,bB1,bB2;
BYTE *ligne2, *ligne;
bool end;
 
for(y=0;y<200;++y)
{
	ligne = (BYTE *)fond->ScanLine[y-y_surfer+y_fond];
	ligne2 = (BYTE *)surfer->ScanLine[y];
	end=false;
	for(x=0;x<100;++x)
	{
		try
		{
			bR1 = ligne[3*x+2];
			bG1 = ligne[3*x+1];
			bB1 = ligne[3*x];
 
			bR2 = ligne2[3*x+2];
			bG2 = ligne2[3*x+1];
			bB2 = ligne2[3*x];
 
			bR = int((bR1*bR2)/256.);
			bG = int((bG1*bG2)/256.);
			bB = int((bB1*bB2)/256.);
			sortie->Canvas->Pixels[x][y] = (TColor)RGB(bR, bG, bB);
		}
		catch(...)
		{
			end = true;
		}
	}
}

Qu'en pensez-vous ? D'où peut prevenir le problème avec cmSrcAnd ? Y'a-t'il un moyen d'accélérer encore mon traitement des 2 images ?

En vous remerciant par avance !

[henderson]

Salut !

Dans ton code perso il faudrait également utiliser Scanline pour le bitmap de sortie au lieu de :

sortie->Canvas->Pixels[x][y]

Il me semble que cmSrcAnd n'effectue pas de multiplication mais un AND bit à bit. C'est sans doute pour cette raison que ça tourne plus vite.

A plus !

[henderson]

Salut !

Il faudrait tester si on y gagne en faisant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
class jPix
{
public :
Byte b1;
Byte b2;
Byte b3;
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void __fastcall TForm1::SpeedButton1Click(TObject *Sender)
{
Graphics::TBitmap *B1 = Image1->Picture->Bitmap; B1->PixelFormat = pf24bit;
Graphics::TBitmap *B2 = Image2->Picture->Bitmap; B2->PixelFormat = pf24bit;
Graphics::TBitmap *S  = Image3->Picture->Bitmap; S->PixelFormat  = pf24bit;
 
for(int y = 0; y < B1->Height; y++)
    {
    jPix *L1 = (jPix*)B1->ScanLine[y];
    jPix *L2 = (jPix*)B2->ScanLine[y];
    jPix *L3 = (jPix*)S->ScanLine[y];
    for(int x = 0; x < B1->Width; x++)
        {
        L3->b1 = (Byte)(L1->b1 * L2->b1 / 256);
        L3->b2 = (Byte)(L1->b2 * L2->b2 / 256);
        L3->b3 = (Byte)(L1->b3 * L2->b3 / 256);
        L1++; L2++; L3++;
        }
    }
}

A plus !