IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C Discussion :

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


Sujet :

C

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Inscrit en
    Mars 2009
    Messages
    21
    Détails du profil
    Informations forums :
    Inscription : Mars 2009
    Messages : 21
    Par défaut 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.

  2. #2
    Expert confirmé

    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    10 610
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 610
    Billets dans le blog
    2
    Par défaut
    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).

  3. #3
    Membre éprouvé
    Profil pro
    Inscrit en
    Avril 2009
    Messages
    153
    Détails du profil
    Informations personnelles :
    Âge : 37
    Localisation : France, Nord (Nord Pas de Calais)

    Informations forums :
    Inscription : Avril 2009
    Messages : 153
    Par défaut
    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.

  4. #4
    Membre averti
    Inscrit en
    Mars 2009
    Messages
    21
    Détails du profil
    Informations forums :
    Inscription : Mars 2009
    Messages : 21
    Par défaut
    Citation Envoyé par BSans Voir le message
    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.

  5. #5
    Membre éprouvé
    Profil pro
    Inscrit en
    Avril 2009
    Messages
    153
    Détails du profil
    Informations personnelles :
    Âge : 37
    Localisation : France, Nord (Nord Pas de Calais)

    Informations forums :
    Inscription : Avril 2009
    Messages : 153
    Par défaut
    Voici l'ensemble du code.

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

    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 : 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
     
    #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;
    }

  6. #6
    Membre averti
    Inscrit en
    Mars 2009
    Messages
    21
    Détails du profil
    Informations forums :
    Inscription : Mars 2009
    Messages : 21
    Par défaut
    Merci pour le code BSans, je vais voir ça

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [Image] Décomposer une image de grande taille
    Par Pierre.M dans le forum 2D
    Réponses: 2
    Dernier message: 22/08/2008, 13h14
  2. Réponses: 10
    Dernier message: 23/02/2008, 19h01
  3. Réponses: 5
    Dernier message: 11/08/2006, 10h29
  4. diviser une image en plusieurs liens
    Par mat-tech dans le forum Balisage (X)HTML et validation W3C
    Réponses: 3
    Dernier message: 27/04/2006, 16h10
  5. [Image] Décomposer une image png.
    Par Quintoff dans le forum 2D
    Réponses: 3
    Dernier message: 06/01/2006, 20h22

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo