Bonjour,
je suis debutant en c++ et je suis en train de developper un code de detection de contours avec un masque de prewitt pour une image jpeg et sur linux.

je ne comprends pas très bien comment recupèrer l'intensité de chaque pixel pour la garder dans une matrice et ensuite appliquer le masque et calculer le gradient.
ici, ma variable buffer_jpg_in donne toujours la même valeur, et je pense que le pointeur ne parcours pas l'image...

Quelqu'un peut m'aider?

Voici mon code

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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
#include <iostream>
#include <cstring>
#include "pic_jpeg.h"
#include "gaussian_filtering.h"
 
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 
int main(int argc, char **argv)
{
PIC_JPEG jpg_in;
int dim_x,dim_y,d;
DYNAMIC *buffer_jpg_in;
int m_x, m_y ;
 
char nom_in[256];
sprintf(nom_in, argv[1]);
jpg_in.read(nom_in);
 
dim_x=jpg_in.getWidth();
dim_y=jpg_in.getHeight();
d=jpg_in.getDepth();
buffer_jpg_in=jpg_in.getBody();
 
DYNAMIC *m[512][512];
 
for(m_y=0;  m_y<dim_y; m_y++){
for(m_x=0; m_x<dim_x; m_x++){
m[m_y][m_x]= buffer_jpg_in;
}
}
fprintf(stdout,"(%d,%d,%d)\n",dim_x,dim_y,d);
 
 
 
PIC_JPEG jpg_out(dim_x,dim_y,d);
DYNAMIC *buffer_jpg_out;
buffer_jpg_out=jpg_out.getBody();
 
Gaussian_Filtering filter( 4.0, buffer_jpg_in, buffer_jpg_out, dim_x, dim_y, d);
filter.xy_smoothing();
 
 
char nom_out[256];
sprintf(nom_out, "test_out_%s",nom_in);
jpg_out.write(nom_out,100);
 
  return 1;
}
 
//=================pic_jpeg
 
#ifndef PIC_JPEG_H
#define PIC_JPEG_H
 
#include <iostream>
 
extern "C" {
#include <string.h>
#include <stdio.h>
#include <jpeglib.h>
#include <setjmp.h>
}
 
#define IN(bi,bs,valeur) (((bi <= valeur) && (valeur <= bs)) ? 1 : 0) 
 
#define DYNAMIC float
 
class PIC_JPEG 
{
 
protected:
 
  unsigned int height, width, depth;
  DYNAMIC *body;
  char *file_name;
 
  int readJpeg(char *);
 
public:
 
  static const unsigned int RED = 0;
  static const unsigned int GREEN = 1;
  static const unsigned int BLUE = 2;
  static const unsigned int RGB_DEPTH = 3;
 
  PIC_JPEG();
  PIC_JPEG(const PIC_JPEG &i);
  PIC_JPEG(int dx, int dy, int d);
  PIC_JPEG(char *filename,DYNAMIC *buff,int dx,int dy,int d);
 
  ~PIC_JPEG();
 
  unsigned int isLoaded() const;
  unsigned int getWidth() const;
  unsigned int getHeight() const;
  unsigned int getDepth() const;
  DYNAMIC *getBody() const;          // Pas de copie
 
  DYNAMIC &operator() (unsigned int x, unsigned int y, unsigned int d) const;
  char *getFilename();
 
  void clear();
 
  void rescale(unsigned int w, unsigned int h);
 
  int crop(unsigned int,unsigned int,unsigned int,unsigned int);  
 
  int read(char *filename);
  int write(char *filename, int quality) const;
};
 
 
#endif
 
//===============le filtre gaussian
 
#ifndef GAUSSIAN_FILTERING_H
#define GAUSSIAN_FILTERING_H
 
#include <iostream>
#include "pic_jpeg.h"    // pour DYNAMIC
 
class Gaussian_Filtering
{
  protected :
 
    float sigma;
    DYNAMIC *buffer_in,*buffer_out;
    int dim_x,dim_y,dim_z;
    int depth;
    int px,py,pz;
    double pos_num_x[4],neg_num_x[4],den_x[4];
    double pos_num_y[4],neg_num_y[4],den_y[4];
    double pos_num_z[4],neg_num_z[4],den_z[4];
 
    void init(DYNAMIC *,DYNAMIC *,int,int,int);
    void coeff(int,float,double *,double *,double *);
    void filtre(DYNAMIC *,int,double *,double *,double *);
    DYNAMIC *extract_suite(DYNAMIC *,int,int,int);
    void remplit(DYNAMIC *,DYNAMIC *,int,int,int);
    int filter(float,int,int);
 
  public :
 
    // Initialisations
 
    Gaussian_Filtering(float s);
    void setBuffers(DYNAMIC *b1,DYNAMIC *b2,int nb_col,int nb_lig,int d);
    void setBuffers(DYNAMIC *b1,DYNAMIC *b2,int nb_col,int nb_lig);
 
    Gaussian_Filtering(float s,DYNAMIC *b_in,DYNAMIC *b_out,int nb_col,int nb_lig,int d);
    Gaussian_Filtering(float s,DYNAMIC *b_in,DYNAMIC *b_out,int nb_col,int nb_lig);
 
    // Les outils de filtrage
 
    void xy_smoothing();         // lissage en x et y  
 
    void x_derivative();         // derivee 1ere en x lissage en y
    void xx_derivative();        // derivee 2eme en x lissage en y 
    void xxx_derivative();       // derivee 3eme en x lissage en y
 
    void y_derivative();         // derivee 1ere en y lissage en x
    void yy_derivative();        // derivee 2eme en y lissage en x 
    void yyy_derivative();       // derivee 3eme en y lissage en x
 
    void xy_derivative();        // derivee 1ere en x derivee 1ere en y 
    void xxy_derivative();       // derivee 2eme en y derivee 1ere en x
    void xyy_derivative();       // derivee 2eme en x derivee 1ere en y 
};
 
 
#endif

[Balises CODE rajoutées par Loulou24, merci d'y penser à l'avenir]