Redimmensionner une image

Redimmensionner une image - C - Programmation

Marsh Posté le 09-03-2011 à 14:11:08    

Bonjour a tous !
 
j'ai besoin d'une aide pour cette question comme toujours je travaille en C sous devc++ sans bibliothéque  
je posséde une image de taille 512*512(CT) et une autre 128*128(TEP)  
Il me faut fusionner ces images mais avant cela il me faut arriver a dimensionner l'image 128*128(TEP) en 512*512 pour que la fusion ce fasse parfaitement
je compte alors faire un programme qui suivent ces parametres :
Fusion(i,j)(512*512)
CT(512) (i1,j1)->(i1=i,j1=j)
TEP(128) (i2,j2)->(i2=i/4,j2=j/4)  
 
Quel sont les fonctions a utilisé,comment arriver a retranscrire ces paramétres en langage C ?
 
Merci d'avance

Reply

Marsh Posté le 09-03-2011 à 14:11:08   

Reply

Marsh Posté le 09-03-2011 à 14:43:41    

Je vois pas de difficulté majeure...transformer du 128x128 en 512x512 ça revient tout simplement à créer un carré de 4x4 pixels pour chaque pixel de l'image d'origine...:??:


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

Marsh Posté le 09-03-2011 à 14:45:27    

Oui je comprend bien mais tu aurait un bout de code a me montrer poue effectuer cette opération s'il te plais
 
Merci d'avance

Reply

Marsh Posté le 09-03-2011 à 14:49:12    

Non.
Le principe sur ce forum c'est plutôt de commencer à faire quelque chose, et de demander de l'aide quand on est bloqué...tu en es où? Tu as du code à montrer?


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

Marsh Posté le 09-03-2011 à 15:13:42    

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. /**************************************************************************************************************************************************/   
  32.  float coef[3][3]={1.,2.,1.,2.,4.,2.,1.,2.,1.} ;  /* pondérations pour le lissage */
  33.  float somme, calcul;
  35. /* Calcul de la somme des coefficients pour moyenne */
  37.      somme = 0.0;
  38.     for(i=0;i<3;i++) for(j=0;j<3;j++) somme += coef[i][j];
  39. /**************************************************************************************************************************************************/ 
  41. /* Ouverture du fichier contenant l’image */
  42.    
  43.     printf("\nEntrez le nom du fichier image dicom a ouvrir : " );                                                  /* affiche un texte à l'écran, pour information */
  44.     scanf("%s",nom);                                                                                               /* affecte la chaine de caractères tapée au pointeur nom */
  45.     sprintf(nom1,"%s.dcm",nom);                                                                                    /* concatène nom et .dcm dans nom1*/
  47.     printf("\nEntrez la taille de cette image (nombre de pixels par cote) : " );
  48.     scanf("%d",&cote);                                                                                             /* affecte le nombre entier entré à l'adresse pointée par &cote*/
  50. /* Affectation de la mémoire vive nécessaire au stockage des pixels de l'image */   
  51.    
  52.     image = malloc(cote*cote*sizeof(short int)) ;                                                                /* Allocation de taille_dicom mots de 2 octets à partir de *dicom */
  53.  if(image==NULL)
  54.              {
  55.              sprintf(information, "Erreur : Allocation du fichier dicom impossible lors de sa lecture\n" );
  56.              message(information);
  57.              }           
  58.  
  59.    
  60. /* Lecture de l'image dicom sur le disque dur et affectation des valeurs des pixels au pointeur image */     
  61.    
  62.     lecture_ecriture_image(image,cote,nom1,nom1,0);
  64. /* Filtrage de l’image */
  66.     tampon = malloc(cote*cote*sizeof(short int)) ;                                                                       /* Allocation de cote² mots de 2 octets à partir de *tampon */
  67. if(tampon==NULL)
  68.              {
  69.              sprintf(information, "Erreur : Allocation de l'image tampon impossible lors du filtrage\n" );
  70.              message(information);
  71.              }
  72.          
  73. for(i=1; i<cote-1; i++) for(j=1; j<cote-1; j++)
  74.              {
  75.              *(tampon+j+i*cote) = 0;
  76.            
  77. /**************************************************************************************************************************************************/ 
  78.            
  79.              calcul = 0.0;
  80.            
  81.              for(ki=-1;ki<=1;ki++)
  82.                   for(kj=-1;kj<=1;kj++)
  83.                   calcul +=  (coef[ki+1][kj+1] * (float)(*(image + j+kj + (i+ki)*cote))) ;   /* Filtrage linéaire */                             
  84.            
  85.              *(tampon+j+i*cote) = (short int)( calcul/somme + 0.5);                                                                 /* moyenne arrondie au plus près*/
  86.          
  87. /**************************************************************************************************************************************************/           
  88.              }
  89.    
  90.     for(i=1; i<cote-1; i++) for(j=1; j<cote-1; j++) *(image +j+i*cote) = *(tampon+j+i*cote);                                        /* recopie en ecrasant l'ancienne image */
  91.     free(tampon);
  93. /* 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 */
  94.      
  95.     sprintf(nom2,"%s-filtre.dcm",nom);                                                                                 /* nom du fichier en sortie */
  96.     lecture_ecriture_image(image,cote,nom1,nom2,1);
  98. /* libération de mémoire */
  99.     free(image);
  100.    
  101.     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);
  102.     message(information);
  103. }
  104. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  113. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  114. /*                               A partir d'ici, nous définissons les fonctions et programmes utilisées dans le programme princupal           */
  115. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  124. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  125. void lecture_ecriture_image(short int *image, int cote, char *nom1, char *nom2, int option)
  126. /* Cette fonction est utilisée pour lire les pixels d'une image dicom et pour y écrire des valeurs de pixels modifiés */
  127. /* image est un pointeur en mémoire à partir duquel sont stockés les cote² valeurs des pixels; cote est le nombre de pixels par ligne et par colonne d'une image carrée */
  128. /* nom1 est le nom du fichier dicom à lire sur le disque (option 0) ou celui dont on utilisera l'entete pour écrire un fichier dicom nom2 filtré (option 1) */
  129. /* en d'autres termes :  */
  130. /* 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*/
  131. /* 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 */
  132.      {
  133.  FILE *fichier ;                         /* structure identifiant un fichier */
  134.   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*/
  135.      int taille;                             /* taille du fichier image dicom */
  136.      int entete;                             /* entier contenant le nombre de mots dans l'entete dicom */
  137.      int i,j;                                /* entiers servant à balayer les pixels de l'image suivant lignes et colonnes */
  138.      char information[2048];                 /* message à afficher a l'utilisateur */
  139.    
  140. /* Définition d'un pointeur sur le fichier présent dans le disque dur */   
  141.              
  142.      fichier=fopen(nom1,"rb" ) ;                                                                                     /* ouvre le fichier nom1 sur le disque en lecture */
  143.  if(fichier==NULL)                                                                                              /* avertissement et sortie en cas de lecture impossible */
  144.              {
  145.              sprintf(information, "Erreur : le fichier %s n'est pas lisible dans le repertoire courant\n",nom1);    /* fabrique la chaine de caractères "message" */
  146.              message(information);                                                                                  /* appel à la fonction qui affiche le message */
  147.              }
  148.            
  149. /* Calcul de la taille du fichier dicom contenant l'image */
  150.            
  151.      fseek(fichier,0,SEEK_END);                                                           /* Déplacement du pointeur du fichier en fin de fichier */
  152.      taille = ftell(fichier);                                                             /* La fonction ftell renvoie la position courante en octet du pointeur de fichier */
  153.                                                                                           /* par rapport au début du fichier, donc ici la taille du fichier */
  154.      taille/=MOT;                                                                         /* calcul de la taille du fichier dicom en mots de 2 octets */
  155.        
  156. /* Calcul de la taille de l'entête unique en début de fichier */
  158.       entete = taille - cote*cote;                                                        /* calcul de la taille de l'entête du fichier dicom en mots de 2 octets */
  159.      
  160. /* Allocation d’un pointeur sur le fichier image dicom complet */
  162.  dicom = malloc(taille*sizeof(short int)) ;                                           /* Allocation locale de taille_dicom mots de 2 octets à partir de *dicom */
  163.  if(dicom==NULL)
  164.              {
  165.              sprintf(information, "Erreur : Allocation du fichier dicom impossible lors de sa lecture\n" );
  166.              message(information);
  167.              }           
  168.     fseek(fichier,0,SEEK_SET);                                                                                 /* rembobinage */
  169. fread(dicom,taille,sizeof(short int),fichier) ;                                                            /* affectation de la mémoire vive allouée par lecture de nom1 */
  170. fclose(fichier) ;                                                                                          /* libération du pointeur de fichier */
  172. /* Lecture ou écriture, suivant la valeur de l'option */
  174.     if(option==0) for(i=0;i<cote;i++) for(j=0;j<cote;j++) *(image+j+i*cote) = *(dicom + entete +j + i*cote);
  175.    /* Si option=0, affectation du pointeur image aux valeurs des pixels situés après l'entete */
  177.     else /* si option=1*/
  178.         {   
  179.         /* Dans le pointeur dicom, on conserve l'entete et on écrase les valeurs des pixels situées après l'entete avec les pixels filtrés pointés par image */
  180.         for(i=0;i<cote;i++) for(j=0;j<cote;j++) *(dicom+entete+j+i*cote) = *(image +j + i*cote);
  181.  
  182.         /* puis on écrit sur le disque dur le nouveau fichier dicom produit */
  183.         fichier=fopen(nom2,"wb" ) ;                                                                                 /* pointeur sur le fichier à écrire sur le disque */
  184.     if(fichier==NULL)
  185.          {
  186.              sprintf(information,"Erreur : le fichier %s ne peut pas etre ecrit dans le répertoire courant\n",nom2);
  187.              message(information);
  188.              }
  189.         fseek(fichier,-0,SEEK_SET);                                                                                   /* positionnement en début de fichier */
  190.     fwrite(dicom,taille,sizeof(short int),fichier) ;                                                             /* écriture du pointeur dans le fichier nom2 */
  191.     fclose(fichier) ;                                                                                            /* libération du pointeur de fichier */
  192.         }
  193.    
  194.     } 
  195. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  198. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  199. void message(char *information)
  200.      {
  201.      printf(information);      /* affiche à l'écran le message d'information */
  202.      getch();                  /* attente d'une frappe clavier pour que l'utilisateur prenne connaissance du probleme */
  203.      exit(1) ;                 /* sort du programme */
  204.      }
  205. /*---------------------------------------------------------------------------------------------------------------------------------------------*/


 
Voila mon code sauf que pour le moment j'effectue un filtrage sur une image (ici une image dicom) je compte suprimé ce bout de code et à la place arriver a redimensionner mon image  
 
dans ce code : a partir de la console j'insere une image dicom avec ça taille et il me recrée un fichier "filtré"

Reply

Marsh Posté le 09-03-2011 à 15:21:00    

...tu as donc une bonne base pour ce nouvel exercice...qu'est-ce qui te pose problème? :??:


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

Marsh Posté le 09-03-2011 à 15:25:00    

Eh bien j'aimerais avoir le code qui me permette de redimensionner mon image à la place du code de filtrage .
Je ne c'est pas du tout comme faire pour redimensionner mon image !
meme si j'ai compris le principe .

Reply

Marsh Posté le 09-03-2011 à 15:36:22    

Tu ouvres ton image d'origine, tu en crées une nouvelle en 512x512, et tu copies les pixels de ton image d'origine au bon endroit dans la nouvelle.
Il n'y a aucune réelle difficulté à-partir du code que tu as déjà, si tu l'as compris.


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

Marsh Posté le 09-03-2011 à 17:34:00    

Mais pourrait me montrer les directives du code a appliquer si ce n'est pas trop compliqué  
Je t'en remercie d'avance

Message cité 1 fois
Reply

Marsh Posté le 09-03-2011 à 17:47:31    

yoyo30 a écrit :

Mais pourrait me montrer les directives du code a appliquer si ce n'est pas trop compliqué  
Je t'en remercie d'avance


 
1. tu crées une image vide de 512x512 (c'est à toi de savoir comment créer une image vide... c'est ton code, tes lib)
2. tu parcours ton image vide pixel par pixel (c'est à toi de savoir comment on parcourt une image)
3. pour chaque pixel de l'image vide (d'arrivée) tu vas lire une valeur dans l'image d'origine (c'est à toi de savoir comment on lit la valeur d'un pixel dans une image) et tu la copies dans ton image d'arrivée (c'est à toi de savoir comment on écrit une valeur dans une image)
 
Une fois le parcours fini, tu as une image de 512x512 non vide. Tu as terminé ton redimensionnement.
 
Pour les directives de code, débrouille toi.


---------------
Il y a autant d'atomes d'oxygène dans une molécule d'eau que d'étoiles dans le système solaire.
Reply

Marsh Posté le 09-03-2011 à 17:47:31   

Reply

Marsh Posté le 09-03-2011 à 18:12:19    

Il serait peut être plus simple de procéder ainsi:
1. tu crées une image vide de 512x512 (c'est à toi de savoir comment créer une image vide... c'est ton code, tes lib)  
2 Tu parcours ton image source de 128*128
  - Pour chaque ligne de l'image source, tu la parcours pixel par pixel
        - Pour chaque pixel de la ligne, tu l'écris 4 fois dans l'image d'arrivée.
   Une fois la ligne de l'image source lue, et une ligne de l'image d'arrivée écrite, on copie 3 fois cette ligne de l'image d'arrivée dans l'image d'arrivée (ca nous fait donc 4 lignes de l'image d'arrivée au total)
   Et on reboucle tant qu'il reste des lignes dans l'image source.
 
A+,


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

Marsh Posté le 09-03-2011 à 18:30:41    

Ok merci juste une question on fait comment pour crée une image vide ?

Reply

Marsh Posté le 09-03-2011 à 20:11:40    

Ben tu alloues une taille mémoire ad-hoc, et tu remplis les champs a renseigner qui dépendent de ton format d'image .
A+,


Message édité par gilou le 09-03-2011 à 20:12:50

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

Marsh Posté le 10-03-2011 à 12:01:52    

Voila ce que j'ai commencé a faire  
 

Code :
  1. /* Calcul de la taille du fichier dicom contenant l'image */
  2.            
  3.      fseek(fichier,0,SEEK_END);                                                           /* Déplacement du pointeur du fichier  
  4.      taille = ftell(fichier);                                                             /* La fonction ftell renvoie la position courante en octet du pointeur de fichier */
  5.                                                                                           /* par rapport au début du fichier, donc ici la taille du fichier */
  6.      taille/=MOT;                                                                         /* calcul de la taille du fichier dicom en mots de 2 octets */
  7.          
  8. /* Calcul de la taille de l'entête unique en début de fichier */
  10.       entete = taille - cote*cote;
  12. //Début de l'écriture du programme  
  14. if(option==0) fread(dicom-entete,taille,sizeof(short int),fichier);
  15.                   fwrite(// c'est la que je plante pour arriver a dire qu'il faut que a la place des pixels lu il les multiplies par 4)

Reply

Marsh Posté le 10-03-2011 à 13:37:28    

Bien sur, puisque la tu lis l'image d'un coup au lieu de la lire pixel par pixel, et tenir compte du fait que tu as des lignes de 128 pixels..
A+,


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

Marsh Posté le 10-03-2011 à 14:00:39    


Et quel fonction je doit utiliser pour lire pixel par pixel ?

Reply

Marsh Posté le 10-03-2011 à 14:02:27    

Il suffit de te sortir les doigts du cul et essayer de comprendre ce que tu fais / ce que ton premier code fait. Tu n'en as visiblement pas la moindre idée.


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

Marsh Posté le 10-03-2011 à 14:10:15    


" Il suffit de te sortir les doigts du cul ! "
je vais essayer ! je vais essayer de comprendre ce code !!!
je reviendrait qd je me serais ....
 
merci  

Reply

Marsh Posté le 10-03-2011 à 15:26:57    

Ben oui, parce que soit tu comprends ce que fait la ligne
fread(dicom-entete,taille,sizeof(short int),fichier);
et donc ça devrait pas te poser de problème d'adapter avec une boucle pour lire pixel par pixel
soit c'est recopié d'un autre programme en changeant les noms de variable  
et que ça marche sans que tu comprennes comment ça marche
et la on ne peut rien pour toi, puisqu'ici, on ne donne pas dans la programmation vaudou.
A+,


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

Marsh Posté le 10-03-2011 à 17:39:42    


je comprend ce que fait cette ligne puisque je les écrite  
 
elle permet de lire après l'entête mais le probléme qui doit ce poser c'est que je doit (je pense) remplacer un bout du code pour lui dire de lire pixel par pixel  

Reply

Marsh Posté le 10-03-2011 à 18:08:32    

Ben si tu comprends cette ligne, qui lit 16384 pixels d'un coup, tu devrais savoir comment faire pour en lire un seul d'un coup.
A+,


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

Marsh Posté le 10-03-2011 à 21:08:49    

Disons que c'est plus simple de les lire tous que un par un je pense

Message cité 2 fois
Reply

Marsh Posté le 11-03-2011 à 01:28:43    

yoyo30 a écrit :

Disons que c'est plus simple de les lire tous que un par un je pense


oui mais on te dit depuis le début que tu dois pixel par pixel pour pouvoir quadrupler ton image.


---------------
Blablaté par Harko
Reply

Marsh Posté le 11-03-2011 à 02:23:01    

yoyo30 a écrit :

Disons que c'est plus simple de les lire tous que un par un je pense

Non, c'est pareil, il y a juste que la quantité de pixels lus qui change.
A+,


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

Marsh Posté le 11-03-2011 à 11:31:31    


j'ai rajouté ce code
 

Code :
  1. short *ligne_en_sortie = (short *)malloc(4*cote*sizeof(short));
  2.     /* je passe les déclarations de compteurs évidentes ! */
  3.     ...
  4.     for (l=0;l<cote;l++)
  5.     {
  6.         /* decalage buffer entree pour ligne courante */
  7.         int offset_entree = entete + l * cote;
  8.         for (c=0;c<cote;c++)
  9.             for (i=0;i<4;i++)
  10.                 ligne_en_sortie[c*4+i] = dicom[offset_entree+c];
  12.         for (i=0;i<4;i++)
  13.             fwrite(ligne_en_sortie,4*cote,sizeof(short),fpout);
  14.     }


 
mais ça marche pas !

Reply

Marsh Posté le 11-03-2011 à 11:59:36    

Bah c'est en bonne voie en tout cas.  
 
Essaie de décrire le problème de manière concise :
- si ça ne compile pas : que dit le compilateur ?
- si ça compile :
-- est-ce que le programme va jusqu'au bout ou est-ce que ça crash avant la fin ?
-- tu as mis quoi en entrée, tu as obtenu quoi en sortie ?  
 
On peut pas t'aider si tu dis juste "ça marche pas" :/


---------------
Il y a autant d'atomes d'oxygène dans une molécule d'eau que d'étoiles dans le système solaire.
Reply

Marsh Posté le 11-03-2011 à 13:05:13    

en faite ça compile mais il me prend l'image d'entrer et il me crée une image de sortie identique à l'image d'entrée !

Reply

Marsh Posté le 11-03-2011 à 14:07:54    

Si tu mets un point d'arrêt (il te faut un débugger pour ça) ou un printf au cœur de tes boucles for, tu passes bien dans ton nouveau bout de code ou pas ?

 


Sinon aucun rapport, mais je mets une version sans tes commentaires ici (plus facile pour nous à lire)

Code :
  1. #include <stdio.h>
  2. #include <stdlib.h>
  5. #define MOT 2                                                     
  9. void lecture_ecriture_image(short int *image, int cote, char *nom1, char *nom2, int option);
  10. void message(char *information);                                   
  13. int main()                                 
  14. {
  15.     int i,j,ki, kj;                       
  16.     int cote;                             
  17.     char nom[256], nom1[256], nom2[256];   
  18.     char information[2048];               
  19.     short int *image;
  20.     short int *image2 ;                   
  21.     short int *tampon ;                   
  23.      
  24.     float coef[3][3]={1.,2.,1.,2.,4.,2.,1.,2.,1.} ; 
  25.     float somme, calcul;
  27.     somme = 0.0;
  28.     for(i=0;i<3;i++) for(j=0;j<3;j++) somme += coef[i][j];
  29.    
  31.     printf("\nEntrez le nom du fichier image dicom a ouvrir : " );                                                 
  32.     scanf("%s",nom);                                                                                             
  33.     sprintf(nom1,"%s.dcm",nom);                                                                                   
  35.     printf("\nEntrez la taille de cette image (nombre de pixels par cote) : " );
  36.     scanf("%d",&cote);                                                                                           
  38.     image = malloc(cote*cote*sizeof(short int)) ;                                                               
  39.     if(image==NULL)
  40.     {
  41.         sprintf(information, "Erreur : Allocation du fichier dicom impossible lors de sa lecture\n" );
  42.         message(information);
  43.     }         
  46.     lecture_ecriture_image(image,cote,nom1,nom1,0);
  48.    
  50.     tampon = malloc(cote*cote*sizeof(short int)) ;                                                                     
  51.     if(tampon==NULL)
  52.     {
  53.         sprintf(information, "Erreur : Allocation de l'image tampon impossible lors du filtrage\n" );
  54.         message(information);
  55.     }
  57.     for(i=1; i<cote-1; i++) for(j=1; j<cote-1; j++)
  58.     {
  59.         *(tampon+j+i*cote) = 0;
  61.         calcul = 0.0;
  63.         for(ki=-1;ki<=1;ki++)
  64.             for(kj=-1;kj<=1;kj++)
  65.                 calcul +=  (coef[ki+1][kj+1] * (float)(*(image + j+kj + (i+ki)*cote))) ;                               
  67.         *(tampon+j+i*cote) = (short int)( calcul/somme + 0.5);                                                               
  69.                  
  70.     }
  72.     for(i=1; i<cote-1; i++) for(j=1; j<cote-1; j++) *(image +j+i*cote) = *(tampon+j+i*cote);                                       
  73.     free(tampon);
  75.     sprintf(nom2,"%s-filtre.dcm",nom);                                                                               
  76.     lecture_ecriture_image(image,cote,nom1,nom2,1);
  78.    
  79.     free(image);
  81.     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);
  82.     message(information);
  83. }
  85. void lecture_ecriture_image(short int *image, int cote, char *nom1, char *nom2, int option)
  86. {
  87.     FILE *fichier ;                       
  88.     short int *dicom ;                     
  89.     int taille;                           
  90.     int entete;                           
  91.     int i,j;                               
  92.     char information[2048];               
  93.      
  95.     fichier=fopen(nom1,"rb" ) ;                                                                                   
  96.     if(fichier==NULL)                                                                                             
  97.     {
  98.         sprintf(information, "Erreur : le fichier %s n'est pas lisible dans le repertoire courant\n",nom1);   
  99.         message(information);                                                                                 
  100.     }
  102.     fseek(fichier,0,SEEK_END);                                                         
  103.     taille = ftell(fichier);                                                           
  104.    
  105.     taille/=MOT;                                                                       
  107.     entete = taille - cote*cote;                                                       
  109.     dicom = malloc(taille*sizeof(short int)) ;                                         
  110.     if(dicom==NULL)
  111.     {
  112.         sprintf(information, "Erreur : Allocation du fichier dicom impossible lors de sa lecture\n" );
  113.         message(information);
  114.     }         
  115.     fseek(fichier,0,SEEK_SET);                                                                               
  116.     fread(dicom,taille,sizeof(short int),fichier) ;                                                           
  117.     fclose(fichier) ;                                                                                         
  118.    
  120.     if(option==0) for(i=0;i<cote;i++) for(j=0;j<cote;j++) *(image+j+i*cote) = *(dicom + entete +j + i*cote);
  121.     else
  122.     { 
  123.         for(i=0;i<cote;i++) for(j=0;j<cote;j++) *(dicom+entete+j+i*cote) = *(image +j + i*cote);
  124.        
  125.         fichier=fopen(nom2,"wb" ) ;                                                                               
  126.         if(fichier==NULL)
  127.         {
  128.             sprintf(information,"Erreur : le fichier %s ne peut pas etre ecrit dans le répertoire courant\n",nom2);
  129.             message(information);
  130.         }
  131.         fseek(fichier,-0,SEEK_SET);                                                                                 
  132.         fwrite(dicom,taille,sizeof(short int),fichier) ;                                                           
  133.         fclose(fichier) ;                                                                                           
  134.     }
  136. }
  140. void message(char *information)
  141. {
  142.     printf(information);     
  143.     //getch();                 
  144.     exit(1) ;               
  145. }
 

Ça compile plutôt pas mal.


$ gcc -Wall test.c
test.c: In function ‘main’:
test.c:24: warning: missing braces around initializer
test.c:24: warning: (near initialization for ‘coef[0]’)
test.c:20: warning: unused variable ‘image2’
test.c:83: warning: control reaches end of non-void function


Message édité par Xavier_OM le 11-03-2011 à 14:17:23

---------------
Il y a autant d'atomes d'oxygène dans une molécule d'eau que d'étoiles dans le système solaire.
Reply

Marsh Posté le 11-03-2011 à 14:31:49    

Enfaite a ce code j'ai effacé ce qui concerné le filtrage et a la fin a la place de la ligne 120 à 124 j'ai mis mon bout de code  
 
short *ligne_en_sortie = (short *)malloc(4*cote*sizeof(short));
    /* je passe les déclarations de compteurs évidentes ! */
    ...
    for (l=0;l<cote;l++)
    {
        /* decalage buffer entree pour ligne courante */
        int offset_entree = entete + l * cote;
        for (c=0;c<cote;c++)
            for (i=0;i<4;i++)
                ligne_en_sortie[c*4+i] = dicom[offset_entree+c];
 
        for (i=0;i<4;i++)
            fwrite(ligne_en_sortie,4*cote,sizeof(short),fpout);
    }

Reply

Marsh Posté le 14-03-2011 à 10:59:20    

Arrête de remonter ce topic sans infos supplémentaires, merci. C'est pénible.
En survolant ton code, on dirait que tu modifies une image mais que tu enregistres la mauvaise:

 
Code :
  1. *(image+j+i*cote) = *(dicom + entete +j + i*cote);
  2. //[...]
  3. fwrite(dicom,taille,sizeof(short int),fichier) ;


Message édité par skeye le 14-03-2011 à 10:59:36

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

Marsh Posté le 14-03-2011 à 11:17:29    

Ok  
mais j'ai apporté de nouveau éléments !
le Poste du 11-03-2011 à 14:31:49  

Reply

Marsh Posté le 14-03-2011 à 12:49:00    

Oui, mais il se passe quoi depuis?
A+,


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

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

eh bien je code que j'ai posté sert a fair le zoom *4 mais quand je compile je retrouve mon image d'origine non modifié !!!

Reply

Marsh Posté le 14-03-2011 à 13:45:36    

Tu pourrais reposter ton code, qu'on s'y retrouve, car le bout que tu avais modifié semblait correct.
 
A+,


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

Marsh Posté le    

Reply

Sujets relatifs:

Leave a Replay

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