Discussion :

[SmileSoft]

Salut

Je manipule dans mon application des images en niveau de gris, j�ai cod� une fonction nomm�e Niv2Gris pour transformer l�image charg�e en niveau de gris dont le but est de manipuler dans la suite des traitements une seule composante (la composante en niveau de gris que je lui associ� la variable (propri�t� dans la classe TForm1) nomm�e Gris.

Voil� le code de la fonction Niv2Gris :

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
void __fastcall TForm1::Niv2Gris(Graphics::TBitmap * Srce,TImage *ImgS, Graphics::TBitmap * Dest,TImage *ImgD)
{
we = Srce->Width;
he = Srce->Height;
P = (jRgb*)Srce->ScanLine[0];
L = (jRgb*)Srce->ScanLine[1];
ImgD->Width = ImgS->Width;
ImgD->Height = ImgS->Height;
 
for(int y = 2; y < he; y++)
    {
N = (jRgb*)Srce->ScanLine[y];
T = (jRgb*)Dest->ScanLine[y-2];
    for(int x = 0; x < we; x++)
        {
 
 Gris = (P[x].Blue + P[x].Green + P[x].Red)/3;
 
T[x].Blue = (Byte)Gris;
T[x].Green = (Byte)Gris;
T[x].Red = (Byte)Gris;
 
 }
    P = L;
    L = N;
 
    }
ImgD->Repaint();
 
 
        }
 
 
}

Au chargement de l�image j�appelle la fonction Niv2Gris:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
if(OpenPictureDialog1->Execute())
{
 
Form1->Image1->Picture->LoadFromFile(OpenPictureDialog1->FileName);
ImgS=Image1;
ImgD=Image1;
Srce = Image1->Picture->Bitmap;
Dest = Image1->Picture->Bitmap;
Niv2Gris(Srce,ImgS,Dest,ImgD);
}

Mon fichier .h contient:

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
 
public:		// Déclarations de l'utilisateur
 
int Gris, he,we ;
Graphics::TBitmap *Srce;
Graphics::TBitmap *Dest ;
TImage *ImgS;
TImage *ImgD;
 
class jRgb
{
public :
Byte Blue;
Byte Green;
Byte Red;
};
  jRgb* P;
  jRgb* N;
  jRgb* L;
  jRgb* T;

maintenant ImgD contient l'image en niveu de gris, je cherche comment acceder aux elements de ImgD (l'image en niveau de gris) par la methode ScaneLine?

Merci d'avance !

[Traxsilver]

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
public:		// Déclarations de l'utilisateur
 
int Gris, he,we ;

D'apres ce que je lis ici la variable n'est pas globale mais fait partis d'une classe, donc d�pentante de l'objet instanci�.

[henderson]

Salut !

Donc... o� sont stock�s les gris ???

Comme ici on s'obstine � utiliser un 24 bits pour du niveau de gris et bien, il suffit d'assumer... en r�cup�rant l'une des composantes dans le bitmap de destination... de la m�me mani�re qu'on l'aura fait pour le calculer mais en plus simple : soit R, G ou B (puisque R = G = B = gris)!

Par ailleurs, ton code est sans doute d�clin� d'un bout code concernant un traitement � l'aide d'une matrice (3*3)... on y trouve donc des pointeurs qui ne servent � rien, ici, pour une conversion en niveaux de gris !

Je ne suis pas s�r que la d�claration des variables en tant que propri�t�s aille dans le bon sens !

A plus !

[SmileSoft]

Salut

Merci henderson de me sauver comme d�habitude, une petite question concernant ma fonction Niv2Gris, vous avez dit:

Salut !

......Par ailleurs, ton code est sans doute d�clin� d'un bout code concernant un traitement � l'aide d'une matrice (3*3)... on y trouve donc des pointeurs qui ne servent � rien, ici, pour une conversion en niveaux de gris !

...
A plus !

Est-ce qu�il ya une possibilit� de ne pas utiliser 3 pointeurs pour parcourir l�image ?

Merci d�avance

[henderson]

Salut !

Le plus �vident est, en partant sur la base suivante :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
 
Graphics::TBitmap *Srce;
int we = Srce->Width
int he = Srce->Height
Graphics::TBitmap *Dest;
Dest->Width = we;
Dest->Height = he;

Pour la conversion entre bitmaps 24 bits :

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
 
jRgb *S;
jRgb *D;
Byte gris;
 
for(int y = 0; y < he; y++)
    {
    S = (jRgb*)Srce->ScanLine[y];
    D = (jRgb*)Dest->ScanLine[y];
    for(int x = 0; x < we; x++)
        {
        gris = (Byte)( (S[x].Blue + S[x].Green + S[x].Red) / 3 );
        D[x].Blue  = gris;
        D[x].Green = gris;
        D[x].Red   = gris;  
        }
    }

Si le source devait �tre un bitmap 8 bits on ne proc�derait pas ainsi.
Par contre dans un programme vite fait (donc mal fait � mes yeux) on trouverait une ligne du genre :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
 
Srce->PixelFormat = pf24bit;

Pour le convertir d'abord en 24 bits pour ensuite appliquer l'algo pr�c�dent de la conversion en niveaux de gris.
Ce n'est pas la bonne m�thode en terme de performances et plus pr�cis�ment en terme de temps d'ex�cution !!!

Si la distination est un 8 bits, dans ce cas l'algo est un peu plus simple :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
jRgb *S; // source en 24 bits
Byte *D; // destination en 8 bits
 
for(int y = 0; y < he; y++)
    {
    S = (jRgb*)Srce->ScanLine[y];
    D = (Byte*)Dest->ScanLine[y];
    for(int x = 0; x < we; x++)
        {
        D[x] = (Byte)( (S[x].Blue + S[x].Green + S[x].Red) / 3 );
        }
    }

Pour ce dernier cas, si ce bitmap n'est jamais affich�, alors il peut servir uniquement pour les calculs.
Par contre on risque d'avoir un sacr� probl�me lors de l'affichage (incoh�rence compl�te au niveau de l'image) si la palette de ce bitmap n'est pas en niveaux de gris.

A plus !

[SmileSoft]

Salut

je vous remercie infiniment henderson, c'est r�solu

[SmileSoft]

Salut

D'apres ce que je lis ici la variable n'est pas globale mais fait partis d'une classe, donc d�pentante de l'objet instanci�.

Peut �tre que j�ai male expliqu� en disant que Gris est une variable globale ; j�aurais pu dire que c�est un champ / propri�t� de la classe TForm1.

Donc... o� sont stock�s les gris ???

.........

Oui vous avez raison, je n�ai pas une seule variable � Gris � je dois avoir une matrice (de taille de l'image charg�e) contenant les gris.


Puisque ImgD contient l�image en niveau de Gris est ce qu�elle peut me servir (au lieu d�utiliser une matrice pour stocker les gris) ?

si c'est le cas Comment manipuler cette image par le ScaneLine??

L�id�e des 3 pointeurs �t� pour se d�plac� dans l�image : le pointeur P point sur la ligne actuelle de l�image, L sur la ligne suivante et ainsi de suite, en fait j�ai pris l�id�e de floutage ( 3*3).

Si vous avez d�autre id�e merci de me la montr�e.



Merci d'avance!

[SmileSoft]

salut

j'ai reformul� mon probl�me

Merci d'avance!

[henderson]

Salut !

ScanLine est une propri�t� de Graphics::TBitmap qui s'applique donc � tout TImage::TPicture::TBitmap et qui renvoie un pointeur sur l'une des lignes du bitmap.

Donc si le bitmap de destination des niveaux de gris est un 24bits, alors c'est le m�me sch�ma algorithmique qu'avec ta conversion.
Comme dans un 24 bits, les composantes sont �gales (R = G = B = gris), suite � cette conversion en niveau de gris, il suffit de n'en r�cup�rer qu'une seule (R, G ou B).

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
 
Graphics::TBitmap *Gris24Bits = ImageEn24Bits->Picture->Bitmap;
Byte gris;
jRgb *D;
...
D = (jRgb*)Gris24Bits->ScanLine[y];
...
gris = D[x].Blue; // ou Green ou Red puisque R = G = B

Si ton bitmap de destination des niveaux de gris �tait un 8 bits, alors dans ce cas le pointeur renvoy� par ScanLine donnerait directement les niveaux de gris.

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
 
Graphics::TBitmap *Gris8Bits = ImageEn8Bits->Picture->Bitmap;
Byte gris;
Byte *D;
...
D = (Byte*)Gris8Bits->ScanLine[y];
...
gris = D[x];

REM :
- un bitmap 24 bits m�morise ses pixels avec les 3 composantes (RGB) d'ou la classe jRgb avec ses trois Bytes.
- un bitmap 8 bits ne m�morise ses pixels que sous la forme d'un index (du type Byte) auquel correspond une couleur dans sa palette (256 teintes max).
Cette palette n'est importante que si l'on doit afficher le bitmap car dans ce cas, cette palette devient le r�f�rentiel de teintes � partir duquel tous les pixels du bitmap vont se coloriser.

A plus !