Charger une image et appliquer un filtre

**yusuzen** · 31/10/2009, 19h36

Bonjour, je suis débutant en c++ builder et je souhaiterai établir un programme qui charge une image puis lui appliquée un filtre par le biais d'un produit de convolution. j'ai pu réalisé les premières étapes mes au niveau du produit de convolution sa bloque, en plus je reçois des messages d'erreurs E2015 au niveau de "Image1[][]" qui dit: "Ambiguity between 'TComponent::operator IInterfaceComponentReference*()' and 'Tcomponent::operator IInterface*()'".

Je vous écrit le code c++ et j'espère que quelqu'un d'entre vous puisse m'aider à résoudre le problème. merci d'avance
cordialement

Le code c++

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
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
//---------------------------------------------------------------------------
 
#include <vcl.h>
#pragma hdrstop
 
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------
 
 
void __fastcall TForm1::OuvrirClick(TObject *Sender)
{
this->OpenPictureDialog1->Execute();
Image1->Picture->LoadFromFile(this->OpenPictureDialog1->FileName);
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::LectureClick(TObject *Sender)
{
int l,c;
int** image1;
//Lecture
l=Image1->Height;
c=Image1->Width;
image1=new int*[l];
for (int x=0 ; x<=l; x++)
image1[x]=new int [c];
 
      //niveau gris
      for (int x=0 ; x<=l; x++){
      for (int y=0 ; y<=c; y++){
 
         int r,v,b,g;
 
         r=GetRValue(this->Image1->Canvas->Pixels [x][y]);
         v=GetGValue(this->Image1->Canvas->Pixels [x][y]);
         b=GetBValue(this->Image1->Canvas->Pixels [x][y]);
         g=div(r+v+b,3).quot;
         image1[x][y]=g;
 
               }
      }
 
 
      //Affichage
 
       this->StringGrid1->ColCount=c;
       this->StringGrid1->RowCount=l;
       for (int x=0 ; x<=l; x++){
       for (int y=0 ; y<=c; y++){
       this->StringGrid1->Cells [x][y]=image1[x][y];
       }
       }
}
//---------------------------------------------------------------------------
void __fastcall TForm1::FiltreClick(TObject *Sender)
{
 int** filt;
//Lecture
filt=new int*[3];
for (int i=0 ; i<=3; i++)
filt[i]=new int [3];
//Affichage
 
       this->StringGrid2->ColCount=3;
       this->StringGrid2->RowCount=3;
       for (int i=0 ; i<=3; i++){
       for (int j=0 ; j<=3; j++){
       this->StringGrid2->Cells [0][0]=1;
       this->StringGrid2->Cells [0][1]=0;
       this->StringGrid2->Cells [0][2]=-1;
       this->StringGrid2->Cells [1][0]=1;
       this->StringGrid2->Cells [1][1]=0;
       this->StringGrid2->Cells [1][2]=-1;
       this->StringGrid2->Cells [2][0]=1;
       this->StringGrid2->Cells [2][1]=0;
       this->StringGrid2->Cells [2][2]=-1;
       }
       }
       for (int i=0 ; i<=3; i++){
       for (int j=0 ; j<=3; j++){
 
       this->StringGrid2->Cells [i][j] = filt[i][j];
}
}
}
//---------------------------------------------------------------------------
 
void __fastcall TForm1::ConvolutionClick(TObject *Sender)
{
int h,w,t1,t2;
int** conv,filt;
 
h=Image1->Height;
w=Image1->Width;
conv=new int*[h];
for (int x=0 ; x<=h; x++)
conv[x]=new int [w];
 
// Produit de convolution
 for (int x=1 ; x<=h-1; x++){
       for (int y=1 ; y<=w-1; y++){
        t1=filt[0][0]*Image1[x-1][y-1]+filt[0][1]*Image1[x-1][y]+filt[0][2]*Image1[x-1][y+1]+filt[1][0]*Image1[x][y-1]+filt[1][1]*Image1[x][y]+filt[1][2]*Image1[x][y+1]+filt[2][0]*Image1[x+1][y-1]+filt[2][1]*Image1[x+1][y]+filt[2][2]*Image1[x+1][y+1];
        t2=div(t1,9).quot;
        conv[x][y]=t2;
        }
 }
 
// affichage
 
 for (int x=0 ; x<=h; x++){
       for (int y=0 ; y<=w; y++){
        this->Image2->Canvas->Pixels [x][y];
        }
        }
}
//---------------------------------------------------------------------------

**pottiez** · 03/11/2009, 10h13

Salut,
Image1 est un TImage, et si c'est bien aux pixels que tu veut accéder en faisant [][] alors il faut que tu utilise la propriété Pixel du canvas, comme tu l'as fait pôur ton Image2

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
void __fastcall TForm1::ConvolutionClick(TObject *Sender)
{
   int h,w,t1,t2;
   int** conv,filt;
 
   h=Image1->Height;
   w=Image1->Width;
   conv=new int*[h];
   for (int x=0 ; x<=h; x++)
     conv[x]=new int [w];
 
// Produit de convolution
    for (int x=1 ; x<=h-1; x++){
            for (int y=1 ; y<=w-1; y++){
               t1=filt[0][0]*Image1->Canvas->Pixel[x-1][y-1]+filt[0][1]*Image1->Canvas->Pixel[x-1][y]+filt[0][2]*Image1->Canvas->Pixel[x-1][y+1]+filt[1][0]*Image1->Canvas->Pixel[x][y-1]+filt[1][1]*Image1->Canvas->Pixel[x][y]+filt[1][2]*Image1->Canvas->Pixel[x][y+1]+filt[2][0]*Image1->Canvas->Pixel[x+1][y-1]+filt[2][1]*Image1->Canvas->Pixel[x+1][y]+filt[2][2]*Image1->Canvas->Pixel[x+1][y+1];
               t2=div(t1,9).quot;
               conv[x][y]=t2;
             }
    }
 
   // affichage
 
    for (int x=0 ; x<=h; x++){
            for (int y=0 ; y<=w; y++){
               this->Image2->Canvas->Pixels [x][y];
             }
           }
}

PS : Ajoute des parenthèses à ton calcule, ça ne fait pas de mal et ça évite des erreurs bêtes

**yusuzen** · 26/12/2009, 15h05

Merci de m'avoir aider, autre chose je souhaiterai savoir comment faire la conversion matrice->image et vis versa.

**henderson** · 27/12/2009, 20h12

Salut !

En matière de traitement d'images il faut toujours privilégier le temps d'exécution au temps de développement !
TCanvas::Pixels est certes très pratique d'emploi mais excessivement pénalisant au niveau temps d'exécution.
Les problèmes seraient résolus en travaillant avec des bitmaps au lieu des tableaux qui ne doivent être mis en lice que pour des calculs intermédiaires.
Pour accéder directement aux compsantes RGB des pixels il suffit de :

Code :

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

1
2
3
4
5
6
7
8
 
class jRgb
{
public :
Byte b;
Byte g;
Byte r;
};

Et d'utiliser TBitmap::ScanLine !

Voici un exemple de conversion en gris argentique.
Srce est le bitmap dans lequel est stockée l'image.
Dest est un bitmap dans lequel sera stockée l'image convertie en niveau de gris.
Ces deux bitmaps ont leur propriété PixelFormat fixé à pf24bit.

Graphics::TBitmap *Srce;
Graphics::TBitmap *Dest;

Srce et Dest peuvent être des bitmaps isolés ou bien être ceux de leur TImage !
Au quel cas on aurait (par exemple) :

Graphics::TBitmap *Srce = Image1->Picture->Bitmap;
Graphics::TBitmap *Dest = Image2->Picture->Bitmap;

Voici la conversion :

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
 
jRgb *S, *D;
int y, x, g;
 
Dest->Width = Srce->Width;
Dest->Height = Srce->Height;
 
for(y=0; y < Dest->Height; y++)
    {
    S = (jRgb*)Srce->ScanLine[y]; // ligne des pixels source
    D = (jRgb*)Dest->ScanLine[y]; // ligne des pixels de destination
    for(x = 0; x < Dst->Width; x++)
        {
        g = ((S[x].r * 30) +
             (S[x].g * 59) +
             (S[x].b * 11)) / 100;
        //REM : dans un 24 bits: R = G = B = niveau de gris 
        D[x].r = (Byte)g ;
        D[x].g = (Byte)g ;
        D[x].b = (Byte)g ;
        }
    }

Si Dest est le bitmap d'un TImage, il suffira de faire :

Code :

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

1
2
 
Image2->Repaint();

Si Dest est un bitmap isolé, on peut le dessiner directement sur une form à un emplacement quelconque :

Code :

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

1
2
 
Canvas->Draw(0, 0, Dest);

Il y a pas mal de discussions sur ScanLine sur ce forum donc ...

A plus !

**yusuzen** · 31/12/2009, 10h44

Bonjour, merci pour vos réponse.
je souhaiterai savoir comment faire la conversion matrice->image et vis versa.

**b_reda31** · 05/01/2010, 20h20

Une partie de ce post traite le chargement d'une image dans une matrice et vis versa.

**kmaniche** · 30/01/2010, 21h40

Mise à part la solution que ta proposé henderson, qui est la plus efficace. Pour te permettre de commencer, je te donne ce code :

Lecture de l'image et la mettre dans une matrice :

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
 
// Déclaration des variables
int H = Image1 -> Picture -> Height,
    W= Image1 -> Picture -> Width ; 
 
int **ImSourceR = new int*[H] ;
int **ImSourceG = new int*[H] ;
int **ImSourceB = new int*[H] ;
 
for(int i = 0 ; i < H ; i++)
      {
         ImSourceR[i] = new int[W] ;
         ImSourceG[i] = new int[W] ;
         ImSourceB[i] = new int[W] ;
       }   
 
// Lecture de l'image et la mettre dans la matrice
for(int i = 0 ; i < H ; i++)
   for(int j = 0 ; j < W ; j++)
      {
         ImSourceR[i][j] = GetRValue(Image1 -> Canvas -> Pixels[j][i]);
         ImSourceG[i][j] = GetGValue(Image1 -> Canvas -> Pixels[j][i]);
         ImSourceB[i][j] = GetBValue(Image1 -> Canvas -> Pixels[j][i]);
        }

Charger une image et appliquer un filtre

C++Builder

Discussions similaires

Partager

Partager