Re Redimensionnement

Re Redimensionnement - C - Programmation

Marsh Posté le 14-03-2011 à 15:32:17    

Voila mon code actuelle qui devrait me permetre de modifier une image dicom pour passer d'une taille de 128*128 en 512*512 mais je retrouve mon image d'origine inchangé
 

Code :
  1. /* Inclusions des bibliothèques contenant les prototypes des fonctions standard de C */
  2. #include <stdio.h>
  3. #include <stdlib.h>
  5. /* Définition de constantes globales */
  6. #define MOT 2                                                       /* nombre d'octet dans un mot */
  8. /* Définition des prototypes des fonctions ou sous-programmes codés par l'utilisateur : informe le compilateur de la syntaxe attendue pour ce sous-programme  */
  10. void lecture_ecriture_image(short int *image, int cote, char *nom1, char *nom2, int option);
  11. /* si option vaut 0, lit sur le disque l'image dicom nommée nom1 puis stocke en mémoire les cote² valeurs des pixels à partir du pointeur image*/
  12. /* si option vaut 1, écrit sur le disque une image dicom nommée nom2 contenant l'entete du fichier nom1 puis les cote² valeurs des pixels stockés à partir du pointeur image */
  13. void message(char *information);                                    /* renvoie à l'écran un message */
  16. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  17. /*                                                                  Programme principal                                                        */
  18. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  20. int main()                                   /* Programme principal */
  21.      {
  22.      int i,j,ki, kj;                         /* variable entières signées: indices de boucles */
  23.      int cote;                               /* taille de l'image en pixels par cote */
  24.      char nom[256], nom1[256], nom2[256];    /* chaines de caractères via pointeurs sur les noms des fichiers images lus sans entete, avec entete dicom et écrits en sortie */
  25.      char information[2048];                 /* message à afficher a l'utilisateur */
  26.      short int *image;
  27.      short int *image2 ;                    /* pointeur sur les valeurs de pixels contenues dans le fichier image dicom, sur 2 octets */
  28.   short int *tampon ;                     /* pointeur sur les pixels de l'image en cours de filtrage, codes sur 1 mot */
  31. /**************************************************************************************************************************************************/   
  33. /* Ouverture du fichier contenant l’image */
  34.    
  35.     printf("\nEntrez le nom du fichier image dicom a ouvrir : " );                                                  /* affiche un texte à l'écran, pour information */
  36.     scanf("%s",nom);                                                                                               /* affecte la chaine de caractères tapée au pointeur nom */
  37.     sprintf(nom1,"%s.dcm",nom);                                                                                    /* concatène nom et .dcm dans nom1*/
  39.     printf("\nEntrez la taille de cette image (nombre de pixels par cote) : " );
  40.     scanf("%d",&cote);                                                                                             /* affecte le nombre entier entré à l'adresse pointée par &cote*/
  42. /* Affectation de la mémoire vive nécessaire au stockage des pixels de l'image */   
  43.    
  44.     image = malloc(cote*cote*sizeof(short int)) ;                                                                /* Allocation de taille_dicom mots de 2 octets à partir de *dicom */
  45.  if(image==NULL)
  46.              {
  47.              sprintf(information, "Erreur : Allocation du fichier dicom impossible lors de sa lecture\n" );
  48.              message(information);
  49.              }           
  50.  
  51.    
  52. /* Lecture de l'image dicom sur le disque dur et affectation des valeurs des pixels au pointeur image */     
  53.    
  54.     lecture_ecriture_image(image,cote,nom1,nom1,0);
  56. /* Ecriture sur le disque d'une image dicom contenant l'entete du fichier nom1 puis les cote² valeurs des pixels stockés à partir du pointeur image sur 2 octets */
  57.      
  58.     sprintf(nom2,"%s-filtre.dcm",nom);                                                                                 /* nom du fichier en sortie */
  59.     lecture_ecriture_image(image,cote,nom1,nom2,1);
  61. /* libération de mémoire */
  62.     free(image);
  63.    
  64.     sprintf(information,"\nLe fichier %s a ete ecrit dans le repertoire courant avec succes.\nFin du programme (tapez sur une touche pour fermer)\n",nom2);
  65.     message(information);
  66. }
  67. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  68. /*                               A partir d'ici, nous définissons les fonctions et programmes utilisées dans le programme princupal           */
  69. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  71. void lecture_ecriture_image(short int *image, int cote, char *nom1, char *nom2, int option)
  72.      {
  73.  FILE *fichier ;                         /* structure identifiant un fichier */
  74.   short int *dicom ;                      /* pointeur sur le fichier image dicom complet, avec ses entetes, sur 2 octets : ces données ne seront connues que dans cette fonction*/
  75.      int taille;                             /* taille du fichier image dicom */
  76.      int entete;                             /* entier contenant le nombre de mots dans l'entete dicom */
  77.      int i,j,l,c;                                /* entiers servant à balayer les pixels de l'image suivant lignes et colonnes */
  78.      char information[2048];                 /* message à afficher a l'utilisateur */
  79.    
  80. /* Définition d'un pointeur sur le fichier présent dans le disque dur */   
  81.              
  82.      fichier=fopen(nom1,"rb" ) ;                                                                                     /* ouvre le fichier nom1 sur le disque en lecture */
  83.  if(fichier==NULL)                                                                                              /* avertissement et sortie en cas de lecture impossible */
  84.              {
  85.              sprintf(information, "Erreur : le fichier %s n'est pas lisible dans le repertoire courant\n",nom1);    /* fabrique la chaine de caractères "message" */
  86.              message(information);                                                                                  /* appel à la fonction qui affiche le message */
  87.              }
  88.            
  89. /* Calcul de la taille du fichier dicom contenant l'image */
  90.            
  91.      fseek(fichier,0,SEEK_END);                          /* Déplacement du pointeur du fichier en fin de fichier */
  92.      taille = ftell(fichier);                            /* La fonction ftell renvoie la position courante en octet du pointeur de fichier */
  93.                                                          /* par rapport au début du fichier, donc ici la taille du fichier */
  94.      taille/=MOT;                                        /* calcul de la taille du fichier dicom en mots de 2 octets */
  95.        
  96. /* Calcul de la taille de l'entête unique en début de fichier */
  98.       entete = taille - cote*cote;                       /* calcul de la taille de l'entête du fichier dicom en mots de 2 octets */
  99.      
  100. /* Allocation d’un pointeur sur le fichier image dicom complet */
  102.  dicom = malloc(taille*sizeof(short int)) ;          /* Allocation locale de taille_dicom mots de 2 octets à partir de *dicom */
  103.  if(dicom==NULL)
  104.              {
  105.              sprintf(information, "Erreur : Allocation du fichier dicom impossible lors de sa lecture\n" );
  106.              message(information);
  107.              }           
  108.     fseek(fichier,0,SEEK_SET);                                                                                 /* rembobinage */
  109. fread(dicom,taille,sizeof(short int),fichier) ;                                                            /* affectation de la mémoire vive allouée par lecture de nom1 */
  110. // fclose(fichier) ;                                                                                          /* libération du pointeur de fichier */
  112. short * tampon = (short *)malloc(4*cote*sizeof(short));
  113.     //"l" compteur de ligne//
  114.     for (l=0;l<cote;l++)
  115.     {
  116.         /* decalage de la zone memoire en entree */
  117.         int decalage_entree = entete + l * cote;
  118.         //"c" compteur de colonne//
  119.         for (c=0;c<cote;c++)
  120.         //facteur zoom *4//   
  121.             for (i=0;i<4;i++)
  122.                 tampon[c*4+i] = dicom[decalage_entree+c];
  123.             for (i=0;i<4;i++)
  124.             fwrite(tampon,4*cote,sizeof(short),fichier);
  125.     }
  126.    
  127.     //fread(dicom-entete,taille,sizeof(short int),fichier);
  128.    
  129.         /* puis on écrit sur le disque dur le nouveau fichier dicom produit */
  130.         fichier=fopen(nom2,"wb" ) ;                                                                                 /* pointeur sur le fichier à écrire sur le disque */
  131.     if(fichier==NULL)
  132.          {
  133.              sprintf(information,"Erreur : le fichier %s ne peut pas etre ecrit dans le répertoire courant\n",nom2);
  134.              message(information);
  135.              }
  136.         fseek(fichier,-0,SEEK_SET);                                                                                   /* positionnement en début de fichier */
  137.     fwrite(dicom,4*cote,sizeof(short int),fichier) ;                                                             /* écriture du pointeur dans le fichier nom2 */
  138.     fclose(fichier) ;                                                                                            /* libération du pointeur de fichier */
  139.         }
  140. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  141. void message(char *information)
  142.      {
  143.      printf(information);      /* affiche à l'écran le message d'information */
  144.      getch();                  /* attente d'une frappe clavier pour que l'utilisateur prenne connaissance du probleme */
  145.      exit(1) ;                 /* sort du programme */
  146.      }
  147. /*---------------------------------------------------------------------------------------------------------------------------------------------*/

Reply

Marsh Posté le 14-03-2011 à 15:32:17   

Reply

Marsh Posté le 14-03-2011 à 16:13:17    

Le topic précédent ne te suffisait plus?[:pingouino dei]


---------------
Can't buy what I want because it's free -
Reply

Marsh Posté le 15-03-2011 à 08:44:44    

Disons c'est plus au clair la je pense !
Pour essayer de résoudre le probléme

Reply

Marsh Posté le 15-03-2011 à 11:32:21    

Bon, vu que ton code est clair comme du jus de moule, mais que tu as l'air d'avoir bossé, je vais te donner de quoi t'inspirer:
 

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <stdbool.h>
  4. #include <math.h>
  6. typedef short int PIXEL;
  7. typedef struct {
  8.   int width;
  9.   int length;
  10.   PIXEL *pixmap;
  11. } IMAGE;
  13. /* Lecture ecriture d'une image */
  14. bool lecture_image(char *filename, IMAGE *image);
  15. bool ecriture_image(char *filename, IMAGE image);
  16. /* manipulation de l'image */
  17. IMAGE inflate_image(IMAGE image, int ratiol, int ratiow);
  18. IMAGE inflate_proportional_image(IMAGE image, int ratio);
  19. /* manipulation des pixmaps d'une image */
  20. PIXEL *inflate_pixmap(PIXEL *pixmap, int length, int width, int ratiol, int ratiow);
  21. /* fonction ad hoc pour l'exemple */
  22. static bool getdims(long size, int *length, int *width); 
  24. #define BUFFER_SIZE 256
  25. #define RATIO 4
  27. /* 1) recuperation du nom de fichier
  28.    2) lecture du fichier et creation de l'image en memoire
  29.    3) creation de l'image zoomee  en memoire
  30.    4) ecriture de l'image zoomee
  31. */
  32. int main(int argc, char *argv[])
  33. {
  34.   char buffer[BUFFER_SIZE];
  35.   IMAGE image, inflated;
  36.   int length, width;
  37.   int retcode = EXIT_FAILURE;
  38.    
  39.   printf("\rEntrez le nom du fichier image dicom a ouvrir : " );
  40.   scanf("%s", buffer);
  41.   if (lecture_image(buffer, &image)) {
  42.     inflated = inflate_proportional_image(image, RATIO);
  43.     if (inflated.pixmap) {
  44.       strcat(buffer,"-filtre.dcm" ); 
  45.       if (ecriture_image(buffer, inflated)) {
  46.         retcode = EXIT_SUCCESS;
  47.       }
  48.       free(inflated.pixmap);
  49.     }
  50.     free(image.pixmap);
  51.   }
  52.   return retcode;
  53. }
  55. /* lit un fichier et cree l'image en mémoire */
  56. /* 1) Ouverture du fichier
  57.    2) lecture des infos du header
  58.    3) allocation du pixmap
  59.    4) lecture du pixmap
  60.    5) fermeture du fichier */
  61. bool lecture_image(char *filename, IMAGE *image) {
  62.   FILE *file;
  63.   bool retcode = false;
  65.   file = fopen(filename,"rb" );
  66.   if (!file) {
  67.     fprintf(stderr, "Erreur : le fichier %s n'est pas lisible dans le repertoire courant\n", filename);
  68.   }
  69.   else {
  70.     /* normalement ici, on devrait lire les dimensions dans l'en tête, sauter l'en tête jusqu'a l'image, et lire l'image
  71.        mais bon, comme ton code a une procédure simplifiée, je la suis, et je deduis les dimensions de l'image
  72.        a partir de sa taille. Ca ne paut marcher que pour une image carrée */
  73.     long filesize;
  74.     fseek(file, 0L, SEEK_END);
  75.     filesize = ftell(file);
  76.     filesize /= sizeof(PIXEL);
  77.     if (getdims(filesize, &(image->length), &(image->width))) {
  78.       fseek(file, 0L, SEEK_SET);
  79.       image->pixmap = malloc((image->length) * (image->width) * sizeof(PIXEL));
  80.       if (!image->pixmap) {
  81.         fprintf(stderr, "Erreur : Allocation du fichier image impossible lors de la lecture de %s\n", filename);
  82.       }
  83.       else {
  84.         size_t read = fread(image->pixmap, sizeof(PIXEL), (image->length) * (image->width), file);
  85.         if ((!read) || (read != ((image->length) * (image->width)))) {
  86.           fprintf(stderr, "Erreur : Lecture du fichier %s incorrecte\n", filename);
  87.           free(image->pixmap);
  88.         }
  89.         else {
  90.           retcode = true;
  91.         }
  92.       }
  93.     }
  94.     fclose(file);
  95.   }
  96.   return retcode;
  97. }
  99. /* ecrit une image en memoire dans un fichier */
  100. /* 1) ouverture du fichier
  101.    2) ecriture du header
  102.    3) ecriture du pixmap
  103.    4) fermeture du fichier
  104. */
  105. bool ecriture_image(char *filename, IMAGE image) {
  106.   FILE *file;
  107.   bool retcode = false;
  109.   file = fopen(filename,"wb" );
  110.   if (!file) {
  111.     fprintf(stderr, "Erreur : le fichier %s n'est pas lisible dans le repertoire courant\n", filename);
  112.   }
  113.   else {
  114.     /* normalement ici, on devrait écrire l'en tête de l'image, avec ses dimensions, puis ecrire le pixmap
  115.        mais bon, comme ton code a une procédure simplifiée, on va se contenter d'écrire le pixmap */
  116.     size_t written = fwrite(image.pixmap, sizeof(PIXEL), image.length * image.width, file);
  117.     if ((!written) || (written != (image.length * image.width))) {
  118.       fprintf(stderr, "Erreur : Ecriture du fichier %s incorrecte\n", filename);
  119.     }
  120.     else {
  121.       retcode = true;
  122.     }
  123.     fclose(file);
  124.   }
  125.   return retcode;
  126. }
  128. /* bon, c'est un exemple ou on deduit la taille d'une image carrée */
  129. /* en général, les dimensions se recupèrent dans le header */
  130. /* calcul par la racine carrée et verification que ça tombait juste */
  131. bool getdims(long size, int *length, int *width) {
  132.   bool retcode = true;
  134.   *length = *width = sqrt(size);
  135.   if (size != (*length)*(*width)) {
  136.     fprintf(stderr, "Erreur : calcul de dimension errone\n" ); // pas carre
  137.     *length = *width = 0;
  138.     retcode = false;
  139.   }
  140.   return retcode;
  141. }
  143. /* renvoit une image avec des facteurs de zoom en longueur et largeur */
  144. IMAGE inflate_image(IMAGE image, int ratiol, int ratiow) {
  145.   IMAGE inflated;
  147.   inflated.width  = (image.width)  * ratiow;
  148.   inflated.length = (image.length) * ratiol;
  149.   inflated.pixmap = inflate_pixmap(image.pixmap, image.length, image.width, ratiol, ratiow);
  150.   return inflated;
  151. }
  153. /* renvoit une image avec un unique facteur de zoom */
  154. IMAGE inflate_proportional_image(IMAGE image, int ratio) {
  155.   return inflate_image(image, ratio, ratio);
  156. }
  158. /* Fonctions sur les pixmaps.  
  159.    Ces fonctions supposent que les valeurs length et width sont correctes
  160.    par rapport aux dimensions du pixmap
  161.    C'est une précondition à leur emploi */
  163. /* renvoit une pixmap zoom du pixmap initial, avec des facteurs de zoom en longueur et largeur */
  164. PIXEL *inflate_pixmap(PIXEL *pixmap, int length, int width, int ratiol, int ratiow) {
  165.   PIXEL *inflated = NULL;
  167.   inflated = malloc(length * ratiol * width * ratiow * sizeof(PIXEL));
  168.   if (!inflated) {
  169.     fprintf(stderr, "Erreur : Allocation du fichier agrandi impossible\n" );
  170.   }
  171.   else {
  172.     int i, j, k, l;
  173.     PIXEL *pix = inflated;
  175.     for (i = 0; i < width; ++i)  // chaque ligne
  176.       for (j = 0; j < ratiow; ++j) // repetee ratiow fois
  177.         for (k = 0; k < length; ++k) // chaque pixel d'une ligne
  178.           for (l = 0; l < ratiol; ++l)  // repete ratiol fois
  179.             *pix++ = pixmap[(i*length)+k];
  180.   }
  181.   return inflated;
  182. }
  185. /* on peut faire diverses operations sur les images selon ses besoins
  186.    en définissant une opération au niveau image, puis une au niveau pixmap
  187.    qui fait l'essentiel du boulot */


 
J'ai écrit ça en vitesse, donc j'ai pas tout testé, mais sur une image 2*2 pixels, c'était OK. Ça fait peut être pas exactement ce que tu veux, mais à toi d'adapter ensuite.
Je vais pondre pas mal de commentaires sur ton code précédent dans mon prochain post.
 
A+,


---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 15-03-2011 à 12:12:32    

Merci Gilou !
 
Mais quand "j'incere" une image dicom 128*128 le programme s'arrete et rien ne ce passe  
 
en tous cas merci je vais essayer de voir tous ça  !

Reply

Marsh Posté le 15-03-2011 à 12:26:11    

Comme j'ai pas d'info sur le format de tes images, ici, ça lit directement un pixmap sauvegardé dans un fichier. Comme je t'ai dit, c'est à adapter a tes besoins. Ca devrait te générer un fichier avec la nom initial suivi de -filtre.dcm en sortie.
Normalement, le programme est fait de manière a ce qu'on aie systématiquement un message d'erreur en cas de pb, et pas de message si l'écriture en sortie du fichier s'est bien passé. Donc si tu as pas de message, tu devrais avoir un fichier écrit au final.
 
A+,


Message édité par gilou le 15-03-2011 à 12:30:07

---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 15-03-2011 à 13:34:41    

Je veut bien te croire mais j'ai absoluement rien au final  
 
mais j'essaye de comprendre ton programme !

Reply

Marsh Posté le 15-03-2011 à 14:09:35    

Bon, sinon, sur ton code:
 
- On ne met pas un commentaire par ligne, ça rend le code illisible. Un commentaire, ça doit donner une information importante, s'il y a des commentaires partout, ceux qui sont importants sont noyés dans la masse.  
De plus, un bon choix des noms de variable rend nombre de commentaires inutiles:
< char information[2048];                 /* message à afficher a l'utilisateur */
> char user_info[2048];
 
- main ne doit pas faire un tas de trucs complexes. Il est la pour découper ton programme en morceaux qui font une tache bien définie
 
- On sort pas en cours de route avec exit si on peut l'éviter (dans ton cas, des fichiers ouverts ne sont pas fermés en sortant brutalement). On fait des fonctions qui rendent un booleen ou NULL et on teste dans l'appelante, si possible.
 
- On fait pas faire 2 choses différentes a une fonction: par exemple, la lecture ou bien l'écriture d'une image, mais pas les deux a la fois
 
Bon sinon, dans le code que je t'ai donné, main n'est pas blindé, je ne vérifie rien sur le bon fonctionnement de scanf (dépassement...)
printf("\rEntrez le nom du fichier image dicom a ouvrir : " );
  scanf("%s", buffer);
et  
strcat(buffer,"-filtre.dcm" );  
 
Dans un contexte autre que un exemple vite écrit, j'aurais écrit du code qui fait ces vérifications.
Je pense avoir fait les autres vérifications qui s'imposent dans le code.
 
Je définis un type de donnée correspondant a ce que je vais manipuler, donc un pour l'image et un pour une suite de pixels. C'est une habitude qu'il te faut prendre: regarder quels sont les objets que ton programme va manipuler, et définir des types correspondants.
Je découpe mes fonctions en fonction de ce qu'elles manipulent (ie des fonctions au niveau image et des fonctions au niveau pixmap)
Je fais des fonctions de bas niveau les plus génériques possibles, afin d'éviter d'en réécrire deux dont l'une est une spécialisation de l'autre (ie pas de PIXEL *inflate_proportional_pixmap(...) ici)
 
l'algo lui même:
    PIXEL *pix = inflated;
    for (i = 0; i < width; ++i)  // chaque ligne
      for (j = 0; j < ratiow; ++j) // repetee ratiow fois
        for (k = 0; k < length; ++k) // chaque pixel d'une ligne
          for (l = 0; l < ratiol; ++l)  // repete ratiol fois
            *pix++ = pixmap[(i*length)+k];
 
1)    PIXEL *pix = inflated; on se place au début de la pixmap a remplir, qu'on vient d'allouer
2)  *pix++ = pixmap[(i*length)+k]; on remplit le pixel de la pixmap (*pix) puis on avance au pixel suivant (pix++) d'ou *pix++
      on remplit avec le k-ieme pixel de la ligne i du pixmap de départ (en comptant i et k a partir de 0), pixmap[(i*length)+k];
 
A+,


---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 15-03-2011 à 15:27:47    

Bon, pour la suite, ce qui risque fort de t'intéresser, c'est le type de code suivant:

 
Code :
  1. /* fusionne deux images selon la fonction merge de fusion de pixels */
  2. IMAGE merge_image(IMAGE image1, IMAGE image2, PIXEL (*merge)(PIXEL, PIXEL)) {
  3.   IMAGE merged;
  5.   if ((image1.width != image2.width) || (image1.length != image2.length)) {
  6.     fprintf(stderr, "Erreur : Fusion d'images de dimension differentes impossible\n" );
  7.     merged.pixmap = NULL;
  8.   }
  9.   else {
  10.     merged.width  = image1.width;
  11.     merged.length = image1.length;
  12.     merged.pixmap = merge_pixmap(image1.pixmap, image2.pixmap, merged.length, merged.width, merge);
  13.   }
  14.   return merged;
  15. }
  16. /* fusionne deux pixmaps selon la fonction merge de fusion de pixels */
  17. PIXEL *merge_pixmap(PIXEL *pixmap1, PIXEL *pixmap2, int length, int width, PIXEL (*merge)(PIXEL, PIXEL)) {
  18.   PIXEL *merged = NULL;
  20.   merged = malloc(length * width * sizeof(PIXEL));
  21.   if (!merged) {
  22.     fprintf(stderr, "Erreur : Allocation du fichier fusionné impossible\n" );
  23.   }
  24.   else {
  25.     int i, j, k;
  27.     for (i = 0; i < width; ++i)
  28.       for (j = 0; j < length; ++j) {
  29.         k = i*length + j;
  30.         merged[k] = merge(pixmap1[k], pixmap2[k]);
  31.       }
  32.   }
  33.   return merged;
  34. }


C'est du code un peu avancé en C: tu as en dernier paramètre (un pointeur sur) une autre fonction qui prend deux PIXELS en parametres et retourne un PIXEL. Bref, une fonction qui fabrique un PIXEL a partir de deux autres.

 

Exemple:
une fonction de fusion des pixels qui prend un pixel une fois sur deux dans une image et une fois sur deux dans l'autre:

Code :
  1. /* chox d'un pixel d'une pixmap, puis de celui de l'autre */
  2. PIXEL switcher(PIXEL p1, PIXEL p2) {
  3.   static int cpt = 0;
  4.   cpt++;
  5.   return(cpt%2?p1:p2);
  7. }


Et tu vas pouvoir appeler ca comme:

Code :
  1. merged = merge_image(image1, image2, switcher);


ou image1 et image2 sont deux images que tu as déjà construites, et merged est l'image par fusion des deux que tu veux construire (et ensuite écrire dans un fichier ou autre).

 

Bon ici, la fonction de fusion de pixel, switcher, est stupide, et concrètement quand tu vas vouloir fusionner deux images, (superposition d'une sur l'autre, moyenne des deux pixels, ...) il va falloir que tu en écrives une adaptée a tes besoins (ou plusieurs, si tu as plusieurs type de fusions a effectuer, tout l'intérêt ici, c'est que tu as juste la fonction passée en paramètre a changer, et tu touches pas à merge_image(...)).

 

A+,


Message édité par gilou le 15-03-2011 à 22:27:27

---------------
There's more than what can be linked! --    Iyashikei Anime Forever!    --  AngularJS c'est un framework d'engulé!  --
Reply

Marsh Posté le 16-03-2011 à 10:55:18    

Merci beaucoup !!!
 
je vais analyser ton code de ce pas !
 
Merci encore @+

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed