Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
574 connectés 

  FORUM HardWare.fr
  Programmation
  C

  Redimmensionner une image

 



 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

Redimmensionner une image

n°2062019
yoyo30
Posté le 09-03-2011 à 14:11:08  profilanswer
 

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

mood
Publicité
Posté le 09-03-2011 à 14:11:08  profilanswer
 

n°2062033
skeye
Posté le 09-03-2011 à 14:43:41  profilanswer
 

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 -
n°2062037
yoyo30
Posté le 09-03-2011 à 14:45:27  profilanswer
 

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

n°2062041
skeye
Posté le 09-03-2011 à 14:49:12  profilanswer
 

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 -
n°2062058
yoyo30
Posté le 09-03-2011 à 15:13:42  profilanswer
 

Code :
  1. /* Inclusions des bibliothèques contenant les prototypes des fonctions standard de C */
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. /* Définition de constantes globales */
  5. #define MOT 2                                                       /* nombre d'octet dans un mot */
  6. /* 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  */
  7. void lecture_ecriture_image(short int *image, int cote, char *nom1, char *nom2, int option);
  8. /* 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*/
  9. /* 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 */
  10. void message(char *information);                                    /* renvoie à l'écran un message */
  11. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  12. /*                                                                  Programme principal                                                        */
  13. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  14. int main()                                   /* Programme principal */
  15.      {
  16.      int i,j,ki, kj;                         /* variable entières signées: indices de boucles */
  17.      int cote;                               /* taille de l'image en pixels par cote */
  18.      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 */
  19.      char information[2048];                 /* message à afficher a l'utilisateur */
  20.      short int *image;
  21.      short int *image2 ;                    /* pointeur sur les valeurs de pixels contenues dans le fichier image dicom, sur 2 octets */
  22.   short int *tampon ;                     /* pointeur sur les pixels de l'image en cours de filtrage, codes sur 1 mot */
  23. /**************************************************************************************************************************************************/   
  24.  float coef[3][3]={1.,2.,1.,2.,4.,2.,1.,2.,1.} ;  /* pondérations pour le lissage */
  25.  float somme, calcul;
  26. /* Calcul de la somme des coefficients pour moyenne */
  27.      somme = 0.0;
  28.     for(i=0;i<3;i++) for(j=0;j<3;j++) somme += coef[i][j];
  29. /**************************************************************************************************************************************************/ 
  30. /* Ouverture du fichier contenant l’image */
  31.    
  32.     printf("\nEntrez le nom du fichier image dicom a ouvrir : " );                                                  /* affiche un texte à l'écran, pour information */
  33.     scanf("%s",nom);                                                                                               /* affecte la chaine de caractères tapée au pointeur nom */
  34.     sprintf(nom1,"%s.dcm",nom);                                                                                    /* concatène nom et .dcm dans nom1*/
  35.     printf("\nEntrez la taille de cette image (nombre de pixels par cote) : " );
  36.     scanf("%d",&cote);                                                                                             /* affecte le nombre entier entré à l'adresse pointée par &cote*/
  37. /* Affectation de la mémoire vive nécessaire au stockage des pixels de l'image */   
  38.    
  39.     image = malloc(cote*cote*sizeof(short int)) ;                                                                /* Allocation de taille_dicom mots de 2 octets à partir de *dicom */
  40.  if(image==NULL)
  41.              {
  42.              sprintf(information, "Erreur : Allocation du fichier dicom impossible lors de sa lecture\n" );
  43.              message(information);
  44.              }           
  45.  
  46.    
  47. /* Lecture de l'image dicom sur le disque dur et affectation des valeurs des pixels au pointeur image */     
  48.    
  49.     lecture_ecriture_image(image,cote,nom1,nom1,0);
  50. /* Filtrage de l’image */
  51.     tampon = malloc(cote*cote*sizeof(short int)) ;                                                                       /* Allocation de cote² mots de 2 octets à partir de *tampon */
  52. if(tampon==NULL)
  53.              {
  54.              sprintf(information, "Erreur : Allocation de l'image tampon impossible lors du filtrage\n" );
  55.              message(information);
  56.              }
  57.          
  58. for(i=1; i<cote-1; i++) for(j=1; j<cote-1; j++)
  59.              {
  60.              *(tampon+j+i*cote) = 0;
  61.            
  62. /**************************************************************************************************************************************************/ 
  63.            
  64.              calcul = 0.0;
  65.            
  66.              for(ki=-1;ki<=1;ki++)
  67.                   for(kj=-1;kj<=1;kj++)
  68.                   calcul +=  (coef[ki+1][kj+1] * (float)(*(image + j+kj + (i+ki)*cote))) ;   /* Filtrage linéaire */                             
  69.            
  70.              *(tampon+j+i*cote) = (short int)( calcul/somme + 0.5);                                                                 /* moyenne arrondie au plus près*/
  71.          
  72. /**************************************************************************************************************************************************/           
  73.              }
  74.    
  75.     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 */
  76.     free(tampon);
  77. /* 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 */
  78.      
  79.     sprintf(nom2,"%s-filtre.dcm",nom);                                                                                 /* nom du fichier en sortie */
  80.     lecture_ecriture_image(image,cote,nom1,nom2,1);
  81. /* libération de mémoire */
  82.     free(image);
  83.    
  84.     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);
  85.     message(information);
  86. }
  87. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  88. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  89. /*                               A partir d'ici, nous définissons les fonctions et programmes utilisées dans le programme princupal           */
  90. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  91. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  92. void lecture_ecriture_image(short int *image, int cote, char *nom1, char *nom2, int option)
  93. /* Cette fonction est utilisée pour lire les pixels d'une image dicom et pour y écrire des valeurs de pixels modifiés */
  94. /* 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 */
  95. /* 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) */
  96. /* en d'autres termes :  */
  97. /* 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*/
  98. /* 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 */
  99.      {
  100.  FILE *fichier ;                         /* structure identifiant un fichier */
  101.   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*/
  102.      int taille;                             /* taille du fichier image dicom */
  103.      int entete;                             /* entier contenant le nombre de mots dans l'entete dicom */
  104.      int i,j;                                /* entiers servant à balayer les pixels de l'image suivant lignes et colonnes */
  105.      char information[2048];                 /* message à afficher a l'utilisateur */
  106.    
  107. /* Définition d'un pointeur sur le fichier présent dans le disque dur */   
  108.              
  109.      fichier=fopen(nom1,"rb" ) ;                                                                                     /* ouvre le fichier nom1 sur le disque en lecture */
  110.  if(fichier==NULL)                                                                                              /* avertissement et sortie en cas de lecture impossible */
  111.              {
  112.              sprintf(information, "Erreur : le fichier %s n'est pas lisible dans le repertoire courant\n",nom1);    /* fabrique la chaine de caractères "message" */
  113.              message(information);                                                                                  /* appel à la fonction qui affiche le message */
  114.              }
  115.            
  116. /* Calcul de la taille du fichier dicom contenant l'image */
  117.            
  118.      fseek(fichier,0,SEEK_END);                                                           /* Déplacement du pointeur du fichier en fin de fichier */
  119.      taille = ftell(fichier);                                                             /* La fonction ftell renvoie la position courante en octet du pointeur de fichier */
  120.                                                                                           /* par rapport au début du fichier, donc ici la taille du fichier */
  121.      taille/=MOT;                                                                         /* calcul de la taille du fichier dicom en mots de 2 octets */
  122.        
  123. /* Calcul de la taille de l'entête unique en début de fichier */
  124.       entete = taille - cote*cote;                                                        /* calcul de la taille de l'entête du fichier dicom en mots de 2 octets */
  125.      
  126. /* Allocation d’un pointeur sur le fichier image dicom complet */
  127.  dicom = malloc(taille*sizeof(short int)) ;                                           /* Allocation locale de taille_dicom mots de 2 octets à partir de *dicom */
  128.  if(dicom==NULL)
  129.              {
  130.              sprintf(information, "Erreur : Allocation du fichier dicom impossible lors de sa lecture\n" );
  131.              message(information);
  132.              }           
  133.     fseek(fichier,0,SEEK_SET);                                                                                 /* rembobinage */
  134. fread(dicom,taille,sizeof(short int),fichier) ;                                                            /* affectation de la mémoire vive allouée par lecture de nom1 */
  135. fclose(fichier) ;                                                                                          /* libération du pointeur de fichier */
  136. /* Lecture ou écriture, suivant la valeur de l'option */
  137.     if(option==0) for(i=0;i<cote;i++) for(j=0;j<cote;j++) *(image+j+i*cote) = *(dicom + entete +j + i*cote);
  138.    /* Si option=0, affectation du pointeur image aux valeurs des pixels situés après l'entete */
  139.     else /* si option=1*/
  140.         {   
  141.         /* 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 */
  142.         for(i=0;i<cote;i++) for(j=0;j<cote;j++) *(dicom+entete+j+i*cote) = *(image +j + i*cote);
  143.  
  144.         /* puis on écrit sur le disque dur le nouveau fichier dicom produit */
  145.         fichier=fopen(nom2,"wb" ) ;                                                                                 /* pointeur sur le fichier à écrire sur le disque */
  146.     if(fichier==NULL)
  147.          {
  148.              sprintf(information,"Erreur : le fichier %s ne peut pas etre ecrit dans le répertoire courant\n",nom2);
  149.              message(information);
  150.              }
  151.         fseek(fichier,-0,SEEK_SET);                                                                                   /* positionnement en début de fichier */
  152.     fwrite(dicom,taille,sizeof(short int),fichier) ;                                                             /* écriture du pointeur dans le fichier nom2 */
  153.     fclose(fichier) ;                                                                                            /* libération du pointeur de fichier */
  154.         }
  155.    
  156.     } 
  157. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  158. /*---------------------------------------------------------------------------------------------------------------------------------------------*/
  159. void message(char *information)
  160.      {
  161.      printf(information);      /* affiche à l'écran le message d'information */
  162.      getch();                  /* attente d'une frappe clavier pour que l'utilisateur prenne connaissance du probleme */
  163.      exit(1) ;                 /* sort du programme */
  164.      }
  165. /*---------------------------------------------------------------------------------------------------------------------------------------------*/


 
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é"

n°2062063
skeye
Posté le 09-03-2011 à 15:21:00  profilanswer
 

...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 -
n°2062069
yoyo30
Posté le 09-03-2011 à 15:25:00  profilanswer
 

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 .

n°2062073
skeye
Posté le 09-03-2011 à 15:36:22  profilanswer
 

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 -
n°2062103
yoyo30
Posté le 09-03-2011 à 17:34:00  profilanswer
 

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

n°2062108
Xavier_OM
Pas de slips radioactifs !
Posté le 09-03-2011 à 17:47:31  profilanswer
 

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.


---------------
https://www.baba-patrimoine.fr/  pour tout comprendre sur l'art et le patrimoine - https://serpentaplumes.tumblr.com/
mood
Publicité
Posté le 09-03-2011 à 17:47:31  profilanswer
 

n°2062113
gilou
Modérateur
Modzilla
Posté le 09-03-2011 à 18:12:19  profilanswer
 

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é!  --
n°2062115
yoyo30
Posté le 09-03-2011 à 18:30:41  profilanswer
 

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

n°2062120
gilou
Modérateur
Modzilla
Posté le 09-03-2011 à 20:11:40  profilanswer
 

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é!  --
n°2062236
yoyo30
Posté le 10-03-2011 à 12:01:52  profilanswer
 

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 */
  9.       entete = taille - cote*cote;
  10. //Début de l'écriture du programme  
  11. if(option==0) fread(dicom-entete,taille,sizeof(short int),fichier);
  12.                   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)

n°2062252
gilou
Modérateur
Modzilla
Posté le 10-03-2011 à 13:37:28  profilanswer
 

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é!  --
n°2062264
yoyo30
Posté le 10-03-2011 à 14:00:39  profilanswer
 


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

n°2062266
skeye
Posté le 10-03-2011 à 14:02:27  profilanswer
 

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 -
n°2062272
yoyo30
Posté le 10-03-2011 à 14:10:15  profilanswer
 


" 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  

n°2062306
gilou
Modérateur
Modzilla
Posté le 10-03-2011 à 15:26:57  profilanswer
 

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é!  --
n°2062357
yoyo30
Posté le 10-03-2011 à 17:39:42  profilanswer
 


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  

n°2062361
gilou
Modérateur
Modzilla
Posté le 10-03-2011 à 18:08:32  profilanswer
 

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é!  --
n°2062384
yoyo30
Posté le 10-03-2011 à 21:08:49  profilanswer
 

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

n°2062414
gatsu35
Blablaté par Harko
Posté le 11-03-2011 à 01:28:43  profilanswer
 

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
n°2062417
gilou
Modérateur
Modzilla
Posté le 11-03-2011 à 02:23:01  profilanswer
 

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é!  --
n°2062499
yoyo30
Posté le 11-03-2011 à 11:31:31  profilanswer
 


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];
  11.         for (i=0;i<4;i++)
  12.             fwrite(ligne_en_sortie,4*cote,sizeof(short),fpout);
  13.     }


 
mais ça marche pas !

n°2062519
Xavier_OM
Pas de slips radioactifs !
Posté le 11-03-2011 à 11:59:36  profilanswer
 

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" :/


---------------
https://www.baba-patrimoine.fr/  pour tout comprendre sur l'art et le patrimoine - https://serpentaplumes.tumblr.com/
n°2062542
yoyo30
Posté le 11-03-2011 à 13:05:13  profilanswer
 

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 !

n°2062561
Xavier_OM
Pas de slips radioactifs !
Posté le 11-03-2011 à 14:07:54  profilanswer
 

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>
  3. #define MOT 2                                                     
  4. void lecture_ecriture_image(short int *image, int cote, char *nom1, char *nom2, int option);
  5. void message(char *information);                                   
  6. int main()                                 
  7. {
  8.     int i,j,ki, kj;                       
  9.     int cote;                             
  10.     char nom[256], nom1[256], nom2[256];   
  11.     char information[2048];               
  12.     short int *image;
  13.     short int *image2 ;                   
  14.     short int *tampon ;                   
  15.      
  16.     float coef[3][3]={1.,2.,1.,2.,4.,2.,1.,2.,1.} ; 
  17.     float somme, calcul;
  18.     somme = 0.0;
  19.     for(i=0;i<3;i++) for(j=0;j<3;j++) somme += coef[i][j];
  20.    
  21.     printf("\nEntrez le nom du fichier image dicom a ouvrir : " );                                                 
  22.     scanf("%s",nom);                                                                                             
  23.     sprintf(nom1,"%s.dcm",nom);                                                                                   
  24.     printf("\nEntrez la taille de cette image (nombre de pixels par cote) : " );
  25.     scanf("%d",&cote);                                                                                           
  26.     image = malloc(cote*cote*sizeof(short int)) ;                                                               
  27.     if(image==NULL)
  28.     {
  29.         sprintf(information, "Erreur : Allocation du fichier dicom impossible lors de sa lecture\n" );
  30.         message(information);
  31.     }         
  32.     lecture_ecriture_image(image,cote,nom1,nom1,0);
  33.    
  34.     tampon = malloc(cote*cote*sizeof(short int)) ;                                                                     
  35.     if(tampon==NULL)
  36.     {
  37.         sprintf(information, "Erreur : Allocation de l'image tampon impossible lors du filtrage\n" );
  38.         message(information);
  39.     }
  40.     for(i=1; i<cote-1; i++) for(j=1; j<cote-1; j++)
  41.     {
  42.         *(tampon+j+i*cote) = 0;
  43.         calcul = 0.0;
  44.         for(ki=-1;ki<=1;ki++)
  45.             for(kj=-1;kj<=1;kj++)
  46.                 calcul +=  (coef[ki+1][kj+1] * (float)(*(image + j+kj + (i+ki)*cote))) ;                               
  47.         *(tampon+j+i*cote) = (short int)( calcul/somme + 0.5);                                                               
  48.                  
  49.     }
  50.     for(i=1; i<cote-1; i++) for(j=1; j<cote-1; j++) *(image +j+i*cote) = *(tampon+j+i*cote);                                       
  51.     free(tampon);
  52.     sprintf(nom2,"%s-filtre.dcm",nom);                                                                               
  53.     lecture_ecriture_image(image,cote,nom1,nom2,1);
  54.    
  55.     free(image);
  56.     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);
  57.     message(information);
  58. }
  59. void lecture_ecriture_image(short int *image, int cote, char *nom1, char *nom2, int option)
  60. {
  61.     FILE *fichier ;                       
  62.     short int *dicom ;                     
  63.     int taille;                           
  64.     int entete;                           
  65.     int i,j;                               
  66.     char information[2048];               
  67.      
  68.     fichier=fopen(nom1,"rb" ) ;                                                                                   
  69.     if(fichier==NULL)                                                                                             
  70.     {
  71.         sprintf(information, "Erreur : le fichier %s n'est pas lisible dans le repertoire courant\n",nom1);   
  72.         message(information);                                                                                 
  73.     }
  74.     fseek(fichier,0,SEEK_END);                                                         
  75.     taille = ftell(fichier);                                                           
  76.    
  77.     taille/=MOT;                                                                       
  78.     entete = taille - cote*cote;                                                       
  79.     dicom = malloc(taille*sizeof(short int)) ;                                         
  80.     if(dicom==NULL)
  81.     {
  82.         sprintf(information, "Erreur : Allocation du fichier dicom impossible lors de sa lecture\n" );
  83.         message(information);
  84.     }         
  85.     fseek(fichier,0,SEEK_SET);                                                                               
  86.     fread(dicom,taille,sizeof(short int),fichier) ;                                                           
  87.     fclose(fichier) ;                                                                                         
  88.    
  89.     if(option==0) for(i=0;i<cote;i++) for(j=0;j<cote;j++) *(image+j+i*cote) = *(dicom + entete +j + i*cote);
  90.     else
  91.     { 
  92.         for(i=0;i<cote;i++) for(j=0;j<cote;j++) *(dicom+entete+j+i*cote) = *(image +j + i*cote);
  93.        
  94.         fichier=fopen(nom2,"wb" ) ;                                                                               
  95.         if(fichier==NULL)
  96.         {
  97.             sprintf(information,"Erreur : le fichier %s ne peut pas etre ecrit dans le répertoire courant\n",nom2);
  98.             message(information);
  99.         }
  100.         fseek(fichier,-0,SEEK_SET);                                                                                 
  101.         fwrite(dicom,taille,sizeof(short int),fichier) ;                                                           
  102.         fclose(fichier) ;                                                                                           
  103.     }
  104. }
  105. void message(char *information)
  106. {
  107.     printf(information);     
  108.     //getch();                 
  109.     exit(1) ;               
  110. }
 

Ç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

---------------
https://www.baba-patrimoine.fr/  pour tout comprendre sur l'art et le patrimoine - https://serpentaplumes.tumblr.com/
n°2062568
yoyo30
Posté le 11-03-2011 à 14:31:49  profilanswer
 

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);
    }

n°2063162
skeye
Posté le 14-03-2011 à 10:59:20  profilanswer
 

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 -
n°2063182
yoyo30
Posté le 14-03-2011 à 11:17:29  profilanswer
 

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

n°2063235
gilou
Modérateur
Modzilla
Posté le 14-03-2011 à 12:49:00  profilanswer
 

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é!  --
n°2063254
yoyo30
Posté le 14-03-2011 à 13:40:17  profilanswer
 

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é !!!

n°2063257
gilou
Modérateur
Modzilla
Posté le 14-03-2011 à 13:45:36  profilanswer
 

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é!  --
mood
Publicité
Posté le   profilanswer
 


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  C

  Redimmensionner une image

 

Sujets relatifs
[C++] Traitement d'image par pixel (bits)Slide show : changer un lien href en meme temps que l'image affichée
fade in simple sur une seule image d'accueilDétecter la définition d'une image
intégrer image dans commentaireRedimmensionner image dans movieclip
[C#]Redimmensionner une imageRedimmensionner une image via php ?
Redimmensionner une Image avant upload ..Comment redimmensionner une image sous netscape en JS
Plus de sujets relatifs à : Redimmensionner une image


Copyright © 1997-2018 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR