gradient d'une image jpeg prewit sur linux

Version imprimable

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:

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]

30/12/2005, 12h28
Luther13
A koi sert cette boucle ?
Code:

1 2 3 4 5 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; // ? } }
D'ailleurs la declaration de la variable m comme

Code:

long * m[][];

n'est pas bonne ou plutôt que represente m : un tableau à 2 dimension ?

Code commenté

Bonsoir,

La boucle sert à parcourir la ou les matrices dont on se sert pour appliquer plus facilement le masque de prewitt (axe x / axe y)

m est une matrice à trois dimensions (j'avais oubliée la couleur) qui garde les informations de pixel du jpeg d'entree et px/py gardent les informations après le traitement.

Mon problème c'est que je n'arrive pas a écrire les résultats dans le fichier d'image de sortie, j'ai un pointeur DYNAMIC *pointeur_px_out/DYNAMIC *pointeur_py_out et une méthode PIC_JPEG(char *filename,DYNAMIC *buff,int dx,int dy,int d) , mais je ne sais pas très bien comment m'en servir...

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
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
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
 
//==============================================================================
//==============================================================================
 
// Déctecteur de Contours avec masque de Prewitt - Décembre 2005.
//
// ALGORITHME
// - Convertir une image en niveaux de gris ou en couleur en une matrice d'intensité de couleur
// avec une taille idéntique à celle de l'image jpeg en entrée. Les valeurs de couleur
// varient entre 0 et 255 la valeur 0 étant le noir et 255 le blanc.
// - Appliquer un masque de prewitt Gx=[-1,0,1][-1,0,1][-1,0,1]
// - Appliquer un masque de prewitt Gy=[-1,-1,-1][0,0,0][1,1,1]
// - Imprimer les images résultantes en sortie ( jpeg ) (c’est ici mon problème!!!!)
 
//==============================================================================
//==============================================================================
#include <iostream>
#include <cstring>
#include "pic_jpeg.h" //fichier d'entête avec la classe et les méthodes pour le jpg
 
int main(int argc, char **argv)
{
//===========INSTRUCTIONS DE DECLARATION==================================================
//==================================================================================
int dim_x,dim_y,d; //vars pour garder les infos de taille et nombre de couches/plans de couleur
int m_y,m_x,plan; //vars pour parcourir la matrice en hauteur, largeur et par couche
 
char nom_in[256]; //var pour nom d'image en entrée
char nom_px_out[256];//var pour nom d'image masque prewitt axe x en sortie
char nom_py_out[256];//var pour nom d'image masque prewitt axe y en sortie
 
DYNAMIC *pointeur_jpg_in; //pointeur vers pixel à traiter (image d'entrée)
DYNAMIC *pointeur_px_out;//pointeur vers pixel à sauvegarder en sortie(image masque prewitt axe x)
DYNAMIC *pointeur_py_out;//pointeur vers pixel à sauvegarder en sortie(image masque prewitt axe y)
 
//===========INSTRUCTIONS EXECUTABLES=====================================================
//===================================================================================
 
//===========RECUPERER LES INFOS DU JPEG D'ENTREE
PIC_JPEG jpg_in; //instancier classe pic_jpeg (pour accès aux infos sur jpeg d'entrée)
sprintf(nom_in, argv[1]);//mémoiser dans (nom_in) le nom du jpeg fournit en entrée
jpg_in.read(nom_in);//lire le fichier d'image avec l'objet jpg_in
 
dim_x=jpg_in.getWidth();//recupèrer largeur en pixels du jpeg
dim_y=jpg_in.getHeight();//recupèrer hauteur en pixels du jpeg
d=jpg_in.getDepth();//recupèrer nombre de couches/plans de couleur du jpeg
pointeur_jpg_in=jpg_in.getBody();//recupèrer infos de couleur des pixels du jpeg
 
//===========GARDER LES INFOS DU JPEG D'ENTREE DANS UNE MATRICE
DYNAMIC m[d][dim_y][dim_x];//creer matrice à trois dimensions pour garder infos de couleur
 
for(plan=0; plan< d; plan++){//on parcourt tous les couches de couleur
for(m_y=0; m_y<dim_y; m_y++){//on parcourt toutes les lignes
for(m_x=0; m_x<dim_x; m_x++){//on parcourt toutes les colonnes
m[plan][m_y][m_x]= *pointeur_jpg_in++; //on fait évoluer pointeur et on garde infos dans la matrice
}//end for colonnes
}//end for lignes
}//end for couches de couleur
 
 
//===========PARCOURIR LA MATRICE AVEC LE MASQUE DE PREWITT
DYNAMIC px[d][dim_y][dim_x];//creer matrice à trois dimensions pour garder resultat de convolution axe x
DYNAMIC py[d][dim_y][dim_x];//creer matrice à trois dimensions pour garder resultat de convolution axe y
 
for(plan=0; plan< d; plan++){//on parcourt tous les couches de couleur
for(m_y=1; m_y<dim_y-1; m_y++){//on parcourt toutes les lignes
px[plan][m_y][0]=0;//image de la même taille, première ligne en noir (perte masque 3x3)
py[plan][m_y][0]=0;//image de la même taille, première ligne en noir (perte masque 3x3)
px[plan][m_y][dim_y]=0;//image de la même taille, dernière ligne en noir (perte masque 3x3)
py[plan][m_y][dim_y]=0;//image de la même taille, dernière ligne en noir (perte masque 3x3)
for(m_x=1; m_x<dim_x-1; m_x++){//on parcourt toutes les colonnes
px[plan][0][m_x]=0;//image de la même taille, premiere colonne en noir (perte masque 3x3)
py[plan][0][m_x]=0;//image de la même taille, premiere colonne en noir (perte masque 3x3)
px[plan][dim_x][m_x]=0;//image de la même taille, dernière colonne en noir (perte masque 3x3)
py[plan][dim_x][m_x]=0;//image de la même taille, dernière colonne en noir (perte masque 3x3)
px[plan][m_y][m_x]=-m[plan][m_y-1][m_x-1]+m[plan][m_y-1][m_x+1]-m[plan][m_y][m_x-1]+m[plan][m_y][m_x+1]-m[plan][m_y+1][m_x-1]+m[plan][m_y+1][m_x+1];
py[plan][m_y][m_x]=-m[plan][m_y-1][m_x-1]-m[plan][m_y-1][m_x]-m[plan][m_y-1][m_x+1]+m[plan][m_y+1][m_x-1]+m[plan][m_y+1][m_x]+m[plan][m_y+1][m_x+1];
}//end for colonnes
}//end for lignes
}//end for couches de couleur
 
 
PIC_JPEG px_out(dim_x,dim_y,d);//creer un pic_jpeg pour la sortie (taille idéntique au jpeg d'entrée)
PIC_JPEG py_out(dim_x,dim_y,d);//creer un pic_jpeg pour la sortie (taille idéntique au jpeg d'entrée)
 
pointeur_px_out=px_out.getBody();
pointeur_py_out=py_out.getBody();
 
//===========PARCOURIR L'IMAGE FILTREE PREWITT AXE X ET CRÉER JPEG PIXEL PAR PIXEL
for(plan=0; plan< d; plan++){//on parcourt tous les couches de couleur
for(m_y=0; m_y<dim_y; m_y++){//on parcourt toutes les lignes
for(m_x=0; m_x<dim_x; m_x++){//on parcourt toutes les colonnes
pointeur_px_out++;
pointeur_py_out++;
}//end for colonnes
}//end for lignes
}//end for couches de couleur
 
 
//===========PRINT DE CONTROLE DES RESULTATS
fprintf(stdout,"(%d,%d,%d)\n",dim_x,dim_y,d);//imprimer taille et nombre de couches
fprintf(stdout,"(%f)\n",m[0][150][150]);//imprimer la valeur d'un pixel au hasard
fprintf(stdout,"(%f)\n",px[0][150][150]);
fprintf(stdout,"(%f)\n",py[0][150][150]);
 
//===========IMAGES EN SORTIE
 
sprintf(nom_px_out, "prewitt_x_%s",nom_in);//mémoriser dans (nom_px_out) jpeg prewitt axe x 
sprintf(nom_py_out, "prewitt_y_%s",nom_in);//mémoriser dans (nom_py_out) jpeg prewitt axe y 
 
px_out.write(nom_px_out,100);//écrire un fichier d'image jpeg de qualité de compression 100%
py_out.write(nom_py_out,100);//écrire un fichier d'image jpeg de qualité de compression 100%
 
 
return 1;
}
 
 
 
 
//==============================================================================
 
// Header pour la Classe PIC_JPEG.h - Décembre 2005.
 
//==============================================================================
 
#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

30/12/2005, 23h16
laberthe

En fait

j'arrive à recupèrer les infos du pixel en entrée mais en sortie je n'arrive pas à écrire le resultat de mes calculs dans une image jpeg
...ma question a donc, évoluée un peu...
mais le problème est toujours le même...
j'ai du mal à m'en servir des pointeurs car je n'ai pas d'experience avec c++.
En tout cas j'ai fait bcp de recherches dans des forums et sur internet (en espagnol, français et anglais), et je pensait qu'il serait bien de laisser ce code ici (quand il fonctionnera), car il y a peu d'informations disponibles sur le web sur le traitement d'images jpeg avec des masques de convolution en c++ sur linux (on trouve l'algorithme mais pas le code).

En tout cas, merci d'essaier de m'aider...c'est gentil...