00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
#include <string.h>
00045
#include <stdlib.h>
00046
#include "idio.h"
00047
00048
#include <stdio.h>
00049
#include <stdlib.h>
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
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
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
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) { \
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
\
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
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
00240
00241
00242
if((e=
IdDcmGetHeader(filename))==0) {
00243
00244
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
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
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) {
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
00360
00361 printf (
"Image RGB ->%s<-\n", bufbid);
00362 }
00363 }
00364
00365
if((ndim=
_IdDcmReadElementUSHORT(0x0028,0x0005,e))==0xFFFF) {
00366 ndim=2;
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
00379
00380
00381
00382
00383
00384
00385
00386
00387
00388
00389
if(!(bufbid=
_IdDcmReadElement(0x0028,0x0008,e))) {
00390 nbFrames=1;
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
00411
00412
int secuDim;
00413
00414
00415 secuDim = dim[0];
00416 dim[0] = dim[1];
00417 dim[1] = secuDim;
00418 }
else {
00419
00420
00421
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) {
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) {
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
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) {
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
00486
00487
if(ndim==2) typObj=
IMA;
00488
if(ndim==3) typObj=
VOL;
00489
if(ndim==4) typObj=
SEQ;
00490
00491
00492
if((SamplesPerPixel=
_IdDcmReadElementUSHORT(0x0028,0x0002,e))==0xFFFF) {
00493 SamplesPerPixel=1;
00494 }
00495
00496
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;
00503
00504
if (typ!=typePasse)
00505 printf (
"typeTrouve= %x typePasse= %x\n", typ, typePasse);
00506
00507 typ=typePasse;
00508
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);
00517
00518 typObj=type&0x000f;
00519 type =type&0xfff0;
00520
00521
00522
if ( premIm != -2) {
00523 lgrASauter =
IdTypeSize(type);
00524
00525
for(i=0;i<ndim;i++)
00526 lgrASauter = lgrASauter * dim[i];
00527
00528 lgrASauter = lgrASauter * premIm;
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)) ) {
00538
00539
00540
00541
00542
00543
00544 }
00545
00546
00547
00548
00549
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
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) {
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
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 }
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)
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);
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
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
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
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 {
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 }
00758
if (nbu!=nb)
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 }
00764
00765
00766
break;
00767
00768
case TY_SHORT:
CCI(
PPIMAGE_SHORT,
TA_TY_SHORT);
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 }
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
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 }
00975
00976 }
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
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);
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);
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);
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);
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);
01227
01228
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);
01240
01241
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
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);
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
01272
return(0);
01273 }
01274 plelem =
IdLstNext(plelem);
01275 }
01276
01277
while(plelem) {
01278 ple=
IdLstPtrObj(plelem);
01279
01280
if(ple->
Num == num)
break;
01281
if(ple->
Num > num) {
01282
if (
DEBUG) printf(
" num %04x trouve\n",ple->
Num);
01283
01284
return(0);
01285 }
01286 plelem =
IdLstNext(plelem);
01287 }
01288
return (ple->
LgrElem);
01289 }
01290
01291
01292
01293
01294
01295
01296
01297
01298
01299
01300
01301
01302
01303
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);
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) {
01331
01332
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
01346
01347
01348
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
01362
01363 e->
_message=(
char *)malloc(10);
01364 lgrMessage=0;
01365
01366 }
else {
01367
01368
01369
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);
01378 }
else
01379
01380 e->
_message=
_IdDcmReadElement(0x0028,0x0198,e);
01381 }
01382
else
01383 e->
_message=(
char *)malloc(10);
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) {
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
01536
01537 printf (
"Image RGB ->%s<-\n", bufbid);
01538 }
01539 }
01540
01541
if((ndim=
_IdDcmReadElementUSHORT(0x0028,0x0005,e))==0xFFFF) {
01542 ndim=2;
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
01555
01556
if((SamplesPerPixel=
_IdDcmReadElementUSHORT(0x0028,0x0002,e))==0xFFFF) {
01557 SamplesPerPixel=1;
01558 }
01559
01560
01561
01562
if(!(bufbid=
_IdDcmReadElement(0x0028,0x0008,e))) {
01563 *nbFrames=1;
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
01584
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 ;
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 ;
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
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) {
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
01655
01656
01657
01658
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;
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;
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;
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