analyse d'une image

**floopi51** · 04/12/2008, 13h34

Envoyé par ToTo13

Bonjour,

oui, c'est une bonne idée de pré-traiter ton image.
Je te conseillerai de commencer par faire un seuillage sur le noir => tu auras tout le texte et les lignes du tableau.

je ne connais rien au traitement d'image. pour l'instant j'apprend en lisant de la doc sur le web.... d'où forcément mes lacunes...

ma question : si mon image est deja transformée en texte noir sur fond blanc, qu'est ce que va m'apporter en plus un seuillage sur le noir ?
à moins que j'ai mal compris et que tu me conseilles de faire un seuillage sur le noir comme pré-traitement de l'image pour obtenir le texte en noir sur du blanc ?

Envoyé par ToTo13

Puis une petite transformée de Hough pour trouver les lignes et les supprimer.
Ensuite tu utilise un petit OCR

**ToTo13** · 05/12/2008, 08h02

bonjour,

si ton image contient déjà le texte noir sur fond blanc, inutile de faire le seuillage.

En revanche, même si cela est déjà fait, il doit te rester les lignes formant le tableau.
Donc là je les détecterai avec l'incontournable transformée de Hough. Fais une recherche dans ce forum (Algo), tu trouveras tout ce dont tu as besoin. Même du code Java.

**floopi51** · 05/12/2008, 16h59

bonjour,

pour automatiser le traitement de mon image originale, je suis finalement partie sur la programmation du seuillage.
je précise que je programme en C et avec libpng.
je met un exemple d'image en pièce jointe.

par un premier traitement (image passée en niveau de gris puis seuillage), j'obtiens une image (img1) avec tout le texte noir sur un fond blanc.

j'inverse l'image pour passer le texte blanc en noir et le noir en blanc.
je recupère une 2ème image (img2)avec le texte qui était en blanc passé en noir.

après ca, je veux recopier ces 2 images dans une seule pour recuperer tout le texte et là ca ne fonctionne pas.je recupère une image toute noire.

je me suis basée sur cet algo :

Faire ouvrir Image à seuiller
Créer nouveaux tableau
Faire pour tout i dans img1 et img2
regarder img1.pixel[i] et img2.pixel[i]
si img1.pixel[i] >= 2 et si img2.pixel[i] >= 2
mettre tableau[i] à 0xffffff (blanc)
sinon mettre tableau[i] à zéro.
Fin si
Créer l'image résultat a partir de tableau
Fin faire

merci

**souviron34** · 05/12/2008, 17h44

ben avec ton algo, c'est normal

A partir de img1, (texte noir sur fond blanc), si tu veux texte blanc sur fond noir, tu inverses (img2), et c'est tout, non ??

Code :

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

1
2
3
4
si img1 < 20
    img2 = blanc
sinon
    img2 = noir

(le seuil est au pif)

et tu travailles seulement avec img2 ...

**floopi51** · 05/12/2008, 17h57

Envoyé par souviron34

ben avec ton algo, c'est normal

A partir de img1, (texte noir sur fond blanc), si tu veux texte blanc sur fond noir, tu inverses (img2), et c'est tout, non ??

Code :

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

1
2
3
4
si img1 < 20
    img2 = blanc
sinon
    img2 = noir

(le seuil est au pif)

et tu travailles seulement avec img2 ...

non pas si simple j'illustre avec les images obtenues par mes traitement successifs.
l'image originale contient du texte blanc et du texte noir. le fond est de differentes couleurs.
j'essaye de recuperer le texte pour l'avoir tout en noir sur fond tout blanc.

ah oui je viens de comprendre le travail sur seulement 2 images.
je parcours img1 je mets en noir dans img2 si c est en noir dans img1.
pour le reste je ne fais rien.

je retente le traitement

**floopi51** · 08/12/2008, 15h45

Envoyé par floopi51

ah oui je viens de comprendre le travail sur seulement 2 images.
je parcours img1 je mets en noir dans img2 si c est en noir dans img1.
pour le reste je ne fais rien.

je retente le traitement

bon ben je bloque là : j'obtiens toujours une image totalement noire en résultat.

quelqu'un aurait-il une idée ?
je met mon code : c'est du C et j'utilise la librairie libpng

Code C :

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
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
 
#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
#include <stdarg.h>
 
#include <png.h>
 
int *image1, *image2;
int xs,ys;
int force_gamma_1;
 
/*****************************************************************************/
void 
threshold(int param, int* image1, int* image2) {
  int a;
  int *iptr1, *iptr2;
  int val;
 
  iptr1=image1;
  iptr2=image2;
 
  for(a=xs*ys; a; a--) {
    val=*iptr2;
    *iptr1++=(val>=param)?0xffffff:0;
    if(!(val>=param)) printf("OK\n");
  }
}
/*****************************************************************************/
void 
write_png(unsigned char *filename, int *image) {
  unsigned char *temporary;
  unsigned char *tptr;
  int *iptr,a;
  FILE *f;
  png_structp png_ptr;
  png_infop info_ptr;
 
  f = fopen(filename,"w");
  if(!f) {
    fprintf(stderr,"Unable to open file %s.\n",filename);
    exit(1);
  }
 
  temporary=malloc(xs*ys);
  if(!temporary){
    fprintf(stderr,"Out of memory.\n");
    exit(1);
  }
 
  iptr=image;
  tptr=temporary;
 
  for(a=xs*ys; a; a--) {
    *tptr++=(*iptr++)>>16;
  }
 
  png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,NULL,NULL,NULL);
  info_ptr = png_create_info_struct(png_ptr);
  png_init_io(png_ptr,f);
 
  png_set_filter(png_ptr,0,PNG_FILTER_NONE|PNG_FILTER_SUB|PNG_FILTER_UP
		 |PNG_FILTER_AVG|PNG_FILTER_PAETH);
 
  png_set_compression_level(png_ptr,Z_BEST_COMPRESSION);
 
  png_set_IHDR(png_ptr,info_ptr,xs,ys,8,PNG_COLOR_TYPE_GRAY,PNG_INTERLACE_NONE,
	       PNG_COMPRESSION_TYPE_DEFAULT,PNG_FILTER_TYPE_DEFAULT);
 
  png_set_gAMA(png_ptr,info_ptr,1.0);
 
  png_write_info(png_ptr,info_ptr);
 
  tptr=temporary;
  for(a=ys; a; a--) {
    png_write_row(png_ptr,tptr);
    tptr+=xs;
  }
 
  png_write_end(png_ptr,info_ptr);
  png_destroy_write_struct(&png_ptr,&info_ptr);
  free(temporary);
  fclose(f);
}
 
/*****************************************************************************/
void 
read_png(FILE *f, png_structp png_ptr, png_infop info_ptr, 
	 int *image, int invertMode) {
  unsigned char *temporary_array;
  png_color_16p* background;
  double gamma;
  int y1,number_of_passes;
  unsigned char **ptrs;
 
  if (png_get_gAMA(png_ptr,info_ptr, &gamma)) {
    if (force_gamma_1) {
      png_set_gamma(png_ptr, 1.0, 1.0);
    /* Forcing gamma is here for repairing files after processing
     * with GIMP, which deliberately writes gamma=00 00 b1 8f
     * even when input gamma was 00 01 86 a0 and no gamma setting
     * change is performed by user (simply saind, GIMP is
     * braindead)
     */
    } else {
      png_set_gamma(png_ptr, 1.0, gamma);
    }
  } else {
    png_set_gamma(png_ptr, 1.0, 0.454545);
  }
 
  {
    int bit_depth;
    int color_type;
 
    color_type = png_get_color_type(png_ptr, info_ptr);
    bit_depth = png_get_bit_depth(png_ptr, info_ptr);
 
    if (color_type==PNG_COLOR_TYPE_GRAY) {
      if (bit_depth<8) {
	png_set_expand(png_ptr);
      }
      if (bit_depth==16) {
	png_set_strip_16(png_ptr);
      }
    }
 
    if (color_type==PNG_COLOR_TYPE_PALETTE){
      png_set_expand(png_ptr);
      /*png_set_rgb_to_gray(png_ptr,1,54.0/256,183.0/256);*/
      png_set_rgb_to_gray(png_ptr, 1, 0, 100000);
    }
 
    if (color_type & PNG_COLOR_MASK_ALPHA){
      png_set_strip_alpha(png_ptr);
    }
    if (color_type==PNG_COLOR_TYPE_RGB ||
	color_type==PNG_COLOR_TYPE_RGB_ALPHA){
      png_set_rgb_to_gray(png_ptr, 1, 54.0/256, 183.0/256);
      /*png_set_rgb_to_gray(png_ptr, 1, 0, 100000);*/
    }
 
  }
 
  if(invertMode == 1) {
    png_set_invert_mono(png_ptr);
  }
 
  /* If the depth is different from 8 bits/gray, make the libpng expand
   * it to 8 bit gray.
   */
  number_of_passes = png_set_interlace_handling(png_ptr);
  png_read_update_info(png_ptr,info_ptr);
 
  temporary_array = malloc(xs*ys);
  ptrs = malloc(ys*sizeof(*ptrs));
 
  for(y1=0;y1<ys;y1++) {
    ptrs[y1]=temporary_array+xs*y1;
  }
  for(;number_of_passes;number_of_passes--) {
    png_read_rows(png_ptr, ptrs, NULL, ys);
  }
 
  png_read_end(png_ptr, NULL);
 
  {
    int *imptr=image;
    unsigned char *tptr=temporary_array;
    int a;
 
    for (y1=ys*xs;y1;y1--) {
      a=*tptr++;
      a=a|(a<<8)|(a<<16);
      *imptr++=a;
    }
  }
  free(ptrs);
  free(temporary_array);
}
 
/*****************************************************************************/
int
main (int argc, char *argv[]) {
  FILE *f1, *f2;
  png_structp png_p1, png_p2;
  png_infop info_p1, info_p2;
 
  if(argc < 2) {
    fprintf (stderr, "usage: %s filename.png fileout.png\n", argv[0]);
    return -1;
  }
 
  /* 1ère lecture de l'image :
   * on traite l'image pour récupérer le texte en noir */
  f1 = fopen(argv[1],"r");
  if(f1 == NULL) {
    fprintf(stderr,"impossible d'ouvrir %s\n",argv[1]);
    exit(1);
  }
  png_p1 = png_create_read_struct(PNG_LIBPNG_VER_STRING,
				   NULL, NULL, NULL);
  info_p1 = png_create_info_struct(png_p1);
  png_init_io(png_p1,f1);
  png_read_info(png_p1, info_p1);
 
  xs = png_get_image_width(png_p1,info_p1);
  ys = png_get_image_height(png_p1,info_p1);
 
  image1 = malloc(xs*ys*sizeof(image1));
  /* on lit l'image, les pixels sont stockées dans image1 */
  /* revertMode = 0 : l'image n'est pas inversée
   */
  read_png(f1, png_p1, info_p1, image1, 0);
  png_destroy_read_struct(&png_p1, &info_p1, NULL);
  fclose(f1);
 
  /* 2eme lecture de l'image originale */
  /* on va inverser l'image pour pouvoir recuperer le texte
   * qui est en blanc */
  f2 = fopen(argv[1],"r");
  if(f2 == NULL) {
    fprintf(stderr,"impossible d'ouvrir %s\n",argv[1]);
    if(image1 != NULL) free(image1);
     exit(1);
  }
  png_p2 = png_create_read_struct(PNG_LIBPNG_VER_STRING,
				   NULL, NULL, NULL);
  info_p2 = png_create_info_struct(png_p2);
  png_init_io(png_p2,f2);
  png_read_info(png_p2, info_p2);
 
  image2 = malloc(xs*ys*sizeof(image2));
   /* on lit l'image, les pixels sont stockées dans image2 */
  /* revertMode = 1 : l'image est inversée
   * inversée = pixel noir ==> blanc && pixel blanc ==>noir
   */
  read_png(f2, png_p2, info_p2, image2, 1);
  png_destroy_read_struct(&png_p2, &info_p2, NULL);
  fclose(f2);
 
  /* traitement parallèle des 2 images
   * on lit image2 et on modifie image1 quand on a des pixels noirs
   * pour les reporter dans image1
   */
  threshold(2, image1, image2);
 
  /* ecriture du fichier final */
  write_png(argv[2], image1);
 
  if(image1 != NULL) free(image1);
  if(image2 != NULL) free(image2);
 
  return 0;
}

**souviron34** · 08/12/2008, 17h26

plusieurs remarques :

A quoi ça sert que C il se décarcasse !!!

il y a des types , comme FILE, comme des char *, etc etc...

Dans les tests, il faut tester par rapport à NULL si on teste des pointeurs, ou par rapport à la valeur quand elle est donnée :

if ( f == NULL )
if ( temporary == NULL )
....

etc.... La variable n'est pas un booléen.. C'est le test qui l'est

Secondo, les indices de boucles commencent à zéro, donc :

Code :

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

  for(a=xs*ys; a; a--)

est faux pour 2 raisons :

l'image va de 0 à xs*ys - 1
la valeur de fin n'est pas définie

Je n'ai pas été plus loin....

**floopi51** · 08/12/2008, 20h49

Envoyé par souviron34

plusieurs remarques :

A quoi ça sert que C il se décarcasse !!!

il y a des types , comme FILE, comme des char *, etc etc...

Dans les tests, il faut tester par rapport à NULL si on teste des pointeurs, ou par rapport à la valeur quand elle est donnée :

if ( f == NULL )
if ( temporary == NULL )
....

etc.... La variable n'est pas un booléen.. C'est le test qui l'est

Secondo, les indices de boucles commencent à zéro, donc :

Code :

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

  for(a=xs*ys; a; a--)

est faux pour 2 raisons :

l'image va de 0 à xs*ys - 1
la valeur de fin n'est pas définie

Je n'ai pas été plus loin....

merci.
mon image est toujours noire....

**Emmanuel Delahaye** · 08/12/2008, 23h06

Envoyé par floopi51

merci.
mon image est toujours noire....

Il est possible qu'il y ait d'autres bugs...

**souviron34** · 09/12/2008, 01h17

Comme tu n'as pas bien lu ma remarque sur ton algo, je te pointe les 2 endroits ou ça ne va pas :

Envoyé par floopi51

:

Code C :

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
 
  /* on lit l'image, les pixels sont stockées dans image1 */
  /* revertMode = 0 : l'image n'est pas inversée
   */
  read_png(f1, png_p1, info_p1, image1, 0);
  png_destroy_read_struct(&png_p1, &info_p1, NULL);
  fclose(f1);
 
  /* 2eme lecture de l'image originale */
  /* on va inverser l'image pour pouvoir recuperer le texte
   * qui est en blanc */
  f2 = fopen(argv[1],"r");
  if(f2 == NULL) {
    fprintf(stderr,"impossible d'ouvrir %s\n",argv[1]);
    if(image1 != NULL) free(image1);
     exit(1);
  }
  png_p2 = png_create_read_struct(PNG_LIBPNG_VER_STRING,
				   NULL, NULL, NULL);
  info_p2 = png_create_info_struct(png_p2);
  png_init_io(png_p2,f2);
  png_read_info(png_p2, info_p2);
 
  image2 = malloc(xs*ys*sizeof(image2));
   /* on lit l'image, les pixels sont stockées dans image2 */
  /* revertMode = 1 : l'image est inversée
   * inversée = pixel noir ==> blanc && pixel blanc ==>noir
   */
  read_png(f2, png_p2, info_p2, image2, 1);
  png_destroy_read_struct(&png_p2, &info_p2, NULL);
  fclose(f2);
 
  /* traitement parallèle des 2 images
   * on lit image2 et on modifie image1 quand on a des pixels noirs
   * pour les reporter dans image1
   */
  threshold(2, image1, image2);
 
  /* ecriture du fichier final */
  write_png(argv[2], image1);
 
  if(image1 != NULL) free(image1);
  if(image2 != NULL) free(image2);
 
  return 0;
}

Réfléchis... Tu fais n'importe quoi, là...

Primo, tu n'as pas besoin de re-lire l'image, tu l'as en mémoire (img1).

D'autre part, que vient faire ce bidouillage ??
J'ai pas été clair ??

Code C :

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
 
  /* on lit l'image, les pixels sont stockées dans image1 */
  /* revertMode = 0 : l'image n'est pas inversée
   */
  read_png(f1, png_p1, info_p1, image1, 0);
  png_destroy_read_struct(&png_p1, &info_p1, NULL);
  fclose(f1);
 
 
  image2 = malloc(xs*ys*sizeof(image2));
   /* on inverse l'image, les pixels sont stockées dans image2 */
   */
  threshold(2, image1, image2);
 
  /* ecriture du fichier final */
  write_png(argv[2], image2);
 
  free(image1);
  free(image2);
 
  return 0;
}

Et tu copies dans le mauvais sens.. Et tu fais plein d'opérations inutiles, et tu écrases tes résultats... Et tu n'incrémentes pas iptr1.... Bref, beaucoup de travail....

Code C :

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
 
/*****************************************************************************/
void 
threshold(int param, int* image1, int* image2) {
  int a;
  int *iptr1, *iptr2;
  int val;
 
  iptr1=image1;
  iptr2=image2;
 
  for(a=xs*ys-1; a >= 0; a--) {
   val = *iptr1 ;
    *iptr2++=(val<=param)?0xffffff:0;
    if(val<=param) printf("OK\n");
   iptr1++ ;
  }
}

Avec un bon passage de param, ceci devrait marcher....

ET LA CORRECTION DES REMARQUES MISES PLUS HAUT.....

(je n'ai ni testé, ni compilé)

(et je mettrais au moins 10 ou 20 pour le seuil, et non pas 2)...

**floopi51** · 09/12/2008, 09h23

Envoyé par Emmanuel Delahaye

Il est possible qu'il y ait d'autres bugs...

il y en a surement mais le problème c'est qu'en ayant le nez dedans depuis plusieurs jours, je ne les vois plus

Envoyé par souviron34

Primo, tu n'as pas besoin de re-lire l'image, tu l'as en mémoire (img1).

D'autre part, que vient faire ce bidouillage ??
J'ai pas été clair ??

je ré-explique les manips que j'essaye de faire :

mon image de départ contient du texte noir sur fond clair ET du texte blanc sur fond en couleur. Je fais un double traitement de l'image pour pouvoir récuperer tout le texte (blanc et noir) en noir sur fond blanc.
Je procède donc en 2 étapes :

1) première lecture de l'image
- ouverture du fichier
- passage de l'image en couleur à l'image en niveau de gris
- l'image modifiée est stockée en mémoire dasn image1
- fermeture du fichier

2) deuxième lecture de l'image
- ouverture du fichier
- passage de l'image en niveau de gris
- inversion de l'image : le texte en blanc passe en noir et le texte en noir passe en blanc
- l'image modifiée est stockée en mémoire dans image2
- fermeture du fichier

3) passage dans la fonction treshold : je veux reporter le texte noir lu dans image2 dans image1 un peu comme si j'ajoutais image2 à image1 pour compléter le texte.

Envoyé par souviron34

Et tu copies dans le mauvais sens.. Et tu fais plein d'opérations inutiles, et tu écrases tes résultats... Et tu n'incrémentes pas iptr1.... Bref, beaucoup de travail....

Avec un bon passage de param, ceci devrait marcher....

ET LA CORRECTION DES REMARQUES MISES PLUS HAUT.....

(je n'ai ni testé, ni compilé)

(et je mettrais au moins 10 ou 20 pour le seuil, et non pas 2)...

effectivement j'ai oublié l'incrémentation de iptr1.
j'ai essayé avec un seuil de 20 mais je n'ai toujours pas le résultat escompté.

Invité(e) · 09/12/2008, 09h56

Bonjour,

Envoyé par floopi51

effectivement j'ai oublié l'incrémentation de iptr1.
j'ai essayé avec un seuil de 20 mais je n'ai toujours pas le résultat escompté.

De mon côté, je commence à avoir des résultats avec un seuil au alentour de 0x7fffff.

Quelle est la plage dans laquelle les pixels peuvent prendre leur valeur ?

**floopi51** · 09/12/2008, 10h28

Envoyé par mabu

Bonjour,

De mon côté, je commence à avoir des résultats avec un seuil au alentour de 0x7fffff.

Quelle est la plage dans laquelle les pixels peuvent prendre leur valeur ?

bonjour,
tu es parti avec quel code te quel image ?

Invité(e) · 09/12/2008, 10h46

Le code de ce post.

J'ai modifié la fonction threshold, mais elle fait la même chose que la tienne.
(Avec des itérations sur les deux images).

Code :

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

1
2
3
4
5
6
7
8
9
10
void threshold(int param, int *image1, int *image2)
{
    int end = xs * ys;
    int *end1 = image1 + end;
    int *end2 = image2 + end;
 
    for (;(image1 != end1) && (image2 != end2);++image1, ++image2) {
        *image1 = (*image2 > param) ? 0xffffff : 0;
    }
}

threshold est appelée avec 0x7fffff comme paramètre....

Image de source : 8 bits, éditeur de texte + fenêtre cygwin : du texte sombre sur fond clair, du texte clair sur fond sombre.
Résultat, image binaire, avec le texte bien visible, mais en inversion de contraste.

Pour choisir le seuil automatiquement, il serait malin de faire un histogramme de l'image.

De ton coté

à quoi correspondent les valeurs des pixels ?? Ne faut il pas séparer les trois composantes R G B d'un pixel pour le traiter ?
commence par donner en entrée des images simples avec des grandes zones rouges, vertes, bleus, blanches et noires.

**floopi51** · 09/12/2008, 11h44

Envoyé par mabu

De ton coté

à quoi correspondent les valeurs des pixels ?? Ne faut il pas séparer les trois composantes R G B d'un pixel pour le traiter ?

mon image n'est plus en RGB mais en niveau de gris. Le passage du RGB au niveau de gris est fait dans la fonction read_png avec l'appel à une fonction de la libpng :

Code :

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

   png_set_rgb_to_gray(png_ptr, 1, 54.0/256, 183.0/256);

mais j'ai trouvé le BUG qui me faisait

: il manquait l'incrémentation du pointeur iptr2 sur l'image à modifier

maintenant ça fonctionne.

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
void 
threshold(int param, int* image1, int* image2) {
  int a;
  int *iptr1, *iptr2;
  int val;

  iptr1=image1;
  iptr2=image2;

  for(a=xs*ys; a; a--) {
    val = *iptr1;
    if(val<=param) {
      *iptr2++=0;
    } else {
      *iptr2++;
    }
    iptr1++;
  }
}

voila le code complet légèrement modifié qui fonctionne.
la fonction threshold est devenu add_png et une nouvelle fonction threshold est apparue pour récupérer mon image finale en texte noir sur fond blanc.

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
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
 
#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
#include <stdarg.h>
 
#include <png.h>
 
int *image1, *image2;
int xs,ys;
int force_gamma_1;
 
/*****************************************************************************/
void 
add_png(int param, int* image1, int* image2) {
  int a;
  int *iptr1, *iptr2;
  int val;
 
  iptr1=image1;
  iptr2=image2;
 
  for(a=xs*ys; a; a--) {
    val = *iptr1;
    if(val<=param) {
      *iptr2++=0;
    } else {
      *iptr2++;
    }
    iptr1++;
  }
}
/***************************************************************************/
void 
threshold(int param, int * image) {
  int a;
  int *iptr;
  int val;
 
  iptr=image;
  for(a=0;a<xs*ys;a++) {
    val=*iptr;
    *iptr++=(val>=param)?0xffffff:0;
  }
 
}
 
/*****************************************************************************/
void 
write_png(unsigned char *filename, int *image) {
  unsigned char *temporary;
  unsigned char *tptr;
  int *iptr,a;
  FILE *f;
  png_structp png_ptr;
  png_infop info_ptr;
 
  f = fopen(filename,"w");
  if(!f) {
    fprintf(stderr,"Unable to open file %s.\n",filename);
    exit(1);
  }
 
  temporary=malloc(xs*ys);
  if(!temporary){
    fprintf(stderr,"Out of memory.\n");
    exit(1);
  }
 
  iptr=image;
  tptr=temporary;
 
  for(a=xs*ys; a; a--) {
    *tptr++=(*iptr++)>>16;
  }
 
  png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,NULL,NULL,NULL);
  info_ptr = png_create_info_struct(png_ptr);
  png_init_io(png_ptr,f);
 
  png_set_filter(png_ptr,0,PNG_FILTER_NONE|PNG_FILTER_SUB|PNG_FILTER_UP
		 |PNG_FILTER_AVG|PNG_FILTER_PAETH);
 
  png_set_compression_level(png_ptr,Z_BEST_COMPRESSION);
 
  png_set_IHDR(png_ptr,info_ptr,xs,ys,8,PNG_COLOR_TYPE_GRAY,PNG_INTERLACE_NONE,
	       PNG_COMPRESSION_TYPE_DEFAULT,PNG_FILTER_TYPE_DEFAULT);
 
  png_set_gAMA(png_ptr,info_ptr,1.0);
 
  png_write_info(png_ptr,info_ptr);
 
  tptr=temporary;
  for(a=ys; a; a--) {
    png_write_row(png_ptr,tptr);
    tptr+=xs;
  }
 
  png_write_end(png_ptr,info_ptr);
  png_destroy_write_struct(&png_ptr,&info_ptr);
  free(temporary);
  fclose(f);
}
 
/*****************************************************************************/
void 
read_png(FILE *f, png_structp png_ptr, png_infop info_ptr, 
	 int *image, int invertMode) {
  unsigned char *temporary_array;
  png_color_16p* background;
  double gamma;
  int y1,number_of_passes;
  unsigned char **ptrs;
 
  if (png_get_gAMA(png_ptr,info_ptr, &gamma)) {
    if (force_gamma_1) {
      png_set_gamma(png_ptr, 1.0, 1.0);
    /* Forcing gamma is here for repairing files after processing
     * with GIMP, which deliberately writes gamma=00 00 b1 8f
     * even when input gamma was 00 01 86 a0 and no gamma setting
     * change is performed by user (simply saind, GIMP is
     * braindead)
     */
    } else {
      png_set_gamma(png_ptr, 1.0, gamma);
    }
  } else {
    png_set_gamma(png_ptr, 1.0, 0.454545);
  }
 
  {
    int bit_depth;
    int color_type;
 
    color_type = png_get_color_type(png_ptr, info_ptr);
    bit_depth = png_get_bit_depth(png_ptr, info_ptr);
 
    if (color_type==PNG_COLOR_TYPE_GRAY) {
      if (bit_depth<8) {
	png_set_expand(png_ptr);
      }
      if (bit_depth==16) {
	png_set_strip_16(png_ptr);
      }
    }
 
    if (color_type==PNG_COLOR_TYPE_PALETTE){
      png_set_expand(png_ptr);
      /*png_set_rgb_to_gray(png_ptr,1,54.0/256,183.0/256);*/
      png_set_rgb_to_gray(png_ptr, 1, 0, 100000);
    }
 
    if (color_type & PNG_COLOR_MASK_ALPHA){
      png_set_strip_alpha(png_ptr);
    }
    if (color_type==PNG_COLOR_TYPE_RGB ||
	color_type==PNG_COLOR_TYPE_RGB_ALPHA){
      png_set_rgb_to_gray(png_ptr, 1, 54.0/256, 183.0/256);
      /*png_set_rgb_to_gray(png_ptr, 1, 0, 100000);*/
    }
 
  }
 
  if(invertMode == 1) {
    png_set_invert_mono(png_ptr);
  }
 
  /* If the depth is different from 8 bits/gray, make the libpng expand
   * it to 8 bit gray.
   */
  number_of_passes = png_set_interlace_handling(png_ptr);
  png_read_update_info(png_ptr,info_ptr);
 
  temporary_array = malloc(xs*ys);
  ptrs = malloc(ys*sizeof(*ptrs));
 
  for(y1=0;y1<ys;y1++) {
    ptrs[y1]=temporary_array+xs*y1;
  }
  for(;number_of_passes;number_of_passes--) {
    png_read_rows(png_ptr, ptrs, NULL, ys);
  }
 
  png_read_end(png_ptr, NULL);
 
  {
    int *imptr=image;
    unsigned char *tptr=temporary_array;
    int a;
 
    for (y1=ys*xs;y1;y1--) {
      a=*tptr++;
      a=a|(a<<8)|(a<<16);
      *imptr++=a;
    }
  }
  free(ptrs);
  free(temporary_array);
}
 
/*****************************************************************************/
int
main (int argc, char *argv[]) {
  FILE *f1, *f2;
  png_structp png_p1, png_p2;
  png_infop info_p1, info_p2;
 
  if(argc < 2) {
    fprintf (stderr, "usage: %s filename.png fileout.png\n", argv[0]);
    return -1;
  }
 
  /* 1ère lecture de l'image :
   * on traite l'image pour récupérer le texte en noir */
  f1 = fopen(argv[1],"r");
  if(f1 == NULL) {
    fprintf(stderr,"impossible d'ouvrir %s\n",argv[1]);
    exit(1);
  }
  png_p1 = png_create_read_struct(PNG_LIBPNG_VER_STRING,
				   NULL, NULL, NULL);
  info_p1 = png_create_info_struct(png_p1);
  png_init_io(png_p1,f1);
  png_read_info(png_p1, info_p1);
 
  xs = png_get_image_width(png_p1,info_p1);
  ys = png_get_image_height(png_p1,info_p1);
 
  image1 = malloc(xs*ys*sizeof(image1));
  /* on lit l'image, les pixels sont stockées dans image1 */
  /* revertMode = 0 : l'image n'est pas inversée
   */
  read_png(f1, png_p1, info_p1, image1, 0);
  png_destroy_read_struct(&png_p1, &info_p1, NULL);
  fclose(f1);
 
  /* 2eme lecture de l'image originale */
  /* on va inverser l'image pour pouvoir recuperer le texte
   * qui est en blanc */
  f2 = fopen(argv[1],"r");
  if(f2 == NULL) {
    fprintf(stderr,"impossible d'ouvrir %s\n",argv[1]);
    if(image1 != NULL) free(image1);
     exit(1);
  }
  png_p2 = png_create_read_struct(PNG_LIBPNG_VER_STRING,
				   NULL, NULL, NULL);
  info_p2 = png_create_info_struct(png_p2);
  png_init_io(png_p2,f2);
  png_read_info(png_p2, info_p2);
 
  image2 = malloc(xs*ys*sizeof(image2));
   /* on lit l'image, les pixels sont stockées dans image2 */
  /* revertMode = 1 : l'image est inversée
   * inversée = pixel noir ==> blanc && pixel blanc ==>noir
   */
  read_png(f2, png_p2, info_p2, image2, 1);
  png_destroy_read_struct(&png_p2, &info_p2, NULL);
  fclose(f2);
 
  write_png("img1.png",image1);
  write_png("img2.png",image2);
 
  /* traitement parallèle des 2 images
   * on lit image2 et on modifie image1 quand on a des pixels noirs
   * pour les reporter dans image1
   */
  add_png(20, image1, image2);
 
  /* threshold pour avoir image ne noir et blanc */
  threshold(20, image2);
 
  /* ecriture du fichier final */
  write_png(argv[2], image2);
 
  if(image1 != NULL) free(image1);
  if(image2 != NULL) free(image2);
 
  return 0;
}

merci à tous pour votre aide.

maintenant, je dois supprimer les lignes horizontales et verticales autre que du texte pour ensuite traiter mon image par OCR.....
au boulot sur la transformée de Hough.....

analyse d'une image

Traitement d'images

Discussions similaires

Partager

Partager