Décomposer une image en plusieurs matrices de 8*8

Bonjour,
J'aimerai savoir si quelqu'un connais un lib ou quelque chose en C qui me permet de décomposer une image bmp en matrices (bloks) de 8*8 afin d'appliquer des modifications sur chaque blok.
Merci.

d'abord bloc est un mot français, pas viking ou je ne sais pas quoi. C'est donc avec un C et non un k.

Ensuite peut-être, mais le principe est plus général. Découper un rectangle (une matrice) en bloc de n*m points.

Enfin, il y a des packages de manipulation d'images, mais en général cela prend des buffers en entrée. La lecture des formats est un à-côté. Il faut cherche un code sur le Web, ou bien le faire à la main (avec bmp c'est pas trop compliqué, il suffit de cherche la spec du format).

Je dois encore avoir un bout de code traitant les bmp dans un coin.

J'essaierai de penser à regarder ça ce soir.

Mais d'après mes souvenirs, c'est pas très compliqué.

Il suffit de définir une structure correspondant aux standards bmp (trouvable sur internet), puis lire ton fichier en suivant ces standards pour remplir ta structure.

Citation:

Envoyé par BSans

Je dois encore avoir un bout de code traitant les bmp dans un coin.
J'essaierai de penser à regarder ça ce soir.

Merci, ça m'aidera beaucoup.

Voici l'ensemble du code.

À l'époque j'étais "jeune" et j'aimais pas le C :D

Donc le code est peut être pas terrible, mais les principes sont compréhensibles je pense.
Cependant, si tu as des questions n'hésite pas.

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
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
 
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<string.h>
 
typedef struct {
  unsigned short signature;
  unsigned int taille_fichier;
  unsigned int reserve;
  unsigned int offset_donnees;
} entete_fichier;
 
typedef struct {
  unsigned int taille_entete;
  unsigned int largeur;
  unsigned int hauteur;
  unsigned short nombre_plans;
  unsigned short profondeur;
  unsigned int compression;
  unsigned int taille_donnees_image;
  int resolution_horizontale;
  int resolution_verticale;
  unsigned int taille_palette; /* en nombre de couleurs */
  unsigned int nombre_de_couleurs_importantes; /* 0 */
} entete_bitmap;
 
typedef struct {
  entete_fichier fichier;
  entete_bitmap bitmap;
} entete_bmp;
 
int error(char* err) {
  printf("Erreur : %s.\n",err);
  exit(1);
  return 1;
}
 
unsigned int lire_4_octets(int de) {
  unsigned int r=0;
  int test;
  test = read(de,&r,sizeof(int));
  if (test == -1) {
    error("lecture");
  }
  return r;
}
 
unsigned short lire_2_octets(int de) {
  unsigned int r=0;
  int test;
  test = read(de,&r,sizeof(short));
  if (test == -1) {
    error("Lecture");
  }
  return r;
}
 
int lire_entete(int de, entete_bmp *entete) {
  entete->fichier.signature=lire_2_octets(de);
  entete->fichier.taille_fichier=lire_4_octets(de);
  entete->fichier.reserve=lire_4_octets(de);
  entete->fichier.offset_donnees=lire_4_octets(de);
 
  entete->bitmap.taille_entete=lire_4_octets(de);
  entete->bitmap.largeur=lire_4_octets(de);
  entete->bitmap.hauteur=lire_4_octets(de);
  entete->bitmap.nombre_plans=lire_2_octets(de);
  entete->bitmap.profondeur=lire_2_octets(de);
  entete->bitmap.compression=lire_4_octets(de);
  entete->bitmap.taille_donnees_image=lire_4_octets(de);
  entete->bitmap.resolution_horizontale=lire_4_octets(de);
  entete->bitmap.resolution_verticale=lire_4_octets(de);
  entete->bitmap.taille_palette=lire_4_octets(de);
  entete->bitmap.nombre_de_couleurs_importantes=lire_4_octets(de);
  return 0;
}
 
int ecrire_4_octets(int vers, unsigned int valeur) {
  int test = write(vers,&valeur,sizeof(int));
  if (test == -1) {
    error("Ecriture 4 octets");
  }
  return 0;
}
 
int ecrire_2_octets(int vers, unsigned short valeur) {
  int test = write(vers,&valeur,sizeof(short));
  if (test == -1) {
    error("Ecriture 2 octets");
  }
  return 0;
}
 
int ecrire_entete(int vers, entete_bmp *entete) {
  ecrire_2_octets(vers,entete->fichier.signature);
  ecrire_4_octets(vers,entete->fichier.taille_fichier);
  ecrire_4_octets(vers,entete->fichier.reserve);
  ecrire_4_octets(vers,entete->fichier.offset_donnees);
 
  ecrire_4_octets(vers,entete->bitmap.taille_entete);
  ecrire_4_octets(vers,entete->bitmap.largeur);
  ecrire_4_octets(vers,entete->bitmap.hauteur);
  ecrire_2_octets(vers,entete->bitmap.nombre_plans);
  ecrire_2_octets(vers,entete->bitmap.profondeur);
  ecrire_4_octets(vers,entete->bitmap.compression);
  ecrire_4_octets(vers,entete->bitmap.taille_donnees_image);
  ecrire_4_octets(vers,(unsigned int)entete->bitmap.resolution_horizontale);
  ecrire_4_octets(vers,(unsigned int)entete->bitmap.resolution_verticale);
  ecrire_4_octets(vers,entete->bitmap.taille_palette);
  ecrire_4_octets(vers,entete->bitmap.nombre_de_couleurs_importantes);
 
  return 0;
}
 
int verifier_entete(entete_bmp *entete) {
  if (entete->bitmap.profondeur!=24) {
    error("Mauvaise profondeur d'image");
    return 1;
  }
  return 0;
}
 
unsigned char* allouer_pixels(entete_bmp *entete) {
  unsigned char* r;
  r = (unsigned char*) malloc(entete->bitmap.taille_donnees_image*sizeof(int));
  return r;
}
 
int lire_pixels(int de, entete_bmp *entete, unsigned char *pixels) {
  read(de,pixels,entete->bitmap.taille_donnees_image*sizeof(int));
  return 0;
}
 
int ecrire_pixels(int vers, entete_bmp *entete, unsigned char *pixels) {
  write(vers, pixels,entete->bitmap.taille_donnees_image*sizeof(int));
  return 0;
}
 
int copier_bmp(int de, int vers) {
  entete_bmp entete;
  unsigned char *pixels;
 
  /* lecture du fichier source */
  lire_entete(de, &entete);
  pixels = allouer_pixels(&entete);
  lire_pixels(de, &entete, pixels);
  verifier_entete(&entete);
 
  /* écriture du fichier destination */
  ecrire_entete(vers, &entete);
  ecrire_pixels(vers, &entete, pixels);
 
  /* on libère les pixels */
  free(pixels);
  return 1; /* on a réussi */
}
 
void rouge(entete_bmp *entete, unsigned char *pixels) {
	int j;
	for (j=0; j<(int)(entete->bitmap.taille_donnees_image*sizeof(int)); j+=3) {
		*(pixels+j)=0;
		*(pixels+(j+1))=0;
	}
}
 
void neg(entete_bmp *entete, unsigned char *pixels) {
	int j;
	for (j=0; j<(int)(entete->bitmap.taille_donnees_image*sizeof(int)); j++) {
		pixels[j]=~(pixels[j]);
	}
}
 
void noir_et_blanc(entete_bmp *entete, unsigned char *pixels) {
	int j;
	int tmp;
	for (j=0; j<(int)((entete->bitmap.taille_donnees_image)*sizeof(int)-3); j+=3) {
		tmp = pixels[j]+pixels[j+1]+pixels[j+2];
		*(pixels+j)=tmp/3;
		*(pixels+(j+1))=tmp/3;
		*(pixels+(j+2))=tmp/3;
	}
}
 
void moitie(entete_bmp *entete, unsigned char *pixels, int sup) {
	int i=0;
	if (sup==1) {
		entete->bitmap.hauteur /=2;
	} else {
		for (;i<entete->bitmap.taille_donnees_image/2;i++) {
			pixels[i]=pixels[i+entete->bitmap.taille_donnees_image/2];
		}
		entete->bitmap.hauteur /=2;
	}
}
 
int main(int argc, char* argv[]) {
  entete_bmp entete;
  unsigned char *pixels;
  int ouvert= open("img/test24.bmp",O_RDONLY);
  int ouvert2, i=1, j=1;
  ouvert2 = open("test.bmp",O_CREAT|O_WRONLY,0777);
  if (ouvert == -1) {
    error("Lecture test24.bmp");
  }
  if (ouvert2 == -1) {
    error("Ecriture test.bmp");
  }
  if (argc<2) {
    copier_bmp(ouvert,ouvert2);
  } else {
	lire_entete(ouvert, &entete);
	verifier_entete(&entete);
	pixels = allouer_pixels(&entete);
	lire_pixels(ouvert, &entete, pixels);
	while (i<argc) {
		if (*argv[i]!='-') {
			error(argv[i]);
		}
		while (j<(int)(strlen(argv[i]))) {
			if(*(argv[i]+j)=='r') {
				rouge(&entete,pixels);
			} else if (*(argv[i]+j)=='n') {
				neg(&entete,pixels);
			} else if (*(argv[i]+j)=='b') {
				noir_et_blanc(&entete,pixels);
			} else if (*(argv[i]+j)=='i') {
				moitie(&entete,pixels,1);
			} else if (*(argv[i]+j)=='s') {
				moitie(&entete,pixels,2);
			} else {
				error(argv[i]);
			}
			j++;
		}
		j=1;
		i++;
	}
	ecrire_entete(ouvert2, &entete);
	ecrire_pixels(ouvert2, &entete, pixels);
	/* on libère les pixels */
	free(pixels);
  }
  close(ouvert);
  close(ouvert2);
  return 0;
}

Merci pour le code BSans, je vais voir ça :D