Pb d'affichage.erreur non comprise

Version imprimable

je developpe avec c++builder 6 et c'est que j'ai fait un code pour affiché les valeurs d'un histogramme d'une image dans un TStringGrid.pour les valeurs RGB.
chaque colonne contient les incrémentation des valeurs selon leurs nombre de 1 A 256 pour les couleurs.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 int R,G,B,NG; for(int i=0;i<256;i++) { for(int j=0;j<256;j++) { TColor col=Image1->Canvas->Pixels[i][j]; R=GetRValue(col); G=GetGValue(col); B=GetBValue(col); rgb->Cells[1][R]=IntToStr(StrToInt(rgb->Cells[1][R])+1); rgb->Cells[2][G]=IntToStr(StrToInt(rgb->Cells[1][G])+1); rgb->Cells[3][B]=IntToStr(StrToInt(rgb->Cells[1][B])+1); } }
alors le probleme est que quand je charge une image et je lui applique ce code une exception arrete le deroulement en m'affichant" la valeur de R n'est pas une valeur entiere"
et pour d'autres image elle m'affiche le meme message mais avec G ou B.sachant que pour des image satelitaire(en niveau de gris )ca marche bien mais pour d'autres coloré ou noir et blanc sa m'affiche toujour ce message.merci pour votre attention et votre aide

21/03/2008, 13h54
pottiez

Bonjour,
tout d'abord, je voudrais te faire remarqué que tu as des b au lieux de B dans la dernière ligne (peut-être une simple erreur de copie entre ton code et ici).
Je voulais également savoir sur quel ligne l'exception ce produit exactement (tu doit pouvoir le savoir avec ton déboguer), est-ce les trois première de ta boucle ou les trois dernière ?
21/03/2008, 14h35
l_seringa

Citation:

tout d'abord, je voudrais te faire remarqué que tu as des b au lieux de B dans la dernière ligne (peut-être une simple erreur de copie entre ton code et ici).

Oui comme vous aviez dit si juste une erreur lors de copie du code.

Citation:

Je voulais également savoir sur quel ligne l'exception ce produit exactement (tu doit pouvoir le savoir avec ton déboguer), est-ce les trois première de ta boucle ou les trois dernière ?

c'est au niveau des trois derniere ligne .plus exactement ctte erreur se produit entre les 2derniers accolades fermentes.car g essayer de faire un showmessage pour pouvoir detedter l'erreur c'est ou et j'ai veut que ce ShowMessage est correcte partout sauf entre les deux derniere accolades fermantes ca ne s'affiche pas.merci
21/03/2008, 15h00
pottiez

C'est bizard, je ne voie pas d'où peut venir l'erreur, pour moi le code est bon, par contre, peut tu me renseigner sur un point, les fonctions GetRValue, GetBValue, et GetGValue, elle viennent d'où, c'est des fonction de Borland ou vos propre fonction ?
21/03/2008, 15h05
l_seringa

Ce sont des fonctions de c++builder.merco vraiment pour votre aide.
et ce qui me rend dingue c que ca marche pour des images en niveaux de gris mais couleur ou noir et blanc pas du tout.j'ai trop essayer de régler le probleme avant de le poster mais rien.
21/03/2008, 15h16
pottiez

Essaye en déclarant R, G et B en BYTE plutôt qu'en int, peut-être que cela changera le comportement.
21/03/2008, 15h31
l_seringa

En déclarant R,G,B avec BYTE le meme message est affiché...merci pour votre aide.moi en mmeme temps j'essaye des trucs aussi .merci
21/03/2008, 17h50
henderson

Salut !

Tu cherches à dénombrer les composantes ?

Si c'est le cas, il vaut mieux :
- traiter avec ScanLine
- dénombrer avec un tableau
- ne remplir le TStringGrid qu'à la fin

A plus !
22/03/2008, 00h18
l_seringa

Pour le ScanLine j'en est pas pue comment procéder avec.vos pouvez me donner un aide sur ca.et pour la methode proposé part ""henderson""" je vais essayer et vous dire si ca marche ou pas.merci pour vos aide

Salut !

Chez moi ça tourne, mais par contre, je ne sais pas si ça correspond exactement à ce que tu souhaites faire.

Dans ton code, l'usage de Pixels[X][Y] est extrêment pénalisant en terme de temps d'exécution.
ScanLine permet d'accéder aux pixels directement mais dans ce cas précis on est obligé de tenir compte du PixelFormat du bitmap.
En effet, un bitmap 8 bits mémorise ses 256 teintes dans une palette (type PALETTEENTRY) et non dans les pixels.
Chaque pixel est alors mémorisé sous la forme d'un index (type Byte).
Notons quand même que pour un Bitmap 8 bit en niveau de gris, l'index peut correspondre au niveau de gris lui-même à condition que les teintes (R=G=B) soient parfaitement ordonnées dans la palette (de 0 à 255, du noir au blanc) ce qui peut ne pas être le cas !
J'ai donné du code sur ce forum en ce qui concerne les bitmaps 8 bits !

Pour un pf24bit, les composantes RGB sont directement accessibles !
J'ai rajouté une classe jRgb pour avoir une meilleure lecture lors de la récupération des composantes RGB.

Dans ton code, ne parlons pas des conversions littéral-->numérique-->littéral qui sont encore plus pénalisantes, surtout de la manière dont tu t'y prends !
Donc il vaut mieux faire ce type de conversion qu'une seule fois : lorsque l'on rempli le TStringGrid (numérique-->littéral) avec le résultat final.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 class jRgb { public : Byte Blue; Byte Green; Byte Red; }; //pour attribuer un nom au colonnes(R,G,B) du tableau : Resultat[R,G,B][Valeurs] //comme ceci ou l'aide d'un enum #define red 0 #define green 1 #define blue 2
Le tableau (en global sans doute):
Code:

1 2 int Result[3][256];
Code:

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 35 36 37 38 39 40 41 42 43 44 45 46 47 48 void __fastcall TForm1::SpeedButton1Click(TObject *Sender) { int row, col; jRgb *pRgb; Graphics::TBitmap *B = Image1->Picture->Bitmap; //RAZ du tableau for(col = 0; col < 3; col++) { for(row = 0; row < 256; row++) { Result[col][row] = 0; } } switch(B->PixelFormat) { case pf8bit : //j'ai donné du code sur ce forum pour accéder au composantes RGB //de chaque pixel d'un bitmap doté d'une palette break; case pf24bit : //Remplissage du tableau for(row = 0; row < B->Height; row++) { pRgb = (jRgb*)B->ScanLine[row]; for(col = 0; col < B->Width; col++) { Result[ red ][ pRgb->Red ]++; Result[ green ][ pRgb->Green ]++; Result[ blue ][ pRgb->Blue ]++; pRgb++; //pixel suivant } } } //Remplissage du StringGrid //J'ai utilisé une ligne et une colonne fixes for(col=1; col < 4; col++) { for(row = 1; row < 257; row++) { StringGrid1->Cells[ col ][ row ] = IntToStr(Result[ col-1 ][ row-1 ]); } } }
A plus !

22/03/2008, 12h02
l_seringa

merci pour votre aide .mon probleme je l'ai pue le regler avec vos aide.ben g procéder de la facon dont hederson me la proposé et ca merche a merveille.
je vais esseyer de traiter le ScanLine et voir..merci boucoup

salut.désolé pour le retard pour générer cette question pour Henderson.
alors pour ton code,merci il est bien compris et ca marche tres vite avec le ScanLine.
mais y'a 2problemes
1ere:c'est que quand je code avec mon code celui-la,j'obtient les meme valeurs que votre code ci-dessus mais sauf pour la valeur 255 ou c'est different(des fois une grande differences et d'autres non)
Code:

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 35 36 37 38 39 40 41 42 void TForm1::calcul_rgb() { int R,G,B,NG; int HistoR[256],HistoG[256],HistoB[256],HistoNG[256]; for(int i=0;i<256;i++) { HistoR[i]=0; HistoG[i]=0; HistoB[i]=0; HistoNG[i]=0; } for(int i=0;i<256;i++) { for(int j=0;j<256;j++) { TColor col=Image1->Canvas->Pixels[i][j]; R=GetRValue(col); G=GetGValue(col); B=GetBValue(col); HistoR[R]++; HistoG[G]++; HistoB[B]++; NG=0.299*R+0.587*G+0.114*B; HistoNG[NG]++; } } for(int i=1;i<257;i++) { rgb->Cells[1][i]=HistoR[i-1]; rgb->Cells[2][i]=HistoG[i-1]; rgb->Cells[3][i]=HistoB[i-1]; rgb->Cells[4][i]=HistoNG[i-1]; } }
2eme;j'ai cherché pour le code de pf8bits.es-ce celui la
http://www.developpez.net/forums/sho...ghlight=pf8bit
sauf que c'est pour les niveaux de gris.merci pour votre aide

Salut !

Pour le 8 bits, on récupère les 256 teintes de la palette dans un tableau.
On calcule les 256 niveaux de gris correspondants à ces 256 couleurs.
On sait que chaque pixel est enregistré comme un index (type Byte).
Cet index permettra d'aller chercher les composantes RGB ainsi que le niveaux de gris dans leur tableau respectif.
(En clair : il ne sert à rien de calculer 100 fois (ou plus) les mêmes valeurs, comme on le fait avec Pixels[X][Y])...

Chez moi ça donne ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
//En global
int Result[4][256]; // donc les gris en plus
 
class jRgb
{
public :
Byte Blue;
Byte Green;
Byte Red;
};
 
#define red   0
#define green 1
#define blue  2
#define grey  3 // puisque les gris en plus
 
PALETTEENTRY PaletteEntries[256];
Byte GreyLevels[256];
PALETTEENTRY E;

Code:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
int row, col;
jRgb * pRgb;
 
//RAZ du tableau
for(col = 0; col < 4; col++)
    {
    for(row = 0; row < 256; row++)
        {
        Result[col][row] = 0;
        }
    }
Graphics::TBitmap *B = Image1->Picture->Bitmap;
 
Byte r,g,b;
int gl;
Byte *Line;
switch(B->PixelFormat)
    {
    case pf8bit :
    //Couleurs de la palette dans PaletteEntries
    GetPaletteEntries(B->Palette, 0, 256, PaletteEntries);
    //Conversion en niveau de gris des 256 couleurs
    for(int j = 0; j < 256; j++)
        {
        E = PaletteEntries[j];
        gl = ((E.peRed * 30) + (E.peGreen * 59) + (E.peBlue * 11)) / 100;
        GreyLevels[j] = (Byte)gl;
        }
    //On peut commencer le calcul de l'histogramme
    for(row = 0; row < B->Height; row++)
        {
        Line = (Byte*)B->ScanLine[row];
        for(col = 0; col < B->Width; col++)
            {
            //le pixel comme index et non comme RGB
            b = Line[col]; 
            // les composantes RGB du pixel
            E = PaletteEntries[b];
            //Que l'on comptabilise 
            Result[blue][E.peBlue]++;
            Result[green][E.peGreen]++;
            Result[red][E.peRed]++;
            //On va chercher le niveau de gris que l'on comptabilise
            Result[grey][ GreyLevels[b] ]++;
            //pixel suivant
            Line++;
            }
        }
    break;
 
    case pf24bit :
    //Remplissage du tableau
    for(row = 0; row < B->Height; row++)
        {
        pRgb = (jRgb*)B->ScanLine[row];
        for(col = 0; col < B->Width; col++)
            {
            b = pRgb->Blue;
            Result[blue][b]++;
 
            g = pRgb->Green;
            Result[green][g]++;
 
            r = pRgb->Red;
            Result[red][r]++;
 
            gl = ((r * 30) + (g * 59) + (b * 11)) / 100;
            Result[grey][gl]++;
 
            pRgb++;
            }
        }
    }
 
//Remplissage du StringGrid
for(col=1; col < 5; col++)
    {
    for(row = 1; row < 257; row++)
        {
        StringGrid1->Cells[col][row] = IntToStr(Result[col-1][row-1]);
        }
    }

Juste pour info, voici comment j'ai utilisé la OnDrawCell du StringGrid :

Code:

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
35
36
37
 
//------------------------------------------
//REM : StringGrid1->DefaultDrawing = false
//------------------------------------------
void __fastcall TForm1::StringGrid1DrawCell(TObject *Sender, int Col,
      int Row, TRect &Rect, TGridDrawState State)
{
AnsiString N;
int we;
int he;
int x = (Rect.Right + Rect.Left) / 2;
int y = (Rect.Top + Rect.Bottom) / 2;
 
TCanvas *C = StringGrid1->Canvas;
C->Brush->Style = bsSolid;
C->Brush->Color = clWhite;
C->FillRect(Rect);
 
if(Row == 0)
    {
    switch(Col)
        {
        case 1 : N = "RED"; break;
        case 2 : N = "GREEN"; break;
        case 3 : N = "BLUE"; break;
        case 4 : N = "GREY"; break;
        }
    }
else
    {
    if(Col == 0) N = IntToStr(Row - 1);
    else N = StringGrid1->Cells[Col][Row];
    }
we = C->TextWidth(N) / 2;
he = C->TextHeight(N) / 2;
StringGrid1->Canvas->TextOut(x - we, y - he, N);
}

Pour le problème de comptabilité, je pense que celà peut venir du fait que je calcule sur le bitmap dans toute sa dimension... et non dans une lucarne (au cas où...)

A plus !