Main Page | Modules | Alphabetical List | Data Structures | File List | Data Fields | Globals

dcmread.c

Go to the documentation of this file.
00001 /************************************************************************* 00002 * $Id: dcmread.c,v 1.2 2005/09/09 08:52:37 bellet Exp $ 00003 ************************************************************************** 00004 This software is governed by the CeCILL license under French law and 00005 abiding by the rules of distribution of free software. You can use, 00006 modify and/ or redistribute the software under the terms of the CeCILL 00007 license as circulated by CEA, CNRS and INRIA at the following URL 00008 "http://www.cecill.info". 00009 00010 As a counterpart to the access to the source code and rights to copy, 00011 modify and redistribute granted by the license, users are provided only 00012 with a limited warranty and the software's author, the holder of the 00013 economic rights, and the successive licensors have only limited 00014 liability. 00015 00016 In this respect, the user's attention is drawn to the risks associated 00017 with loading, using, modifying and/or developing or reproducing the 00018 software by the user in light of its specific status of free software, 00019 that may mean that it is complicated to manipulate, and that also 00020 therefore means that it is reserved for developers and experienced 00021 professionals having in-depth computer knowledge. Users are therefore 00022 encouraged to load and test the software's suitability as regards their 00023 requirements in conditions enabling the security of their systems and/or 00024 data to be ensured and, more generally, to use and operate it in the 00025 same conditions as regards security. 00026 00027 The fact that you are presently reading this means that you have had 00028 knowledge of the CeCILL license and that you accept its terms. 00029 00030 Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de 00031 l'Image). All rights reserved. See License.txt for details. 00032 00033 Version 1.0 05/09/2005 00034 *************************************************************************/ 00035 00036 /* 00037 ************************************************************************** 00038 * 00039 * Description : Lit un objet LIBIDO dans un fichier 00040 * au format ACR-NEMA,LibIDO,DICOM 00041 ************************************************************************** 00042 */ 00043 00044 #include <string.h> // For strlen 00045 #include <stdlib.h> 00046 #include "idio.h" 00047 //#include <idprint.h> 00048 #include <stdio.h> 00049 #include <stdlib.h> // For atoi 00050 #include "idgen.h" 00051 00052 #include "idsig.h" 00053 #include "idcnt.h" 00054 #include "idima.h" 00055 #include "idvol.h" 00056 #include "idseq.h" 00057 00058 #include "iderr.h" 00059 00060 #include "iddcm-restricted.h" 00061 #include "iddcmjpeg.h" 00062 00063 #define DEBUG 0 00064 00065 static void _Swap(void* , int , int , int ); 00066 00067 00068 /* 00069 Rappels 00070 ------- 00071 00072 #define TY_CHAR ( 0<<4) 00 00073 #define TY_FLOAT ( 1<<4) 10 00074 #define TY_DOUBLE ( 2<<4) 20 00075 #define TY_COMPLEX ( 3<<4) 30 00076 #define TY_RGB ( 4<<4) 40 00077 #define TY_SHORT ( 5<<4) 50 00078 #define TY_LONG ( 6<<4) 60 00079 #define TY_UCHAR ( 7<<4) 70 00080 #define TY_USHORT ( 8<<4) 80 00081 #define TY_COMPLEX_DOUBLE ( 9<<4) 90 00082 #define TY_COMPLEX_FLOAT (10<<4) a0 00083 #define TY_COMPLEX_CHAR (11<<4) b0 00084 #define TY_COMPLEX_UCHAR (12<<4) c0 00085 #define TY_COMPLEX_SHORT (13<<4) d0 00086 #define TY_COMPLEX_USHORT (14<<4) e0 00087 #define TY_COMPLEX_LONG (15<<4) f0 00088 #define TY_BIT (16<<4) 100 00089 #define TY_IDPOINT (17<<4) 110 00090 #define TY_FACE (18<<4) 120 00091 #define TY_POINTER (19<<4) 130 00092 #qdefine TY_ULONG (20<<4) 140 00093 #define TY_COMPLEX_ULONG (21<<4) 150 00094 00095 #define TY_IDXPOINT_CHAR (22<<4) 160 00096 #define TY_IDXPOINT_UCHAR (23<<4) 170 00097 #define TY_IDXPOINT_FLOAT (24<<4) 180 00098 #define TY_IDXPOINT_DOUBLE(25<<4) 190 00099 #define TY_IDXPOINT_SHORT (26<<4) 1a0 00100 #define TY_IDXPOINT_USHORT(27<<4) 1b0 00101 #define TY_IDXPOINT_LONG (28<<4) 1c0 00102 #define TY_IDXPOINT_ULONG (29<<4) 1d0 00103 00104 #define TY_COLOR (30<<4) 1fo 00105 */ 00106 00107 00108 //static int rgb; // mais ca servait a QUOI qu'elle soit statique ??? 00109 00110 // static int sw; 00111 00112 /* JPR, pour eviter de dupliquer le source */ 00113 00114 #define CCS(Type) \ 00115 if(!fread(&((Type)psi)[0],IdSigDimX(psi)*IdSizeOfType(psi),1,e->fp)) \ 00116 \ 00117 { \ 00118 IdSigFree(psi); \ 00119 printf("DcmRead : echec en lecture Signal\n");\ 00120 return(0); \ 00121 } 00122 00123 #define CCC(Type) \ 00124 if(!fread(&((Type)pco)[0],IdCntDimX(pco)*IdSizeOfType(pco),1,e->fp)) \ 00125 \ 00126 { \ 00127 IdCntFree(pco); \ 00128 printf("DcmRead : echec en lecture Contour\n"); \ 00129 return(0); \ 00130 } 00131 00132 /* pour les anciens codage de contour */ 00133 #define CCC2(Type) \ 00134 if(!fread(&((Type)pco)[0],IdCntDimX(pco)*IdSizeOfType(pco)>>1,1,fp))\ 00135 \ 00136 { \ 00137 IdCntFree(pco); \ 00138 printf("DcmRead :echec en lecture Contour\n"); \ 00139 return(0); \ 00140 } 00141 00142 #define CCI(Type,TailleType) \ 00143 { \ 00144 if (vector != NULL) { /* on a une contrainte de rapidite */ \ 00145 if(!fread(vector,(int)dim[0]*(int)dim[1]*TailleType,1,e->fp)){ \ 00146 printf("DcmRead :echec en lecture Image dans Vecteur \n"); \ 00147 return(0); \ 00148 } \ 00149 } else { \ 00150 for(i=0;i<IdImaDimY(pim);i++){ \ 00151 if(!fread(((Type)pim)[i],IdImaDimX(pim)*IdSizeOfType(pim),1,e->fp)) { \ 00152 printf("echec en lecture Image [i : %d] lgr de %d \n", \ 00153 i,IdImaDimX(pim)*IdSizeOfType(pim)); \ 00154 IdImaFree(pim); \ 00155 return(0); \ 00156 } \ 00157 } \ 00158 } \ 00159 } \ 00160 00161 #define CCV(Type) \ 00162 for(j=0;j<IdVolDimZ(pvo);j++){ \ 00163 /*if (DEBUG) printf("DcmRead CCV: Lecture Plan %d\n", j); */ \ 00164 for(i=0;i<IdVolDimY(pvo);i++) \ 00165 if(!fread(((Type)pvo)[j][i],IdVolDimX(pvo)*IdSizeOfType(pvo),1,e->fp)) \ 00166 { \ 00167 printf("DcmRead CCV : echec en lecture Volume\n"); \ 00168 IdVolFree(pvo); \ 00169 if (DEBUG) printf("DcmRead CCV : Fin Liberation Volume\n");\ 00170 return(0); \ 00171 } \ 00172 } \ 00173 if (DEBUG) printf("DcmRead CCV : Fin Lecture Volume\n"); 00174 00175 #define CCQ(Type) \ 00176 for(k=0;k<IdSeqDimT(pse);k++) \ 00177 for(j=0;j<IdSeqDimZ(pse);j++) \ 00178 for(i=0;i<IdSeqDimY(pse);i++) \ 00179 if(!fread(((Type)pse)[k][j][i],IdSeqDimX(pse)*IdSizeOfType(pse),1,e->fp)) \ 00180 { \ 00181 printf("DcmRead :echec en lecture Sequence\n"); \ 00182 IdSeqFree(pse); \ 00183 if (DEBUG) printf("DcmRead :Fin Liberation Sequence\n");\ 00184 return(0); \ 00185 } 00186 00187 00188 //------------------------------------------------------------------------- 00189 00190 // 00191 // IdDcmReadFileIntoVector ( est un sur-ensemble de IdDcmReadFile ) 00192 // 00193 00231 void *IdDcmReadFileIntoVector(char *filename, int type, int premIm, int dernIm, void * vector) { 00232 00233 ID_DCM_HDR *e; 00234 void * o; 00235 00236 if (DEBUG) printf("----------------------------entree ds IdDcmReadFileIntoVector\n"); 00237 00238 // ------------------------------------------------------------- 00239 // On recupere les info 00240 // ------------------------------------------------------------- 00241 00242 if((e=IdDcmGetHeader(filename))==0) { // POUR LIRE IMAGES LEONARDO, DECOMMENTER 00243 00244 //if((e=IdDcmGetHeaderLeonardo(filename))==0) { 00245 printf ("Gros soucis : %s\n",filename); 00246 return (NULL); 00247 } 00248 if (DEBUG) 00249 printf("DcmReadFileIntoVector : Sortie IdDcmGetHeader\n"); 00250 00251 o = IdDcmReadFileIntoVectorFromDcmHdr(e,type, premIm, dernIm, vector); 00252 IdDcmHdrFree(e); 00253 return (o); 00254 } 00255 00256 00257 //------------------------------------------------------------------------- 00258 // 00259 // IdDcmReadFileIntoVectorFromDcmHdr ( est un sur-ensemble de IdDcmReadFile ) 00260 // 00261 00299 void *IdDcmReadFileIntoVectorFromDcmHdr(ID_DCM_HDR *e, int type, int premIm, int dernIm, void * vector) { 00300 00301 PSIGNAL psi; 00302 PCONTOUR pco; 00303 PPIMAGE pim; 00304 PPPVOLUME pvo; 00305 PPPPSEQUENCE pse; 00306 int i,j,k ; 00307 int nbIm,imNum,nbTotIm = 0,nbFrames; 00308 unsigned short int ndim,nb,ty,nbu, highBit, SamplesPerPixel; 00309 unsigned short int dim[4],usedDim[4]; 00310 long int np,lgrASauter; 00311 unsigned short int typ, typObj = 0; 00312 char *bufbid; 00313 void ** tabIm = NULL; 00314 short int typePasse; 00315 unsigned short int mask5 = 0xffff; 00316 00317 // ------------------- 00318 int JpegLossless; 00319 uint32_t ln; 00320 // ClbJpeg *jpg= NULL; 00321 // -------------------- 00322 00323 psi=0; 00324 pco=0; 00325 pvo=0; 00326 pim=0; 00327 pse=0; 00328 typePasse=type; 00329 if (DEBUG) printf("----------------------------entree ds IdDcmReadFileIntoVectorFromDcmHdr\n"); 00330 00331 00332 if (dernIm < premIm) { 00333 printf("num Derniere Image %d < num Premiere Image %d\n", 00334 premIm,dernIm); 00335 return(0); 00336 } 00337 00338 if (premIm==-1) 00339 premIm=0; 00340 00341 if (DEBUG) 00342 printf("pre %d der %d\n", premIm,dernIm); 00343 00344 typ = -1; 00345 00346 e->ACR_LIBIDO = IdDcmIsAcrLibido(e); 00347 00348 bufbid=_IdDcmReadElement(0x0028,0x0004,e); 00349 00350 if(bufbid!=NULL) { // RGB 00351 if ( (memcmp(bufbid,"RGB ",4)==0) 00352 || 00353 (memcmp(bufbid,"B RG",4)==0) 00354 || 00355 (memcmp(bufbid," BGR",4)==0) 00356 || 00357 (memcmp(bufbid,"GR B",4)==0)) { 00358 00359 // rgb=1; // Mais elle servait a QUOI tout court ?? 00360 00361 printf ("Image RGB ->%s<-\n", bufbid); 00362 } 00363 } 00364 00365 if((ndim=_IdDcmReadElementUSHORT(0x0028,0x0005,e))==0xFFFF) { 00366 ndim=2; // nb de dim de l'objet (IMA par defaut) 00367 } 00368 00369 if ((ndim>4)||(ndim<1)) { 00370 printf ("nb de dim = %d, errone\n",ndim); 00371 return(0); 00372 } else { 00373 if (DEBUG) { 00374 printf ("\t\t\t ndim (0x0028,0x0005) : %d\n",ndim); 00375 } 00376 } 00377 00378 // 10 : nb lignes allouees 00379 // 11 : nb colonnes allouees 00380 // 12 : nb plans alloues ( DICOM, non ACR-NEMA ) 00381 // 13 : nb blocs alloues ( non DICOM, non ACR-NEMA ) 00382 // 15 : nb lignes Utilisees ( non DICOM, non ACR-NEMA ) 00383 // 16 : nb colonnes Utilisees ( non DICOM, non ACR-NEMA ) 00384 // 17 : nb plans Utilises ( non DICOM, non ACR-NEMA ) 00385 // 18 : nb blocs Utilises ( non DICOM, non ACR-NEMA ) 00386 00387 // Lecture nbFrames 00388 00389 if(!(bufbid=_IdDcmReadElement(0x0028,0x0008,e))) { 00390 nbFrames=1; // mono-frame par defaut 00391 } else { 00392 nbFrames=atoi(bufbid); 00393 if (DEBUG) 00394 printf ("\t\t\t nbFrames (0x0028,0x0008) : %d\n",nbFrames); 00395 } 00396 00397 for(i=0;i<ndim;i++) { 00398 if((dim[i]=_IdDcmReadElementUSHORT(0x0028,0x0010+i,e))==0xFFFF) { 00399 IdErrno=IDERR_NON_ACR_FILE; 00400 printf ("IdDcmReadFile : fichier non ACR (0x0028,0x00%d) " 00401 "missing\n",10+i); 00402 return (0); 00403 } else { 00404 if (DEBUG) 00405 printf ("\t\t\t ndim (0x0028,0x0005) : dim[%d]=%d\n",i,dim[i]); 00406 } 00407 } 00408 00409 if (e->ACR_LIBIDO!=1) { 00410 // si c'est une VRAIE image ACR 00411 // on permutte NX et NY ds l'entete LibIDO 00412 int secuDim; 00413 //printf("on permutte NX et NY ds l'entete LibIDO %d \n",e->ACR_LIBIDO); 00414 00415 secuDim = dim[0]; 00416 dim[0] = dim[1]; 00417 dim[1] = secuDim; 00418 } else { 00419 //printf("on ne permutte PAS NX et NY ds l'entete LibIDO\n"); 00420 00421 // Lecture UsedNbX, ... (Uniquement pour ACR LibIDO ...) 00422 00423 for(i=0;i<ndim;i++) 00424 if((usedDim[i]=_IdDcmReadElementUSHORT(0x0028,0x0015+i,e))==0xFFFF) 00425 usedDim[i]=dim[i]; 00426 if (DEBUG) 00427 for(i=0;i<ndim;i++) 00428 printf ("\t\t\t dim[%d]=%d\n",i,usedDim[i]); 00429 } 00430 00431 if((nb=_IdDcmReadElementUSHORT(0x0028,0x0100,e))==0xFFFF) { // nb bits allocated 00432 nb=16 ; 00433 } else { 00434 if (DEBUG) { 00435 printf ("\t\t\t nb (0x0028,0x0100) : %d\n",nb); 00436 } 00437 } 00438 00439 if((nbu=_IdDcmReadElementUSHORT(0x0028,0x0101,e))==0xFFFF) { // nb bits utiles 00440 nbu = nb ; 00441 } else { 00442 if (DEBUG) { 00443 printf ("\t\t\t nbu (0x0028,0x0101) : %d\n",nbu); 00444 } 00445 } 00446 00447 if((highBit=_IdDcmReadElementUSHORT(0x0028,0x0102,e))==0xFFFF) { 00448 // hight bit pas pris en compte 00449 highBit = nb-1 ; 00450 } else { 00451 if (DEBUG) { 00452 printf ("\t\t\t highBit (0x0028,0x0102) : %d\n",highBit); 00453 } 00454 } 00455 00456 mask5 = mask5 >> (nb-nbu); 00457 if((ty=_IdDcmReadElementUSHORT(0x0028,0x0103,e))==0xFFFF) { // signe o/n 00458 IdErrno=IDERR_NON_ACR_FILE; 00459 printf ("fichier non ACR (0x0028,0x0103) missing\n"); 00460 return (0); 00461 } else { 00462 if (DEBUG) { 00463 printf ("\t\t\t signe (0x0028,0x0103) : %d\n",ty); 00464 } 00465 } 00466 00467 if (DEBUG) { 00468 printf("nbit alloues=%d nbit Utiles=%d highbit %d signe=%d\n", 00469 nb,nbu,highBit,ty); 00470 for(i=0;i<ndim;i++) 00471 printf(" dim[%d]= %d; ", i, dim[i]); 00472 printf ("\n"); 00473 } 00474 00475 if (nb==12) { 00476 printf("No luck for you ... nbit=12!... Try : " 00477 " AFFIM BYPASSACR=1 NBIT=12 DIMX=%d DIMY=%d OFFSET= ...\n", 00478 dim[0],dim[1]); 00479 nb=8; 00480 IdErrno=IDERR_NON_ACR_FILE; 00481 return (0); 00482 } 00483 00484 if(ndim==1) typObj=SIG; 00485 // pas de Pb pour les CNT: _IdAcrCheckType trouvera FORCEMENT 00486 // l'element (28,199) ! 00487 if(ndim==2) typObj=IMA; 00488 if(ndim==3) typObj=VOL; 00489 if(ndim==4) typObj=SEQ; 00490 00491 // Lecture SamplesPerPixel (1 : Gray Scale, 3 : RGB) 00492 if((SamplesPerPixel=_IdDcmReadElementUSHORT(0x0028,0x0002,e))==0xFFFF) { 00493 SamplesPerPixel=1; // (Gray Scale par defaut) 00494 } 00495 00496 // on essaye, a titre d'info, de verifier le type, ds le fichier 00497 if (DEBUG)printf ("appel = IdAcrCheckType\n"); 00498 00499 typ=_IdDcmCheckType(e,ty,nb,typObj, SamplesPerPixel); 00500 if (DEBUG)printf ("Sortie = IdAcrCheckType\n"); 00501 00502 if(ndim==1) typObj = typ & IDO_TYPE; // Les CNT ont AUSSI ndim=1 !... 00503 00504 if (typ!=typePasse) 00505 printf ("typeTrouve= %x typePasse= %x\n", typ, typePasse); 00506 00507 typ=typePasse; // Si ca ne cadre pas, on considere que la valeur 00508 // passee est la bonne 00509 00510 np= e->PixelPosition; 00511 00512 if((e->fp=fopen(e->filename,ID_RFILE_BIN))==0) { 00513 printf ("echec ouverture %s\n",e->filename); 00514 return (0); 00515 } 00516 fseek(e->fp,np,SEEK_CUR); // On se positionne sur le début présumé des Pixels 00517 00518 typObj=type&0x000f; // Recomputed from result of _IdAcrCheckType 00519 type =type&0xfff0; 00520 00521 00522 if ( premIm != -2) { // on n'est pas ds MultiFrame 00523 lgrASauter = IdTypeSize(type); 00524 00525 for(i=0;i<ndim;i++) 00526 lgrASauter = lgrASauter * dim[i]; // taille d'un Frame 00527 00528 lgrASauter = lgrASauter * premIm; // si on veut ignorer les Frames de debut 00529 nbTotIm=nbFrames; 00530 } 00531 00532 if (dernIm==-1) 00533 dernIm=nbTotIm-1; 00534 00535 nbIm = dernIm - premIm +1; 00536 00537 if ( (JpegLossless=IdDcmIsJpegLossless(e)) ) { // si Jpeg Lossless, on ne tente pas d'aventure 00538 /* 00539 premIm = 1; 00540 dernIm=nbTotIm-1; 00541 nbIm = dernIm - premIm +1; 00542 lgrASauter = 0; 00543 */ 00544 } 00545 00546 00547 00548 //------------------------------------------------------------- 00549 // Fin recup. info pour pouvoir Allouer 00550 //------------------------------------------------------------- 00551 00552 if (vector == NULL) { 00553 tabIm = (void **) calloc((nbIm+1),sizeof(void *)); 00554 if(!tabIm) { 00555 printf("Echec Alloc Table d Images : premIm %d dernIm %d nbIm %d\n", 00556 premIm, dernIm,nbIm); 00557 return NULL; 00558 } 00559 } 00560 if (DEBUG) printf("OK Alloc Table d Images\n"); 00561 00562 //------------------------------------------------------------- 00563 // Pour CHAQUE 'Objet' du Fichier 00564 //------------------------------------------------------------- 00565 for(imNum=premIm;imNum<dernIm+1;imNum++) { 00566 if (DEBUG) 00567 printf("imNum %d, typObj %x\n",imNum,typObj); 00568 switch(typObj) { 00569 00570 case SIG: 00571 if (DEBUG) 00572 printf("SIGNAL\n"); 00573 00574 if(0==(((PSIGNAL *)tabIm)[imNum-premIm]=psi 00575 =IdSigAlloc((int)dim[0],typ))) { 00576 printf("echec alloc Signal\n"); 00577 return(0); 00578 } 00579 switch(type) { // 4 derniers bits : SIG, IMA, VOL, SEQ 00580 case TY_UCHAR: 00581 CCS(PSIGNAL_UCHAR); 00582 break; 00583 case TY_CHAR: 00584 CCS(PSIGNAL_CHAR); 00585 break; 00586 case TY_USHORT: 00587 CCS(PSIGNAL_USHORT); 00588 if(e->sw) _Swap(psi,21,(int)dim[0],TY_USHORT); 00589 break; 00590 case TY_SHORT: 00591 CCS(PSIGNAL_SHORT); 00592 if(e->sw) _Swap(psi,21,(int)dim[0],TY_SHORT); 00593 break; 00594 case TY_LONG: 00595 CCS(PSIGNAL_LONG); 00596 if(e->sw) _Swap(psi,e->sw,(int)dim[0],TY_LONG); 00597 break; 00598 case TY_ULONG: 00599 CCS(PSIGNAL_ULONG); 00600 if(e->sw) _Swap(psi,e->sw,(int)dim[0],TY_ULONG); 00601 break; 00602 case TY_FLOAT: 00603 CCS(PSIGNAL_FLOAT); 00604 break; 00605 case TY_DOUBLE: 00606 CCS(PSIGNAL_DOUBLE); 00607 break; 00608 case TY_RGB: 00609 CCS(PSIGNAL_RGB); 00610 break; 00611 00612 // revoir le pb du Swap des complexes.... 00613 case TY_COMPLEX_UCHAR: 00614 CCS(PSIGNAL_COMPLEX_UCHAR); 00615 break; 00616 case TY_COMPLEX_CHAR: 00617 CCS(PSIGNAL_COMPLEX_CHAR); 00618 break; 00619 case TY_COMPLEX_USHORT: 00620 CCS(PSIGNAL_COMPLEX_USHORT); 00621 if(e->sw) _Swap(psi,21,(int)dim[0],TY_COMPLEX_USHORT); 00622 break; 00623 case TY_COMPLEX_SHORT: 00624 CCS(PSIGNAL_COMPLEX_SHORT); 00625 if(e->sw) _Swap(psi,21,(int)dim[0],TY_COMPLEX_SHORT); 00626 break; 00627 case TY_COMPLEX_LONG: 00628 CCS(PSIGNAL_COMPLEX_LONG); 00629 if(e->sw) _Swap(psi,e->sw,(int)dim[0],TY_COMPLEX_LONG); 00630 break; 00631 case TY_COMPLEX_ULONG: 00632 CCS(PSIGNAL_COMPLEX_ULONG); 00633 if(e->sw) _Swap(psi,e->sw,(int)dim[0],TY_COMPLEX_ULONG); 00634 break; 00635 case TY_COMPLEX: 00636 CCS(PSIGNAL_COMPLEX); 00637 break; 00638 case TY_COMPLEX_FLOAT: 00639 CCS(PSIGNAL_COMPLEX_FLOAT); 00640 break; 00641 case TY_COMPLEX_DOUBLE: 00642 CCS(PSIGNAL_COMPLEX_DOUBLE); 00643 break; 00644 } // end switch(type) 00645 00646 _IdSigPrivate(psi)->_fichier= 00647 (char *)malloc(strlen(e->filename)+1); 00648 if(premIm == -2) 00649 strcpy(_IdImaPrivate(psi)->_fichier,e->filename); 00650 else 00651 sprintf(_IdImaPrivate(psi)->_fichier,"%s[%d]", 00652 e->filename,imNum); 00653 00654 _IdSigPrivate(psi)->_message= 00655 (char *)malloc(strlen(e->_message)+1); 00656 strcpy(_IdSigPrivate(psi)->_message,e->_message); 00657 IdSigSetUsedNbX(psi,usedDim[0]); 00658 break; 00659 00660 case CNT: 00661 if (DEBUG) 00662 printf("CONTOUR\n"); 00663 00664 if(0==(((PCONTOUR *)tabIm)[imNum-premIm]=pco=IdCntAlloc((int)dim[0],typ))) 00665 00666 { printf("echec alloc Contour\n"); 00667 return(0); 00668 } 00669 00670 switch(type) /* 4 derniers bits : SIG, CNT, IMA, VOL, SEQ */ 00671 { 00672 00673 case TY_UCHAR: CCC(PCONTOUR_UCHAR); break; 00674 case TY_CHAR: CCC(PCONTOUR_CHAR); break; 00675 case TY_USHORT: CCC(PCONTOUR_USHORT); 00676 if(e->sw)_Swap(pco,e->sw,dim[0],TY_USHORT); /* VOIR le Pb du SWAP */ 00677 break; 00678 case TY_SHORT: CCC(PCONTOUR_SHORT); 00679 if(e->sw)_Swap(pco,e->sw,dim[0],TY_SHORT); 00680 break; 00681 case TY_LONG: CCC(PCONTOUR_LONG); 00682 if(e->sw)_Swap(pco,e->sw,dim[0],TY_LONG); 00683 break; 00684 case TY_ULONG: CCC(PCONTOUR_ULONG); 00685 if(e->sw)_Swap(pco,e->sw,dim[0],TY_ULONG); 00686 break; 00687 00688 case TY_FLOAT: CCC(PCONTOUR_FLOAT); break; 00689 case TY_DOUBLE: CCC(PCONTOUR_DOUBLE); break; 00690 00691 } 00692 00693 _IdCntPrivate(pco)->_fichier=(char *)malloc(strlen(e->filename)+1); 00694 if(premIm == -2) strcpy(_IdImaPrivate(pco)->_fichier,e->filename); 00695 else sprintf(_IdImaPrivate(pco)->_fichier,"%s[%d]",e->filename,imNum); 00696 00697 _IdCntPrivate(pco)->_message=(char *)malloc(strlen(e->_message)+1); 00698 strcpy(_IdCntPrivate(pco)->_message,e->_message); 00699 00700 IdCntSetUsedNbX(pco,usedDim[0]); 00701 break; 00702 00703 case IMA: 00704 if (DEBUG) 00705 printf("IMAGE %d %d\n",(int)dim[0],(int)dim[1]); 00706 00707 if(vector==NULL) { 00708 if(0==(((PPIMAGE *)tabIm)[imNum-premIm]= 00709 pim=IdImaAlloc((int)dim[0],(int)dim[1],typ))) { 00710 printf("echec alloc Image \n"); 00711 return(0); 00712 } 00713 if (DEBUG) 00714 printf("Succes alloc Image nX %d nY %d \n",IdImaDimX(pim),IdImaDimY(pim)); 00715 } 00716 00717 switch(type) 00718 { 00719 case TY_UCHAR: CCI(PPIMAGE_UCHAR, TA_TY_UCHAR); 00720 break; 00721 00722 case TY_CHAR: CCI(PPIMAGE_CHAR, TA_TY_CHAR); 00723 break; 00724 00725 case TY_USHORT: 00726 00727 if(e->__TrueDicom && !IdDcmIsUncompressed(e)) { 00728 00729 // skip to the beggining of the pixels 00730 00731 fseek(e->fp,4,SEEK_CUR); 00732 fread(&ln,4,1,e->fp); 00733 if(e->sw) 00734 ln=_IdDcmSWAP_LONG(ln,e->sw); 00735 //if (DEBUG) 00736 printf ("ln %d\n",ln); 00737 fseek(e->fp,ln,SEEK_CUR); 00738 fseek(e->fp,4,SEEK_CUR); 00739 fread(&ln,4,1,e->fp); 00740 if(e->sw) 00741 ln=_IdDcmSWAP_LONG(ln,e->sw); 00742 //if (DEBUG) 00743 printf ("ln image comprimée %d\n",ln); 00744 00745 00746 printf("Sorry, Bits Stored = %d not yet taken into account\n",nbu); 00747 return NULL; 00748 00749 } else { // Old ACR-NEMA or uncompressed 00750 00751 CCI(PPIMAGE_USHORT, TA_TY_USHORT); 00752 if(e->sw) { 00753 if(DEBUG) printf("_Swap\n"); 00754 00755 _Swap(pim[0],e->sw,(int)dim[0]*(int)dim[1],TY_USHORT); 00756 if (DEBUG) printf("\t\t\tOn swappe\n"); 00757 } // end if(e->sw) 00758 if (nbu!=nb) /* GB */ 00759 for(i=0;i<IdImaDimY(pim);i++) 00760 for(j=0;j<IdImaDimX(pim);j++) 00761 ((PPIMAGE_USHORT)pim)[i][j] = 00762 (((PPIMAGE_USHORT)pim)[i][j] >> (nbu-highBit-1)) & mask5; 00763 } // end else Old ACR-NEMA 00764 00765 00766 break; 00767 00768 case TY_SHORT: CCI(PPIMAGE_SHORT,TA_TY_SHORT); // les 16 bits 00769 if(e->sw)_Swap(pim[0],21,dim[0]*dim[1],TY_SHORT); 00770 break; 00771 00772 case TY_ULONG: CCI(PPIMAGE_ULONG,TA_TY_ULONG); 00773 if(e->sw)_Swap(pim[0],e->sw,dim[0]*dim[1],TY_ULONG); 00774 break; 00775 00776 case TY_LONG: CCI(PPIMAGE_LONG,TA_TY_LONG); 00777 if(e->sw)_Swap(pim[0],e->sw,dim[0]*dim[1],TY_LONG); 00778 break; 00779 00780 case TY_FLOAT: CCI(PPIMAGE_FLOAT,TA_TY_FLOAT); 00781 break; 00782 00783 case TY_DOUBLE: CCI(PPIMAGE_DOUBLE,TA_TY_DOUBLE); 00784 break; 00785 00786 case TY_RGB: CCI(PPIMAGE_RGB,TA_TY_RGB); 00787 break; 00788 00789 case TY_COMPLEX_UCHAR: CCI(PPIMAGE_COMPLEX_UCHAR,TA_TY_COMPLEX_UCHAR); 00790 break; 00791 00792 case TY_COMPLEX_CHAR: CCI(PPIMAGE_COMPLEX_CHAR,TA_TY_COMPLEX_CHAR); 00793 break; 00794 00795 case TY_COMPLEX_USHORT: CCI(PPIMAGE_COMPLEX_USHORT, TA_TY_COMPLEX_USHORT); 00796 if(e->sw)_Swap(pim[0],21,dim[0]*dim[1],TY_COMPLEX_USHORT); 00797 break; 00798 00799 case TY_COMPLEX_SHORT: CCI(PPIMAGE_COMPLEX_SHORT, TA_TY_COMPLEX_SHORT); 00800 if(e->sw)_Swap(pim[0],21,dim[0]*dim[1],TY_COMPLEX_SHORT); 00801 break; 00802 00803 case TY_COMPLEX_ULONG: CCI(PPIMAGE_COMPLEX_ULONG, TA_TY_COMPLEX_ULONG); 00804 if(e->sw)_Swap(pim[0],e->sw,dim[0]*dim[1],TY_COMPLEX_ULONG); 00805 break; 00806 00807 case TY_COMPLEX_LONG: CCI(PPIMAGE_COMPLEX_LONG, TA_TY_COMPLEX_LONG); 00808 if(e->sw)_Swap(pim[0],e->sw,dim[0]*dim[1],TY_COMPLEX_LONG); 00809 break; 00810 00811 case TY_COMPLEX_FLOAT: CCI(PPIMAGE_COMPLEX_FLOAT, TA_TY_COMPLEX_FLOAT); 00812 break; 00813 00814 case TY_COMPLEX_DOUBLE: CCI(PPIMAGE_COMPLEX_DOUBLE, TA_TY_COMPLEX_DOUBLE); 00815 break; 00816 00817 } /* end switch Type*/ 00818 00819 if (vector == NULL) { 00820 _IdImaPrivate(pim)->_fichier=(char *)malloc(strlen(e->filename)+1); 00821 if(premIm == -2) strcpy (_IdImaPrivate(pim)->_fichier,e->filename); 00822 else sprintf(_IdImaPrivate(pim)->_fichier,"%s[%d]",e->filename,imNum); 00823 00824 _IdImaPrivate(pim)->_message=(char *)malloc(strlen(e->_message)+1); 00825 strcpy(_IdImaPrivate(pim)->_message,e->_message); 00826 00827 IdImaSetUsedNbX(pim,usedDim[0]); 00828 IdImaSetUsedNbY(pim,usedDim[1]); 00829 } 00830 if (DEBUG) printf("sortie swich case IMA\n"); 00831 00832 break; 00833 00834 case VOL: 00835 if (DEBUG) 00836 printf("VOLUME\n"); 00837 00838 /*if(0==(pvo=IdVolAlloc((int)dim[0],(int)dim[1],(int)dim[2],typ)))*/ 00839 00840 if(0==(((PPPVOLUME *)tabIm)[imNum-premIm] = pvo = 00841 IdVolAlloc((int)dim[0],(int)dim[1],(int)dim[2],typ))) 00842 { printf ("echec alloc Volume\n"); 00843 return(0); 00844 } else { 00845 if (DEBUG) 00846 printf("Succes Alloc VOLUME %d %d %d \n",(int)dim[0],(int)dim[1],(int)dim[2]); 00847 } 00848 00849 switch(type) { 00850 case TY_UCHAR: CCV(PPPVOLUME_UCHAR); break; 00851 case TY_CHAR: CCV(PPPVOLUME_CHAR); break; 00852 case TY_USHORT: CCV(PPPVOLUME_USHORT); 00853 if(e->sw)_Swap(pvo[0][0],21,dim[0]*dim[1]*dim[2],TY_USHORT); 00854 break; 00855 case TY_SHORT: CCV(PPPVOLUME_SHORT); 00856 if(e->sw)_Swap(pvo[0][0],21,dim[0]*dim[1]*dim[2],TY_SHORT); 00857 break; 00858 case TY_ULONG: CCV(PPPVOLUME_ULONG); 00859 if(e->sw)_Swap(pvo[0][0],e->sw,dim[0]*dim[1]*dim[2],TY_ULONG); 00860 break; 00861 case TY_LONG: CCV(PPPVOLUME_LONG); 00862 if(e->sw)_Swap(pvo[0][0],e->sw,dim[0]*dim[1]*dim[2],TY_LONG); 00863 break; 00864 case TY_FLOAT: CCV(PPPVOLUME_FLOAT); break; 00865 case TY_DOUBLE: CCV(PPPVOLUME_DOUBLE); break; 00866 00867 case TY_RGB: CCV(PPPVOLUME_RGB); break; 00868 00869 case TY_COMPLEX_UCHAR: CCV(PPPVOLUME_COMPLEX_UCHAR); break; 00870 case TY_COMPLEX_CHAR: CCV(PPPVOLUME_COMPLEX_CHAR); break; 00871 case TY_COMPLEX_USHORT: CCV(PPPVOLUME_COMPLEX_USHORT); 00872 if(e->sw)_Swap(pvo[0][0],21,dim[0]*dim[1]*dim[2],TY_COMPLEX_USHORT); 00873 break; 00874 case TY_COMPLEX_SHORT: CCV(PPPVOLUME_COMPLEX_SHORT); 00875 if(e->sw)_Swap(pvo[0][0],21,dim[0]*dim[1]*dim[2],TY_COMPLEX_SHORT); 00876 break; 00877 case TY_COMPLEX_ULONG: CCV(PPPVOLUME_COMPLEX_ULONG); 00878 if(e->sw)_Swap(pvo[0][0],e->sw,dim[0]*dim[1]*dim[2],TY_COMPLEX_ULONG); 00879 break; 00880 case TY_COMPLEX_LONG: CCV(PPPVOLUME_COMPLEX_LONG); 00881 if(e->sw)_Swap(pvo[0][0],e->sw,dim[0]*dim[1]*dim[2],TY_COMPLEX_LONG); 00882 break; 00883 case TY_COMPLEX : CCV(PPPVOLUME_COMPLEX); break; 00884 case TY_COMPLEX_FLOAT: CCV(PPPVOLUME_COMPLEX_FLOAT); break; 00885 case TY_COMPLEX_DOUBLE: CCV(PPPVOLUME_COMPLEX_DOUBLE); break; 00886 } 00887 00888 if (DEBUG) printf("fin switch\n"); 00889 if (DEBUG) printf(" lgr champ 'fichier' %d\n",strlen(e->filename)+1 ); 00890 _IdVolPrivate(pvo)->_fichier=(char *)malloc(strlen(e->filename)+1); 00891 00892 if(!(_IdVolPrivate(pvo)->_fichier ) ) { 00893 printf("DcmRead : Echec Alloc champ 'nom fichier'\n"); 00894 } 00895 if(premIm == -2) strcpy(_IdImaPrivate(pvo)->_fichier,e->filename); 00896 else sprintf(_IdImaPrivate(pvo)->_fichier,"%s[%d]",e->filename,imNum); 00897 00898 _IdVolPrivate(pvo)->_message=(char *)malloc(strlen(e->_message)+1); 00899 if(!(_IdVolPrivate(pvo)->_message ) ) { 00900 printf("DcmRead : Echec Alloc champ 'message'\n"); 00901 } 00902 strcpy(_IdVolPrivate(pvo)->_message,e->_message); 00903 IdVolSetUsedNbX(pvo,usedDim[0]); 00904 IdVolSetUsedNbY(pvo,usedDim[1]); 00905 IdVolSetUsedNbZ(pvo,usedDim[2]); 00906 00907 if (DEBUG) printf("fin lect VOLUME\n"); 00908 00909 break; 00910 00911 case SEQ: 00912 if (DEBUG) 00913 printf("SEQUENCE\n"); 00914 00915 if(0==(((PPPPSEQUENCE * )tabIm)[imNum-premIm]=pse=IdSeqAlloc((int)dim[0],(int)dim[1],(int)dim[2],(int)dim[3],typ))) 00916 if(0==(pse=IdSeqAlloc((int)dim[0],(int)dim[1],(int)dim[2],(int)dim[3],typ))) { 00917 printf ("echec alloc Sequence\n"); 00918 return(0); 00919 } 00920 switch(type) 00921 { 00922 case TY_UCHAR: CCQ(PPPPSEQUENCE_UCHAR); break; 00923 case TY_CHAR: CCQ(PPPPSEQUENCE_CHAR); break; 00924 case TY_USHORT: CCQ(PPPPSEQUENCE_USHORT); 00925 if(e->sw)_Swap(pse[0][0][0],21,dim[0]*dim[1]*dim[2]*dim[3],TY_USHORT); 00926 break; 00927 case TY_SHORT: CCQ(PPPPSEQUENCE_SHORT); 00928 if(e->sw)_Swap(pse[0][0][0],21,dim[0]*dim[1]*dim[2]*dim[3],TY_SHORT); 00929 break; 00930 case TY_ULONG: CCQ(PPPPSEQUENCE_ULONG); 00931 if(e->sw)_Swap(pse[0][0][0],e->sw,dim[0]*dim[1]*dim[2]*dim[3],TY_ULONG); 00932 break; 00933 case TY_LONG: CCQ(PPPPSEQUENCE_LONG); 00934 if(e->sw)_Swap(pse[0][0][0],e->sw,dim[0]*dim[1]*dim[2]*dim[3],TY_LONG); 00935 break; 00936 case TY_FLOAT: CCQ(PPPPSEQUENCE_FLOAT); break; 00937 case TY_DOUBLE: CCQ(PPPPSEQUENCE_DOUBLE); break; 00938 00939 case TY_RGB: CCQ(PPPPSEQUENCE_RGB); break; 00940 00941 case TY_COMPLEX_UCHAR: CCQ(PPPPSEQUENCE_COMPLEX_UCHAR); break; 00942 case TY_COMPLEX_CHAR: CCQ(PPPPSEQUENCE_COMPLEX_CHAR); break; 00943 case TY_COMPLEX_USHORT: CCQ(PPPPSEQUENCE_COMPLEX_USHORT); 00944 if(e->sw)_Swap(pse[0][0][0],21,dim[0]*dim[1]*dim[2]*dim[3],TY_COMPLEX_USHORT); 00945 break; 00946 case TY_COMPLEX_SHORT: CCQ(PPPPSEQUENCE_COMPLEX_SHORT); 00947 if(e->sw)_Swap(pse[0][0][0],21,dim[0]*dim[1]*dim[2]*dim[3],TY_COMPLEX_SHORT); 00948 break; 00949 case TY_COMPLEX_ULONG: CCQ(PPPPSEQUENCE_COMPLEX_ULONG); 00950 if(e->sw)_Swap(pse[0][0][0],e->sw,dim[0]*dim[1]*dim[2]*dim[3],TY_COMPLEX_ULONG); 00951 break; 00952 case TY_COMPLEX_LONG: CCQ(PPPPSEQUENCE_COMPLEX_LONG); 00953 if(e->sw)_Swap(pse[0][0][0],e->sw,dim[0]*dim[1]*dim[2]*dim[3],TY_COMPLEX_LONG); 00954 break; 00955 case TY_COMPLEX : CCQ(PPPPSEQUENCE_COMPLEX); break; 00956 case TY_COMPLEX_FLOAT: CCQ(PPPPSEQUENCE_COMPLEX_FLOAT); break; 00957 case TY_COMPLEX_DOUBLE: CCQ(PPPPSEQUENCE_COMPLEX_DOUBLE); break; 00958 00959 } 00960 00961 _IdSeqPrivate(pse)->_fichier=(char *)malloc(strlen(e->filename)+1); 00962 if(premIm == -2) strcpy(_IdImaPrivate(pse)->_fichier,e->filename); 00963 else sprintf(_IdImaPrivate(pse)->_fichier,"%s[%d]",e->filename,imNum); 00964 00965 _IdSeqPrivate(pse)->_message=(char *)malloc(strlen(e->_message)+1); 00966 strcpy(_IdSeqPrivate(pse)->_message,e->_message); 00967 00968 IdSeqSetUsedNbX(pse,usedDim[0]); 00969 IdSeqSetUsedNbY(pse,usedDim[1]); 00970 IdSeqSetUsedNbZ(pse,usedDim[2]); 00971 IdSeqSetUsedNbT(pse,usedDim[3]); 00972 break; 00973 00974 } /* end switch typObj */ 00975 00976 } /* end for : On a parcouru tous les 'objets' du fichier */ 00977 00978 fclose(e->fp); 00979 return tabIm; 00980 } 00981 00982 00983 /* ----------------------------------------------------------------------- */ 00994 void *IdDcmReadFile(char * filename, int type) { 00995 void ** tabObj=NULL; 00996 00997 if (DEBUG) printf("----------------------------entree ds IdDcmReadFile\n"); 00998 00999 tabObj=IdDcmReadFileIntoVector(filename, type,-2, -2, NULL); 01000 01001 if (tabObj==NULL) 01002 return (NULL); 01003 else 01004 return(tabObj[0]); 01005 } 01006 01007 01008 /* ----------------------------------------------------------------------- */ 01018 void *IdDcmReadFileFromDcmHdr(ID_DCM_HDR *e, int type) { 01019 void ** tabObj=NULL; 01020 01021 if (DEBUG) printf("----------------------------entree ds IdDcmReadFileFromDcmHdr\n"); 01022 01023 tabObj=IdDcmReadFileIntoVectorFromDcmHdr(e, type,-2, -2, NULL); 01024 01025 if (tabObj==NULL) 01026 return (NULL); 01027 else 01028 return(tabObj[0]); 01029 } 01030 01031 //------------------------------------------------------------------------- 01032 // 01033 // IdDcmMultiFrameReadFile est une encapsulation de IdDcmReadFileIntoVector 01034 // 01035 01052 void *IdDcmMultiFrameReadFile(char * filename, int type, int numPremIm, int numDernIm) { 01053 void ** tabObj=NULL; 01054 01055 if (DEBUG) printf("----------------------------entree ds IdDcmMultiFrameReadFile\n"); 01056 01057 tabObj=IdDcmReadFileIntoVector(filename,type, numPremIm, numDernIm, NULL); 01058 01059 if (tabObj==NULL) 01060 return (NULL); 01061 else 01062 return(tabObj[0]); 01063 } 01064 01065 // ------------------------------------------------------------------------------- 01066 01067 void *IdDcmMultiFrameReadFileFromDcmHdr(ID_DCM_HDR *e, int type, int numPremIm, int numDernIm) { 01068 void ** tabObj=NULL; 01069 01070 if (DEBUG) printf("----------------------------entree ds IdDcmMultiFrameReadFileFromDcmHdr\n"); 01071 01072 tabObj=IdDcmReadFileIntoVectorFromDcmHdr(e,type, numPremIm, numDernIm, NULL); 01073 01074 if (tabObj==NULL) 01075 return (NULL); 01076 else 01077 return(tabObj[0]); 01078 } 01079 01080 01081 /* ------------------------------------------------------------------------------------ */ 01082 01083 int IdDcmIsAcrLibido(ID_DCM_HDR *e) { 01084 01085 return(e->ACR_LIBIDO); 01086 } 01087 01088 01089 01090 // ------------------------------------------------------------------------------------ 01091 01092 01104 char * _IdDcmReadElement(int gr, int num, ID_DCM_HDR *e) { 01105 01106 _ID_DCM_ELEM *ple; 01107 PLIST_ELEMENT plelem; 01108 plelem = IdLstFirst(e->plist); 01109 01110 if (DEBUG) printf("\t\t\t\t\trecherche (1) gr %x num %x\n",gr,num); 01111 01112 while(plelem) { 01113 ple= IdLstPtrObj(plelem); // le _ID_DCM_ELEM pointé par le PLIST_ELEMENT 01114 01115 if (ple->Gr == gr) break; 01116 if (ple->Gr > gr) { 01117 return(NULL); 01118 } 01119 plelem = IdLstNext(plelem); 01120 } 01121 while(plelem) { 01122 ple= IdLstPtrObj(plelem); // le _ID_DCM_ELEM pointé par le PLIST_ELEMENT 01123 01124 if(ple->Num == num) break; 01125 if(ple->Num > num) { 01126 return(NULL); 01127 } 01128 plelem = IdLstNext(plelem); 01129 } 01130 01131 return(ple->valeurElem); 01132 } 01133 01134 // ------------------------------------------------------------------------------------ 01135 01136 01137 // ------------------------------------------------------------------------------------ 01138 01139 01153 char * _IdDcmReadElementNoSQ(int gr, int num, ID_DCM_HDR *e) { 01154 01155 _ID_DCM_ELEM *ple; 01156 PLIST_ELEMENT plelem; 01157 int trouve = 0; 01158 01159 plelem = IdLstFirst(e->plist); 01160 01161 if (DEBUG) printf("\t\t\t\t\trecherche IdDcmReadElementNoSQ (1) gr %x num %x\n",gr,num); 01162 01163 while(plelem) { 01164 ple= IdLstPtrObj(plelem); // le _ID_DCM_ELEM pointé par le PLIST_ELEMENT 01165 01166 if (ple->Gr == gr) { 01167 trouve =1; 01168 break; 01169 } 01170 plelem = IdLstNext(plelem); 01171 } 01172 01173 if (trouve ==0) return (NULL); 01174 01175 trouve = 0; 01176 01177 while(plelem) { 01178 ple= IdLstPtrObj(plelem); // le _ID_DCM_ELEM pointé par le PLIST_ELEMENT 01179 01180 if(ple->Num == num) { 01181 trouve =1; 01182 break; 01183 } 01184 plelem = IdLstNext(plelem); 01185 } 01186 01187 if (trouve ==0) { 01188 return (NULL); 01189 } else { 01190 return(ple->valeurElem); 01191 } 01192 } 01193 01194 // ------------------------------------------------------------------------------------ 01195 01207 unsigned short _IdDcmReadElementUSHORT(int gr, int num, ID_DCM_HDR *e) { 01208 01209 _ID_DCM_ELEM *ple; 01210 PLIST_ELEMENT plelem; 01211 01212 if(!e) { 01213 printf("DCM_HDR non alloué\n"); 01214 return(0xFFFF); 01215 } 01216 01217 plelem = IdLstFirst(e->plist); 01218 if (!plelem) { 01219 printf("ID_DCM_HDR : Liste vide\n"); 01220 return(0xFFFF); 01221 } 01222 01223 if (DEBUG) printf("\t\t\t_IdDcmReadElementUSHORT\t\trecherche (1) gr %x num %x\n",gr,num); 01224 01225 while(plelem) { 01226 ple= IdLstPtrObj(plelem); // le _ID_DCM_ELEM pointé par le PLIST_ELEMENT 01227 01228 //if (DEBUG) printf(" on est sur gr %04x \n",ple->Gr); 01229 01230 if (ple->Gr == gr) break; 01231 if ( (ple->Gr > gr) && (ple->Gr !=0xFFFE) ) { 01232 if (DEBUG) printf(" gr %04x trouve\n",ple->Gr); 01233 return(0xFFFF); 01234 } 01235 plelem = IdLstNext(plelem); 01236 } 01237 01238 while(plelem) { 01239 ple= IdLstPtrObj(plelem); // le _ID_DCM_ELEM pointé par le PLIST_ELEMENT 01240 01241 //if (DEBUG) printf(" on est sur num %04x \n",ple->Num); 01242 01243 if(ple->Num == num) break; 01244 if(ple->Num > num) { 01245 if (DEBUG) printf(" num %04x trouve\n",ple->Num); 01246 return(0xFFFF); 01247 } 01248 plelem = IdLstNext(plelem); 01249 } 01250 // POURQUOI ple->valShort N'EST PAS INITIALISE? 01251 return (str2num(ple->valeurElem,unsigned short int)); 01252 } 01253 01254 01255 01256 int _IdDcmGetElementLength(int gr, int num, ID_DCM_HDR *e) { 01257 01258 _ID_DCM_ELEM *ple; 01259 PLIST_ELEMENT plelem; 01260 01261 plelem = IdLstFirst(e->plist); 01262 01263 if (DEBUG) printf("\t\t\t\t\trecherche Lgr(1) gr %x num %x\n",gr,num); 01264 01265 while(plelem) { 01266 ple= IdLstPtrObj(plelem); // le _ID_DCM_ELEM pointé par le PLIST_ELEMENT 01267 01268 if (ple->Gr == gr) break; 01269 if ( (ple->Gr > gr) && (ple->Gr !=0xFFFE) ) { 01270 if (DEBUG) printf(" gr %04x trouve\n",ple->Gr); 01271 //return(0xFFFFFFFF); 01272 return(0); 01273 } 01274 plelem = IdLstNext(plelem); 01275 } 01276 01277 while(plelem) { 01278 ple= IdLstPtrObj(plelem); // le _ID_DCM_ELEM pointé par le PLIST_ELEMENT 01279 01280 if(ple->Num == num) break; 01281 if(ple->Num > num) { 01282 if (DEBUG) printf(" num %04x trouve\n",ple->Num); 01283 //return(0xFFFFFFFF); 01284 return(0); 01285 } 01286 plelem = IdLstNext(plelem); 01287 } 01288 return (ple->LgrElem); 01289 } 01290 01291 01292 /* 01293 * ------------------------------------------------------------------------------------------------------ 01294 */ 01295 01296 /* ------------------------------------------------------------ */ 01297 /* A partir d'un fichier Acr deja ouvert, */ 01298 /* ds lequel on deja lu bufbid (8,10) */ 01299 /* et ty (signe : ( 28,103) */ 01300 /* on cherche le type stocke ( 28,105 ou 28,199 ) */ 01301 /* ou le type deduit ( a partir de nb et de ty ) */ 01302 /* */ 01303 /* retourne -1 si rien trouve ou rien deduit */ 01304 /* ------------------------------------------------------------ */ 01305 01306 short int _IdDcmCheckType(ID_DCM_HDR *e, int ity, int inb, int itypObj, int SamplesPerPixel) 01307 { 01308 long int lgrMessage; 01309 short int typ; 01310 short int ty=ity; 01311 short int nb=inb; 01312 short int typObj=itypObj; 01313 char * bufbid; 01314 01315 if (nb==12) nb=8; 01316 01317 if (DEBUG) printf ("ACR LIBIDO %d\n",e->ACR_LIBIDO); 01318 typ= -1; 01319 if ( e->ACR_LIBIDO ) { 01320 if (DEBUG) printf ("IdDcmCheckType : on a trouve ACR LIBIDO\n"); 01321 bufbid=_IdDcmReadElement(0x0028,0x0199,e);/* on cherche 28,199 (LibIDO type)*/ 01322 if (!bufbid) 01323 typ=-1; 01324 else { 01325 typ=str2num(bufbid, short int); 01326 if (DEBUG) printf ("IdDcmCheckType : type lu sur disque %x\n",typ); 01327 } 01328 } 01329 01330 if (typ==-1) { /* on n a rien trouve */ 01331 /* (ce n'EST PAS un fichier ACR-LibIDO nouvelle version) */ 01332 /* debut usine a gaz */ 01333 01334 if (SamplesPerPixel == 3) nb=24; 01335 01336 if((nb==TA_TY_UCHAR*8) && (ty==0))typ = typObj | TY_UCHAR; 01337 else if((nb==TA_TY_CHAR*8) && (ty==1))typ = typObj | TY_CHAR; 01338 else if((nb==TA_TY_USHORT*8)&& (ty==0))typ = typObj | TY_USHORT; 01339 else if((nb==TA_TY_SHORT*8) && (ty==1))typ = typObj | TY_SHORT; 01340 else if((nb==TA_TY_ULONG*8) && (ty==0))typ = typObj | TY_ULONG; 01341 else if((nb==TA_TY_LONG*8) && (ty==1))typ = typObj | TY_LONG; 01342 01343 01344 01345 // ATTENTION : les representations internes des types FLOAT et DOUBLE 01346 // sont machine-dependent 01347 01348 //les anciens float et doubles n etaient pas signes.... */ 01349 01350 else if ((nb==TA_TY_FLOAT*8) ) typ = typObj | TY_FLOAT; 01351 else if ((nb==TA_TY_DOUBLE*8) ) typ = typObj | TY_DOUBLE; 01352 else if ((nb==3*TA_TY_UCHAR*8)&&(ty==0)) typ = typObj | TY_RGB; 01353 else if ((nb==TA_TY_COMPLEX_DOUBLE*8)) typ = typObj | TY_COMPLEX_DOUBLE; 01354 01355 printf("typ %x\n",typ); 01356 01357 01358 if (DEBUG) printf ("IdDcmCheckType : Entete : nb=%d typObj=%x; Type deduit=%x\n", 01359 nb,typObj,typ); 01360 01361 /* ce N'EST PAS un fichier LibIDO */ 01362 01363 e->_message=(char *)malloc(10); /* pour eviter des soucis ulterieurs */ 01364 lgrMessage=0; 01365 01366 } else { /* fin usine a gaz */ 01367 01368 /* C'EST un fichier LibIDO */ 01369 /* on regarde si 'message' (28,198)contient qq chose */ 01370 lgrMessage= _IdDcmGetElementLength(0x0028,0x0198,e); 01371 01372 if (lgrMessage !=0) { 01373 if (DEBUG) printf ("lgrMessage %ld\n", lgrMessage); 01374 e->_message=(char *)malloc(lgrMessage+1); 01375 if (!e->_message) { 01376 printf("Echec alloc _message (lgr %d)\n",lgrMessage); 01377 e->_message=(char *)malloc(10); /* pour eviter des soucis ulterieurs */ 01378 } else 01379 01380 e->_message=_IdDcmReadElement(0x0028,0x0198,e); 01381 } 01382 else 01383 e->_message=(char *)malloc(10); /* pour eviter des soucis ulterieurs */ 01384 } 01385 e->_message[lgrMessage]='\0'; 01386 return typ; 01387 } 01388 01389 01390 //------------------------------------------------------------------------------------------- 01391 01418 int IdDcmInquireInfoFromFile ( char * filename, 01419 unsigned short int *typObj, 01420 unsigned short int *typLibido, 01421 unsigned short int *typData, 01422 int *NX, 01423 int *NY, 01424 int *NZ, 01425 int *NT, 01426 int *offset, 01427 int *nbFrames, 01428 int *codeSwap, 01429 int *bitsAllocated, 01430 int *bitsStored, 01431 int *highBit, 01432 int *signe) 01433 { 01434 ID_DCM_HDR *e; 01435 int i; 01436 if (DEBUG) printf ("entree ds IdDcmInquireInfoFromFile\n"); 01437 01438 if((e=IdDcmGetHeader(filename))==0) { 01439 printf ("Gros soucis sur : %s\n",filename); 01440 return (0); 01441 } 01442 if (DEBUG) printf ("sortie de IdDcmGetHeader\n"); 01443 01444 i = IdDcmInquireInfoFromDcmHdr (e, 01445 typObj, 01446 typLibido, 01447 typData, 01448 NX, 01449 NY, 01450 NZ, 01451 NT, 01452 offset, 01453 nbFrames, 01454 codeSwap, 01455 bitsAllocated, 01456 bitsStored, 01457 highBit, 01458 signe); 01459 01460 if (DEBUG) printf ("sortie de IdDcmInquireInfoFromDcmHdr\n"); 01461 01462 IdDcmHdrFree(e); 01463 return (i); 01464 01465 } 01466 01467 01468 //------------------------------------------------------------------------------------------- 01469 01501 int IdDcmInquireInfoFromDcmHdr ( ID_DCM_HDR * e, 01502 unsigned short int *typObj, 01503 unsigned short int *typLibido, 01504 unsigned short int *typData, 01505 int *NX, 01506 int *NY, 01507 int *NZ, 01508 int *NT, 01509 int *offset, 01510 int *nbFrames, 01511 int *codeSwap, 01512 int *bitsAllocated, 01513 int *bitsStored, 01514 int *highBit, 01515 int *signe) 01516 { 01517 unsigned short int ndim; 01518 unsigned short int dim[4]; 01519 int i, SamplesPerPixel; 01520 char *bufbid; 01521 01522 e->ACR_LIBIDO = IdDcmIsAcrLibido(e); 01523 01524 bufbid=_IdDcmReadElement(0x0028,0x0004,e); 01525 01526 if(bufbid!=NULL) { // RGB 01527 if ( (memcmp(bufbid,"RGB ",4)==0) 01528 || 01529 (memcmp(bufbid,"B RG",4)==0) 01530 || 01531 (memcmp(bufbid," BGR",4)==0) 01532 || 01533 (memcmp(bufbid,"GR B",4)==0)) { 01534 01535 // rgb=1; // Mais elle servait a QUOI tout court ?? 01536 01537 printf ("Image RGB ->%s<-\n", bufbid); 01538 } 01539 } 01540 01541 if((ndim=_IdDcmReadElementUSHORT(0x0028,0x0005,e))==0xFFFF) { 01542 ndim=2; // nb de dim de l'objet (IMA par defaut) 01543 } 01544 01545 if ((ndim>4)||(ndim<1)) { 01546 printf ("nb de dim = %d, errone\n",ndim); 01547 return(0); 01548 } else { 01549 if (DEBUG) { 01550 printf ("\t\t\t ndim (0x0028,0x0005) : %d\n",ndim); 01551 } 01552 } 01553 01554 // Lecture SamplesPerPixel (1 : Gray Scale, 3 : RGB) 01555 01556 if((SamplesPerPixel=_IdDcmReadElementUSHORT(0x0028,0x0002,e))==0xFFFF) { 01557 SamplesPerPixel=1; // (Gray Scale par defaut) 01558 } 01559 01560 // Lecture nbFrames 01561 01562 if(!(bufbid=_IdDcmReadElement(0x0028,0x0008,e))) { 01563 *nbFrames=1; // mono-frame par defaut 01564 } else { 01565 *nbFrames=atoi(bufbid); 01566 if (DEBUG) 01567 printf ("\t\t\t nbFrames (0x0028,0x0008) : %d\n",*nbFrames); 01568 } 01569 01570 for(i=0;i<ndim;i++) 01571 if((dim[i]=_IdDcmReadElementUSHORT(0x0028,0x0010+i,e))==0xFFFF) { 01572 IdErrno=IDERR_NON_ACR_FILE; 01573 printf ("IdDcmInquireInfoFromDcmHdr : fichier non ACR (0x0028,0x00%d) " 01574 "missing\n",10+i); 01575 return (0); 01576 } else { 01577 if (DEBUG) 01578 printf ("\t\t\t dim (0x0028,0x001?) : dim[%d]=%d\n",i,dim[i]); 01579 } 01580 01581 01582 if (e->ACR_LIBIDO!=1) { 01583 // si c'est une VRAIE image ACR 01584 // on permutte NX et NY ds l'entete LibIDO 01585 int secuDim; 01586 secuDim = dim[0]; 01587 dim[0] = dim[1]; 01588 dim[1] = secuDim; 01589 } 01590 01591 *NT = *NZ = *NY = *NX = 1; 01592 01593 switch(ndim) { 01594 case 4: *NT=dim[3]; 01595 case 3: *NZ=dim[2]; 01596 case 2: *NY=dim[1]; 01597 case 1: *NX=dim[0]; 01598 } 01599 01600 switch (ndim) { 01601 case 1: *typObj=SIG; break; 01602 case 2: *typObj=IMA; break; 01603 case 3: *typObj=VOL; break; 01604 case 4: *typObj=SEQ; break; 01605 default: { 01606 IdErrno=IDERR_NON_ACR_FILE; 01607 return (0); 01608 } 01609 } 01610 01611 if((*bitsAllocated=_IdDcmReadElementUSHORT(0x0028,0x0100,e))==0xFFFF) { 01612 *bitsAllocated=16 ; // nb bits allocated 01613 } else { 01614 if (DEBUG) { 01615 printf ("\t\t\t nb (0x0028,0x0100) : %d\n",*bitsAllocated); 01616 } 01617 } 01618 01619 if((*bitsStored=_IdDcmReadElementUSHORT(0x0028,0x0101,e))==0xFFFF) { 01620 *bitsStored = *bitsAllocated ; // nb bits utiles 01621 } else { 01622 if (DEBUG) { 01623 printf ("\t\t\t nbu (0x0028,0x0101) : %d\n",*bitsStored); 01624 } 01625 } 01626 01627 if((*highBit=_IdDcmReadElementUSHORT(0x0028,0x0102,e))==0xFFFF) { 01628 // hight bit pas pris en compte 01629 *highBit = *bitsStored-1 ; 01630 } else { 01631 if (DEBUG) { 01632 printf ("\t\t\t highBit (0x0028,0x0102) : %d\n",*highBit); 01633 } 01634 } 01635 01636 if((*signe=_IdDcmReadElementUSHORT(0x0028,0x0103,e))==0xFFFF) { // signe o/n 01637 IdErrno=IDERR_NON_ACR_FILE; 01638 printf ("fichier non ACR (0x0028,0x0103) missing\n"); 01639 return (0); 01640 } else { 01641 if (DEBUG) { 01642 printf ("\t\t\t signe (0x0028,0x0103) : %d\n",*signe); 01643 } 01644 } 01645 01646 if (DEBUG) { 01647 printf("nbit alloues=%d nbit Utiles=%d highbit %d signe=%d\n", 01648 *bitsAllocated,*bitsStored,*highBit,*signe); 01649 for(i=0;i<ndim;i++) 01650 printf(" dim[%d]= %d; ", i, dim[i]); 01651 printf ("\n"); 01652 } 01653 /* 01654 if (*typData != TY_RGB) { 01655 *typData=_IdAcrCheckType(fp, bufbid, (int)ty, (int)nb, *typObj); 01656 01657 } 01658 *typLibido = *typData & TY_SIZE; 01659 */ 01660 01661 *typLibido=_IdDcmCheckType(e,*signe,*bitsAllocated,*typObj, SamplesPerPixel); 01662 *typData = *typLibido & TY_SIZE; 01663 01664 01665 *offset = e->PixelPosition; 01666 01667 if (DEBUG) { 01668 printf("PixelPosition %d\n", e->PixelPosition); 01669 } 01670 01671 *codeSwap = e->sw; 01672 01673 return 1; 01674 } 01675 01676 01677 01678 static void _Swap(void* im, int swap, int lgr, int type) { 01679 unsigned long s32, i; 01680 unsigned short fort,faible; 01681 01682 if (DEBUG) printf ("Entree ds _Swap codeSwap %d, lgr %d\n",swap, lgr); 01683 01684 if((type==TY_SHORT)||(type==TY_USHORT)) 01685 01686 switch(swap) { 01687 case 0: 01688 case 12: 01689 case 1234: 01690 break; 01691 01692 case 21: 01693 case 3412: 01694 case 2143: 01695 case 4321: 01696 01697 for(i=0;i<lgr;i++) 01698 ((unsigned short int*)im)[i]= ((((unsigned short int*)im)[i])>>8) 01699 | ((((unsigned short int*)im)[i])<<8); 01700 break; 01701 01702 default: 01703 printf("valeur de SWAP (16 bits)non autorisee : %d\n", swap); 01704 } 01705 01706 if( (type==TY_LONG)||(type==TY_ULONG)||(type==TY_FLOAT) ) 01707 01708 switch (swap) { 01709 case 0: 01710 case 1234: 01711 break; 01712 01713 case 4321: 01714 for(i=0;i<lgr;i++) { 01715 faible= ((unsigned long int*)im)[i]&0x0000ffff; /* 4321 */ 01716 fort =((unsigned long int*)im)[i]>>16; 01717 fort= (fort>>8) | (fort<<8); 01718 faible=(faible>>8) | (faible<<8); 01719 s32=faible; 01720 ((unsigned long int*)im)[i]=(s32<<16)|fort; 01721 } 01722 break; 01723 01724 case 2143: 01725 for(i=0;i<lgr;i++) { 01726 faible= ((unsigned long int*)im)[i]&0x0000ffff; /* 2143 */ 01727 fort=((unsigned long int*)im)[i]>>16; 01728 fort= (fort>>8) | (fort<<8); 01729 faible=(faible>>8) | (faible<<8); 01730 s32=fort; 01731 ((unsigned long int*)im)[i]=(s32<<16)|faible; 01732 } 01733 break; 01734 01735 case 3412: 01736 for(i=0;i<lgr;i++) { 01737 faible= ((unsigned long int*)im)[i]&0x0000ffff; /* 3412 */ 01738 fort=((unsigned long int*)im)[i]>>16; 01739 s32=faible; 01740 ((unsigned long int*)im)[i]=(s32<<16)|fort; 01741 } 01742 break; 01743 01744 default: 01745 printf("valeur de SWAP (32 bits) non autorisee : %d\n", swap); 01746 } 01747 if(DEBUG) printf("sortie _Swap\n"); 01748 return; 01749 } 01750 01751 01752 01753 01754

Generated on Wed Oct 19 09:28:33 2005 for SIMRI3D by doxygen 1.3.7