probleme : compression d'image (pgm)

**Micks71** · 05/05/2006, 10h11

Bonjour,
Ca fait plusieur jour que je bloque sur ce probleme j'avance mais mal...
en fait le but et d'arriver a compresser une image par la methode d'un arbre a 4 branche...
mon algo de parcourt est bon, mais je vois pas trop comment utiliser les fonction contenu dans fbit.c donné plus bas, il doit y avoir plusieur chose qui m'echappe, j'arrive a recrée l'image qui est compresser mais je travail sur l'image mais pas comme il faut...

Fbit :

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
typedef struct {
   unsigned char tampon;
   char * mode;
   int offset;
   FILE * fid;
} FBitBuffer;
 
FBitBuffer * fopen_bits(char * fichier, char * mode);
void fclose_bits(FBitBuffer * buffer);
void fwrite_bits(int val,int nbits,FBitBuffer* buffer);
int fread_bits(int nbits,FBitBuffer* buffer);
 
FBitBuffer * fopen_bits(char * fichier,char * mode) {
  FBitBuffer * buffer;
  buffer = (FBitBuffer*) malloc(sizeof(FBitBuffer));
  buffer->tampon = 0;
  buffer->offset=0;
  buffer->fid = fopen(fichier,mode);
  if (!buffer->fid) {
     free(buffer);
     return NULL;
  }
  buffer->mode = (char*) malloc(strlen(mode)+1);
  strcpy(buffer->mode,mode);
  return buffer;
}
 
void fclose_bits(FBitBuffer * buffer) {
   if (!strcmp(buffer->mode,"w") && buffer->offset) {
      fwrite(&(buffer->tampon),1,1,buffer->fid);
   }
   fclose(buffer->fid);
   free(buffer->mode);
   free(buffer);
}
 
void fwrite_bits(int val,int nbits,FBitBuffer* buffer) {
   int reste;
   if (buffer->offset+nbits<8) {
      buffer->tampon += (val)<<(buffer->offset);
      buffer->offset+=nbits;
   }
   else
   {
      reste = (val)>>(8-buffer->offset);
      buffer->tampon += ((val)&((1<<(8-buffer->offset))-1))<<(buffer->offset);
      fwrite(&(buffer->tampon),1,1,buffer->fid);
      nbits -= (8-buffer->offset);
      buffer->tampon = 0;
      buffer->offset = 0;
      fwrite_bits(reste,nbits,buffer);
   }
}
 
int fread_bits(int nbits,FBitBuffer* buffer) {
   int reste,sup;
   int bitslus;
   int resultat;
   if (nbits==0) {
      return 0;
   }
   if (buffer->offset==0) {
      fread(&(buffer->tampon),1,1,buffer->fid);
   }
   if (buffer->offset+nbits<8) {
      resultat =  (buffer->tampon>>buffer->offset)&((1<<nbits)-1);
      buffer->offset+=nbits;
      return resultat;
   }
   else
   {
      reste = (buffer->tampon>>buffer->offset)&((1<<(8-buffer->offset))-1);
      nbits -= (8-buffer->offset);
      bitslus = (8-buffer->offset);
      buffer->tampon = 0;
      buffer->offset = 0;
      sup = fread_bits(nbits,buffer)<<bitslus;
      return reste+sup;
   }
}

une partie de pgm.c :

Code :

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

1
2
3
4
5
6
7
8
typedef struct {
   int hauteur;
   int largeur;
   unsigned char * pixels;
} Image;
 
int pgm_image_write(Image * image,char * fichier,int bin);
Image * pgm_image_read(char * fichier);

mon programme principal ou j'ai essayer d'utiliser les buffer mais sans resultat :

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
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "pgm.h"
#include "fbit.h"
#define SEUIL 10
 
typedef struct 
{
	int x1;int y1; 
	int x2;int y2;
	float moyenne;
	double variance;
}Bloc;
 
typedef struct quad
{
Bloc bloc;
struct quad * premier;
struct quad * deuxieme;
struct quad * troisieme;
struct quad * quatrieme;
} Quadtree;
 
Quadtree * coder(Image * img,Quadtree * arbre,FBitBuffer * flux);
void decoder(Quadtree * arbre,FBitBuffer * flux);
 
int main (void)
{
    int choix;
    int val;
    FBitBuffer * flux;
    Image * img;
    Quadtree * arbre;
                 img=pgm_image_read("./peppers.pgm");
          	     flux=fopen_bits("quad.quad","w");
                 fwrite_bits(img->hauteur, 8, flux);
                 fwrite_bits(img->largeur, 8, flux);
                 arbre=(Quadtree*) malloc(sizeof(Quadtree)); 
                 arbre->bloc.x1=0;arbre->bloc.y1=0;
	             arbre->bloc.x2=img->largeur;arbre->bloc.y2=img->hauteur;
	             arbre->bloc.moyenne=0;arbre->bloc.variance=0;	
//               fid=fopen("z.quad","w"); 
                 arbre=coder(img,arbre,flux);
                 decoder(arbre,flux);
//               val=pgm_image_write(img,"./coder2.pgm",0);
  				 pgm_image_write(img, "test.pgm", 0);
	 			 fclose_bits(flux); 
    }         
return (0);
}                       
 
Quadtree * coder(Image * img,Quadtree * arbre,FBitBuffer * flux)
{
    int x1,y1,x2,y2,i,j,largeur,hauteur,tmp,compteur;
    float tmp1x2,tmp1y2,tmp2x1,tmp2y2,moy;
    compteur=0;moy=0;
    x1=arbre->bloc.x1;
    y1=arbre->bloc.y1;
    x2=arbre->bloc.x2;
    y2=arbre->bloc.y2;
    arbre->bloc.moyenne=0;
    arbre->bloc.variance=0;         
    largeur=x2-x1;
    hauteur=y2-y1;
//    printf("x1 : %d y1 : %d x2 %d y2 %d largeur %d hauteur %d\n",x1,y1,x2,y2,largeur,hauteur);   
    //initialisation de la moyenne
         for (i=y1;i<y2;i++)
	     {
	      	for(j=x1;j<x2;j++)
		    {  
		    	moy=(float)(moy+(img->pixels[j+i*(img->largeur)]));
//		     	printf("%d [j+i*(img->largeur)] %d cpt: %d i: %d j: %d  moy %.2f\n",j+i*(img->largeur),(img->pixels[j+i*(img->largeur)]),compteur,i,j,moy);
		      	compteur++;
            }
         }
 
      moy=((float)(moy/((largeur)*(hauteur))));
      (arbre->bloc.moyenne)=moy;
      printf("bloc moy : %f \n",(arbre->bloc.moyenne));	
      //initialisation de la variance
	  for (i=y1;i<y2;i++)
	  {
		for(j=x1;j<x2;j++)
		{
            arbre->bloc.variance=(float)((img->pixels[j+i*(img->largeur)]-arbre->bloc.moyenne)*(img->pixels[j+i*(img->largeur)]-arbre->bloc.moyenne)+arbre->bloc.variance);
		}
	  }
     arbre->bloc.variance=(float)sqrt(arbre->bloc.variance/((float)(largeur)*(float)(hauteur)));
    printf("variance : %f, diviseur var %d, SEUIL %d \n",arbre->bloc.variance,(largeur*hauteur),SEUIL);
    if (arbre->bloc.variance>SEUIL)
    {
        puts("test 1er");
        fread_bits(16,flux);
        arbre->premier=(Quadtree*) malloc(sizeof(Quadtree)); 
        arbre->premier->bloc.x1=arbre->bloc.x1;
        arbre->premier->bloc.y1=arbre->bloc.y1;
        tmp1x2=((float)((arbre->bloc.x1)+(arbre->bloc.x2))/2.0);
        tmp=(((arbre->bloc.x1)+(arbre->bloc.x2))/2);
        tmp1x2=(tmp1x2-(float)tmp);
//        printf("in 1er arbre->premier->bloc.x1=%d  arbre->bloc.x2=%d\n",(arbre->premier->bloc.x1),(arbre->bloc.x2));
//        printf("in 1er arbre->premier->bloc.y1=%d  arbre->bloc.y2=%d\n",(arbre->premier->bloc.y1),(arbre->bloc.y2));
//        printf("test ! tmp : %d et tmp1x2 : %.1f\n",tmp,tmp1x2);
            tmp1x2=tmp;
//            printf("tmp1x2 : %f tmp2x1 : %f \n",tmp1x2,tmp2x1);
        arbre->premier->bloc.x2=(int)(tmp1x2);
        tmp1y2=((float)(((arbre->bloc.y1)+(arbre->bloc.y2))/2.0));
//        printf("1test ! tmp : %d et tmp1y2 : %.1f  y1:%d y2:%d\n",tmp,tmp1y2,arbre->bloc.y1,arbre->bloc.y2);       
        tmp=((((arbre->bloc.y1)+(arbre->bloc.y2))/2.0));
//        printf("2test ! tmp : %d et tmp1y2 : %.1f  y1:%d y2:%d\n",tmp,tmp1y2,arbre->bloc.y1,arbre->bloc.y2);       
        tmp1y2=(tmp1y2-(float)tmp);
//        printf("3test ! tmp : %d et tmp1y2 : %.1f  y1:%d y2:%d\n",tmp,tmp1y2,arbre->bloc.y1,arbre->bloc.y2);        
            tmp1y2=tmp;
//            printf("tmp1y2 : %f tmp2y2 : %f \n",tmp1y2,tmp2y2); 
        arbre->premier->bloc.y2=(int)(tmp1y2);
        coder(img,(arbre->premier),flux);
        puts("test 2eme");
        arbre->deuxieme=(Quadtree*) malloc(sizeof(Quadtree)); 
        arbre->deuxieme->bloc.x1=(int)(tmp1x2);
        arbre->deuxieme->bloc.y1=arbre->bloc.y1;
        arbre->deuxieme->bloc.x2=arbre->bloc.x2;
        arbre->deuxieme->bloc.y2=(int)(tmp1y2);
        coder(img,(arbre->deuxieme),flux);
        puts("test 3eme");
        arbre->troisieme=(Quadtree*) malloc(sizeof(Quadtree)); 
        arbre->troisieme->bloc.x1=arbre->bloc.x1;
        arbre->troisieme->bloc.y1=(int)(tmp1y2);
        arbre->troisieme->bloc.x2=(int)(tmp1x2);
        arbre->troisieme->bloc.y2=arbre->bloc.y2;
        coder(img,(arbre->troisieme),flux);
        puts("test 4eme");
        arbre->quatrieme=(Quadtree*) malloc(sizeof(Quadtree)); 
        arbre->quatrieme->bloc.x1=(int)(tmp1x2);
        arbre->quatrieme->bloc.y1=(int)(tmp1y2);
        arbre->quatrieme->bloc.x2=arbre->bloc.x2;
        arbre->quatrieme->bloc.y2=arbre->bloc.y2;
        coder(img,(arbre->quatrieme),flux);               
    }
    else
    {
 
/*         puts("in else");
         for(i=y1;i<y2;i++)
         {
            for(j=x1;j<x2;j++)
            {
                 codage sur 16 bits
                 pointeur pas null -> 0
                 1 arrivé a une feuille, et recuperer la moyenne
                 img->pixels[j+i*(img->largeur)]=arbre->bloc.moyenne; 
                 printf("W j+i*(img->largeur) %d\n",j+i*(img->largeur));
            }
         }*/
    }
 
return(arbre);
}
 
void decoder(Quadtree * arbre,FBitBuffer * flux)
{
   puts("decoder");
   //    FREADBITS 16bits
   //    lire les 16 premiers bits
   //    cree une structure image avec un tableau de pixel
 if (arbre!=NULL)
 {
	if (arbre->premier=NULL)
	{                       
		fwrite_bits(0,1,flux);
		fwrite_bits(arbre->bloc.moyenne,8,flux);
    }
	else
	{
        fwrite_bits(1, 1, flux);
        decoder(arbre->premier,flux);
        decoder(arbre->deuxieme,flux);
        decoder(arbre->troisieme,flux);
        decoder(arbre->quatrieme,flux);
	}
 }
}

Désolé pour la place que ca prend ^^;
Merci d'avance pour votre aide

**larnicebafteur** · 05/05/2006, 10h13

Avec un code aussi long, peu lisible et sans commentaires, je doute que tu recoives beaucoup de réponses ...

Il faudrait essayer de cibler un peu plus le problème.

**GyZmoO** · 05/05/2006, 12h05

Salut !

il doit y avoir plusieur chose qui m'echappe

Quoi exactement?? Parce que la c'est chaud de voir direct le soucis

et puis essaye d'éditer ton code pour rajouter les balises CODE/CODE et puis aussi indenter ton code parce que la ...

Bon courage !

**Micks71** · 05/05/2006, 12h32

c'est pas simple je me perd déjà dans ce que j'ai fait ^^;
en fait ce que je comprend c'est l'histoire de codage avec fbit... ce qui est dans fbit.c
le but est de decomposer une image en 4, si la variance des pixels est supperieur au seuil on redevise en 4 jusqu'a ce que la variance soit acceptable, et en fait ca crée un arbre a ce que je comprend
apres il faut reconstitué l'image avec l'arbre et avec les fonction dans fbit mais je sais aps si je m'y prend bien...

merci quand meme ^^

edit: j'ai recommencer mon programme plus clairement avec des aide de mon professeur voila et merci ^^

probleme : compression d'image (pgm)

C

Vue hybride

Discussions similaires

Partager

Partager