]> Creatis software - gdcm.git/blob - src/gdcmFile.cxx
Doxygenation.
[gdcm.git] / src / gdcmFile.cxx
1 // gdcmFile.cxx
2 //-----------------------------------------------------------------------------
3 #include "gdcmFile.h"
4 #include "gdcmDebug.h"
5 #include "jpeg/ljpg/jpegless.h"
6
7 typedef std::pair<TagHeaderEntryHT::iterator,TagHeaderEntryHT::iterator> IterHT;
8
9 //-----------------------------------------------------------------------------
10 // Constructor / Destructor
11 /**
12  * \ingroup   gdcmFile
13  * \brief Constructor dedicated to writing a new DICOMV3 part10 compliant
14  *        file (see SetFileName, SetDcmTag and Write)
15  *        Opens (in read only and when possible) an existing file and checks
16  *        for DICOM compliance. Returns NULL on failure.
17  * \note  the in-memory representation of all available tags found in
18  *        the DICOM header is post-poned to first header information access.
19  *        This avoid a double parsing of public part of the header when
20  *        one sets an a posteriori shadow dictionary (efficiency can be
21  *        seen as a side effect).   
22  * @param header file to be opened for reading datas
23  * @return      
24  */
25 gdcmFile::gdcmFile(gdcmHeader *header) {
26    Header=header;
27    SelfHeader=false;
28    PixelRead=-1; // no ImageData read yet.
29
30    if (Header->IsReadable())
31       SetPixelDataSizeFromHeader();
32 }
33
34 /**
35  * \ingroup   gdcmFile
36  * \brief Constructor dedicated to writing a new DICOMV3 part10 compliant
37  *        file (see SetFileName, SetDcmTag and Write)
38  *        Opens (in read only and when possible) an existing file and checks
39  *        for DICOM compliance. Returns NULL on failure.
40  * \note  the in-memory representation of all available tags found in
41  *        the DICOM header is post-poned to first header information access.
42  *        This avoid a double parsing of public part of the header when
43  *        one sets an a posteriori shadow dictionary (efficiency can be
44  *        seen as a side effect).   
45  * @param filename file to be opened for parsing
46  * @param   exception_on_error whether we throw an exception or not
47  * @param   enable_sequences = true to allow the header 
48  *          to be parsed *inside* the SeQuences, 
49  *          when they have an actual length 
50  * \warning enable_sequences *has to be* true for reading PAPYRUS 3.0 files
51  * @param   ignore_shadow to allow skipping the shadow elements, 
52  *          to save memory space.
53  * \warning The TRUE value for this param has to be used 
54  *          with a FALSE value for the 'enable_sequence' param.
55  *          ('public elements' may be embedded in 'shadow Sequences')
56  */
57 gdcmFile::gdcmFile(std::string & filename, 
58                    bool exception_on_error,
59                    bool enable_sequences, 
60                    bool ignore_shadow) {
61    Header=new gdcmHeader(filename.c_str(),
62                          exception_on_error,
63                          enable_sequences,
64                          ignore_shadow);
65    SelfHeader=true;
66    PixelRead=-1; // no ImageData read yet.
67
68    if (Header->IsReadable())
69       SetPixelDataSizeFromHeader();
70 }
71
72 /**
73  * \ingroup   gdcmFile
74  * \brief Constructor dedicated to writing a new DICOMV3 part10 compliant
75  *        file (see SetFileName, SetDcmTag and Write)
76  *        Opens (in read only and when possible) an existing file and checks
77  *        for DICOM compliance. Returns NULL on failure.
78  * \note  the in-memory representation of all available tags found in
79  *        the DICOM header is post-poned to first header information access.
80  *        This avoid a double parsing of public part of the header when
81  *        one sets an a posteriori shadow dictionary (efficiency can be
82  *        seen as a side effect).   
83  * @param filename file to be opened for parsing
84  * @param   exception_on_error whether we throw an exception or not
85  * @param   enable_sequences = true to allow the header 
86  *          to be parsed *inside* the SeQuences, 
87  *          when they have an actual length 
88  * \warning enable_sequences *has to be* true for reading PAPYRUS 3.0 files
89  * @param   ignore_shadow to allow skipping the shadow elements, 
90  *          to save memory space.
91  * \warning The TRUE value for this param has to be used 
92  *          with a FALSE value for the 'enable_sequence' param.
93  *          ('public elements' may be embedded in 'shadow Sequences')
94  */
95  gdcmFile::gdcmFile(const char * filename, 
96                    bool exception_on_error,
97                    bool enable_sequences, 
98                    bool ignore_shadow) {
99    Header=new gdcmHeader(filename,
100                          exception_on_error,
101                          enable_sequences,
102                          ignore_shadow);
103    SelfHeader=true;
104    PixelRead=-1; // no ImageData read yet.
105
106    if (Header->IsReadable())
107       SetPixelDataSizeFromHeader();
108 }
109
110 /**
111  * \ingroup   gdcmFile
112  * \brief canonical destructor
113  * \note  If the gdcmHeader is created by the gdcmFile, it is destroyed
114  *        by the gdcmFile
115  */
116 gdcmFile::~gdcmFile(void) {
117    if(SelfHeader)
118       delete Header;
119    Header=NULL;
120 }
121
122 //-----------------------------------------------------------------------------
123 // Print
124
125 //-----------------------------------------------------------------------------
126 // Public
127 /**
128  * \ingroup   gdcmFile
129  * \brief returns the gdcmHeader *Header   
130  * @return      
131  */
132 gdcmHeader *gdcmFile::GetHeader(void) {
133    return(Header);
134 }
135
136 /**
137  * \ingroup   gdcmFile
138  * \brief     computes the length (in bytes) to ALLOCATE to receive the
139  *            image(s) pixels (multiframes taken into account)          
140  * \warning : it is NOT the group 7FE0 length
141  *          (no interest for compressed images).
142  * @return length to allocate
143  */
144 void gdcmFile::SetPixelDataSizeFromHeader(void) {
145    // see PS 3.3-2003 : C.7.6.3.2.1  
146    // 
147    //   MONOCHROME1
148    //   MONOCHROME2
149    //   PALETTE COLOR
150    //   RGB
151    //   HSV  (Retired)
152    //   ARGB (Retired)
153    //   CMYK (Retired)
154    //   YBR_FULL
155    //   YBR_FULL_422 (no LUT, no Palette)
156    //   YBR_PARTIAL_422
157    //   YBR_ICT
158    //   YBR_RCT
159
160    // LUT's
161    // ex : gdcm-US-ALOKA-16.dcm
162    // 0028|1221 [OW]   [Segmented Red Palette Color Lookup Table Data]
163    // 0028|1222 [OW]   [Segmented Green Palette Color Lookup Table Data]  
164    // 0028|1223 [OW]   [Segmented Blue Palette Color Lookup Table Data]
165
166    // ex  : OT-PAL-8-face.dcm
167    // 0028|1201 [US]   [Red Palette Color Lookup Table Data]
168    // 0028|1202 [US]   [Green Palette Color Lookup Table Data]
169    // 0028|1203 [US]   [Blue Palette Color Lookup Table Data]
170
171    int nb;
172    std::string str_nb;
173    str_nb=Header->GetEntryByNumber(0x0028,0x0100);
174    if (str_nb == GDCM_UNFOUND ) {
175       nb = 16;
176    } else {
177       nb = atoi(str_nb.c_str() );
178       if (nb == 12) nb =16;
179    }
180    lgrTotale =  lgrTotaleRaw = Header->GetXSize() * Header->GetYSize() 
181               * Header->GetZSize() * (nb/8)* Header->GetSamplesPerPixel();
182    std::string str_PhotometricInterpretation = 
183                              Header->GetEntryByNumber(0x0028,0x0004);
184                              
185    /*if ( str_PhotometricInterpretation == "PALETTE COLOR " )*/
186    // pb when undealt Segmented Palette Color
187    
188     if (Header->HasLUT()) { 
189       lgrTotale*=3;
190    }
191 }
192
193 /**
194  * \ingroup   gdcmFile
195  * \brief     Returns the size (in bytes) of required memory to hold
196  *            the pixel data represented in this file.
197  * @return    The size of pixel data in bytes.
198  */
199 size_t gdcmFile::GetImageDataSize(void) {
200    return (lgrTotale);
201 }
202
203 /**
204  * \ingroup   gdcmFile
205  * \brief     Returns the size (in bytes) of required memory to hold
206  *            the pixel data represented in this file, when user DOESN'T want 
207  *            to get RGB pixels image when it's stored as a PALETTE COLOR image
208  *            -the (vtk) user is supposed to know how deal with LUTs- 
209  * \warning   to be used with GetImagePixelsRaw()
210  * @return    The size of pixel data in bytes.
211  */
212 size_t gdcmFile::GetImageDataSizeRaw(void) {
213    return (lgrTotaleRaw);
214 }
215
216 /**
217  * \ingroup gdcmFile
218  * \brief   Allocates necessary memory, copies the pixel data
219  *          (image[s]/volume[s]) to newly allocated zone.
220  *          Transforms YBR pixels into RGB pixels if any
221  *          Transforms 3 planes R, G, B into a single RGB Plane
222  *          Transforms single Grey plane + 3 Palettes into a RGB Plane
223  * @return  Pointer to newly allocated pixel data.
224  *          NULL if alloc fails 
225  */
226 void * gdcmFile::GetImageData (void) {
227    PixelData = new char[lgrTotale];
228    if (PixelData)
229       GetImageDataIntoVector(PixelData, lgrTotale);
230       
231    PixelRead=0; // no PixelRaw
232    return(PixelData);
233 }
234
235 /**
236  * \ingroup gdcmFile
237  * \brief   Copies at most MaxSize bytes of pixel data to caller's
238  *          memory space.
239  * \warning This function was designed to avoid people that want to build
240  *          a volume from an image stack to need first to get the image pixels 
241  *          and then move them to the volume area.
242  *          It's absolutely useless for any VTK user since vtk chooses 
243  *          to invert the lines of an image, that is the last line comes first
244  *          (for some axis related reasons?). Hence he will have 
245  *          to load the image line by line, starting from the end.
246  *          VTK users have to call GetImageData
247  *     
248  * @param   destination Address (in caller's memory space) at which the
249  *          pixel data should be copied
250  * @param   MaxSize Maximum number of bytes to be copied. When MaxSize
251  *          is not sufficient to hold the pixel data the copy is not
252  *          executed (i.e. no partial copy).
253  * @return  On success, the number of bytes actually copied. Zero on
254  *          failure e.g. MaxSize is lower than necessary.
255  */
256 size_t gdcmFile::GetImageDataIntoVector (void* destination, size_t MaxSize) {
257    //size_t l = GetImageDataIntoVectorRaw (destination, MaxSize);
258          GetImageDataIntoVectorRaw (destination, MaxSize);
259    PixelRead=0 ; // no PixelRaw
260    if (!Header->HasLUT())
261       return lgrTotale; 
262                             
263    // from Lut R + Lut G + Lut B
264    unsigned char * newDest = new (unsigned char)[lgrTotale];
265    unsigned char * a       = (unsigned char *)destination;       
266    unsigned char * lutRGBA =                  Header->GetLUTRGBA();
267    if (lutRGBA) {           
268       int l = lgrTotaleRaw;
269       memmove(newDest, destination, l);// move Gray pixels to temp area     
270       int j;     
271       for (int i=0;i<l; i++) {         // Build RGB Pixels
272          j=newDest[i]*4;
273          *a++ = lutRGBA[j]; 
274          *a++ = lutRGBA[j+1];
275          *a++ = lutRGBA[j+2];
276       }
277       delete[] newDest;
278     
279    // now, it's an RGB image
280    // Lets's write it in the Header
281
282          // CreateOrReplaceIfExist ?
283          
284    std::string spp = "3";        // Samples Per Pixel
285    Header->SetEntryByNumber(spp,0x0028,0x0002);
286    std::string rgb= "RGB ";      // Photometric Interpretation
287    Header->SetEntryByNumber(rgb,0x0028,0x0004);
288    std::string planConfig = "0"; // Planar Configuration
289    Header->SetEntryByNumber(planConfig,0x0028,0x0006);
290
291    } else { 
292              // need to make RGB Pixels (?)
293              //    from grey Pixels (?!)
294              //     and Gray Lut  (!?!) 
295              //    or Segmented xxx Palette Color Lookup Table Data and so on
296                                                   
297          // Oops! I get one (gdcm-US-ALOKA-16.dcm)
298          // No idea how to manage such an image 
299          // It seems that *no Dicom Viewer* has any idea :-(
300          // Segmented xxx Palette Color are *more* than 65535 long ?!?
301                    
302       std::string rgb= "MONOCHROME1 ";      // Photometric Interpretation
303       Header->SetEntryByNumber(rgb,0x0028,0x0004);                                 
304    }             
305    /// \todo Drop Palette Color out of the Header?           
306    return lgrTotale; 
307 }
308
309 /**
310  * \ingroup gdcmFile
311  * \brief   Allocates necessary memory, copies the pixel data
312  *          (image[s]/volume[s]) to newly allocated zone.
313  *          Transforms YBR pixels into RGB pixels if any
314  *          Transforms 3 planes R, G, B into a single RGB Plane
315  *          DOES NOT transform Grey plane + 3 Palettes into a RGB Plane
316  * @return  Pointer to newly allocated pixel data.
317  * \        NULL if alloc fails 
318  */
319 void * gdcmFile::GetImageDataRaw (void) {
320    if (Header->HasLUT())
321       /// \todo Let gdcmHeadar user a chance to get the right value
322                 /// Create a member lgrTotaleRaw ???
323       lgrTotale /= 3;
324    PixelData = new char[lgrTotale];
325    if (PixelData)
326       GetImageDataIntoVectorRaw(PixelData, lgrTotale);
327    PixelRead=1; // PixelRaw
328    return(PixelData);
329 }
330
331 /**
332  * \ingroup gdcmFile
333  * \brief   Copies at most MaxSize bytes of pixel data to caller's
334  *          memory space.
335  * \warning This function was designed to avoid people that want to build
336  *          a volume from an image stack to need first to get the image pixels 
337  *          and then move them to the volume area.
338  *          It's absolutely useless for any VTK user since vtk chooses 
339  *          to invert the lines of an image, that is the last line comes first
340  *          (for some axis related reasons?). Hence he will have 
341  *          to load the image line by line, starting from the end.
342  *          VTK users hace to call GetImageData
343  * \warning DOES NOT transform the Grey Plane + Palette Color (if any) 
344  *                   into a single RGB Pixels Plane
345  *          the (VTK) user will manage the palettes
346  *     
347  * @param   destination Address (in caller's memory space) at which the
348  *          pixel data should be copied
349  * @param   MaxSize Maximum number of bytes to be copied. When MaxSize
350  *          is not sufficient to hold the pixel data the copy is not
351  *          executed (i.e. no partial copy).
352  * @return  On success, the number of bytes actually copied. Zero on
353  *          failure e.g. MaxSize is lower than necessary.
354  */
355 size_t gdcmFile::GetImageDataIntoVectorRaw (void* destination, size_t MaxSize) {
356
357    int nb, nbu, highBit, signe;
358    std::string str_nbFrames, str_nb, str_nbu, str_highBit, str_signe;
359    PixelRead=1 ; // PixelRaw
360  
361    if ( lgrTotale > MaxSize ) {
362       dbg.Verbose(0, "gdcmFile::GetImageDataIntoVector: pixel data bigger"
363                      "than caller's expected MaxSize");
364       return (size_t)0; 
365    }
366         
367    (void)ReadPixelData(destination);
368         
369         // Number of Bits Allocated for storing a Pixel
370    str_nb = Header->GetEntryByNumber(0x0028,0x0100);
371    if (str_nb == GDCM_UNFOUND ) {
372       nb = 16;
373    } else {
374       nb = atoi(str_nb.c_str() );
375    }    
376         // Number of Bits actually used
377    str_nbu=Header->GetEntryByNumber(0x0028,0x0101);
378    if (str_nbu == GDCM_UNFOUND ) {
379       nbu = nb;
380    } else {
381       nbu = atoi(str_nbu.c_str() );
382    }            
383         // High Bit Position
384    str_highBit=Header->GetEntryByNumber(0x0028,0x0102);
385    if (str_highBit == GDCM_UNFOUND ) {
386       highBit = nb - 1;
387    } else {
388       highBit = atoi(str_highBit.c_str() );
389    }            
390         // Pixel sign
391         // 0 = Unsigned
392         // 1 = Signed
393    str_signe=Header->GetEntryByNumber(0x0028,0x0103);
394    if (str_signe == GDCM_UNFOUND ) {
395       signe = 0;  // default is unsigned
396    } else {
397       signe = atoi(str_signe.c_str() );
398    }
399
400    // re arange bytes inside the integer (processor endianity)
401    if (nb != 8)
402      SwapZone(destination, Header->GetSwapCode(), lgrTotale, nb);
403      
404    // to avoid pb with some xmedcon breakers images 
405    if (nb==16 && nbu<nb && signe==0) {
406      int l = (int)lgrTotale / (nb/8);
407      guint16 *deb = (guint16 *)destination;
408      for(int i = 0; i<l; i++) {
409         if(*deb == 0xffff) 
410            *deb=0; 
411            deb++;   
412          }
413     }
414    // re arange bits inside the bytes
415    if (nbu != nb){
416       int l = (int)lgrTotale / (nb/8);
417       if (nb == 16) {
418          guint16 mask = 0xffff;
419          mask = mask >> (nb-nbu);
420          guint16 *deb = (guint16 *)destination;
421          for(int i = 0; i<l; i++) {
422             *deb = (*deb >> (nbu-highBit-1)) & mask;
423             deb ++;
424          }
425       } else if (nb == 32 ) {
426          guint32 mask = 0xffffffff;
427          mask = mask >> (nb-nbu);
428          guint32 *deb = (guint32 *)destination;
429          for(int i = 0; i<l; i++) {
430             *deb = (*deb >> (nbu-highBit-1)) & mask;
431             deb ++;
432          }
433       } else {
434          dbg.Verbose(0, "gdcmFile::GetImageDataIntoVector: wierd image");
435          return (size_t)0; 
436       }
437    } 
438 // DO NOT remove this commented out code .
439 // Nobody knows what's expecting you ...
440 // Just to 'see' what was actually read on disk :-(
441
442 //   FILE * f2;
443 //   f2 = fopen("SpuriousFile.RAW","wb");
444 //   fwrite(destination,lgrTotale,1,f2);
445 //   fclose(f2);
446
447    // Deal with the color
448    // -------------------
449    
450        std::string str_PhotometricInterpretation = 
451                  Header->GetEntryByNumber(0x0028,0x0004);
452                    
453       if ( (str_PhotometricInterpretation == "MONOCHROME1 ") 
454         || (str_PhotometricInterpretation == "MONOCHROME2 ") ) {
455          return lgrTotale; 
456       }
457       
458    // Planar configuration = 0 : Pixels are already RGB
459    // Planar configuration = 1 : 3 planes : R, G, B
460    // Planar configuration = 2 : 1 gray Plane + 3 LUT
461
462    // Well ... supposed to be !
463    // See US-PAL-8-10x-echo.dcm: PlanarConfiguration=0,
464    //                            PhotometricInterpretation=PALETTE COLOR
465    // and heuristic has to be found :-( 
466
467       int planConf=Header->GetPlanarConfiguration();  // 0028,0006
468
469       // Whatever Planar Configuration is, 
470       // "PALETTE COLOR " implies that we deal with the palette. 
471       if (str_PhotometricInterpretation == "PALETTE COLOR ")
472          planConf=2;
473
474       switch (planConf) {
475       case 0:                              
476          //       Pixels are already RGB
477          break;
478     
479       case 1:
480
481          {
482          if (str_PhotometricInterpretation == "YBR_FULL") { 
483          
484    // Warning : YBR_FULL_422 acts as RGB
485    //         : we need to make RGB Pixels from Planes Y,cB,cR
486          
487          // to see the tricks about YBR_FULL, YBR_FULL_422, 
488          // YBR_PARTIAL_422, YBR_ICT, YBR_RCT have a look at :
489          //   ftp://medical.nema.org/medical/dicom/final/sup61_ft.pdf
490          // and be *very* affraid
491          //
492             int l = Header->GetXSize()*Header->GetYSize();
493             int nbFrames = Header->GetZSize();
494
495             unsigned char * newDest = new (unsigned char)[lgrTotale];
496             unsigned char *x  = newDest;
497             unsigned char * a = (unsigned char *)destination;
498             unsigned char * b = a + l;
499             unsigned char * c = b + l;
500             double R,G,B;
501
502             /// \todo : Replace by the 'well known' integer computation
503             /// counterpart
504                  /// see http://lestourtereaux.free.fr/papers/data/yuvrgb.pdf
505             /// for code optimisation
506             
507             for (int i=0;i<nbFrames;i++) {
508                for (int j=0;j<l; j++) {
509                   R= 1.164 *(*a-16) + 1.596 *(*c -128) + 0.5;
510                   G= 1.164 *(*a-16) - 0.813 *(*c -128) - 0.392 *(*b -128) + 0.5;
511                   B= 1.164 *(*a-16) + 2.017 *(*b -128) + 0.5;
512
513                   if (R<0.0)   R=0.0;
514                   if (G<0.0)   G=0.0;
515                   if (B<0.0)   B=0.0;
516                   if (R>255.0) R=255.0;
517                   if (G>255.0) G=255.0;
518                   if (B>255.0) B=255.0;
519
520                   *(x++) = (unsigned char)R;
521                   *(x++) = (unsigned char)G;
522                   *(x++) = (unsigned char)B;
523                   a++; b++; c++;  
524                }
525            }
526             memmove(destination,newDest,lgrTotale);
527             delete[] newDest;
528
529         } else {
530          
531          //       need to make RGB Pixels from R,G,B Planes
532          //       (all the Frames at a time)
533
534             int l = Header->GetXSize()*Header->GetYSize()*Header->GetZSize();
535
536             char * newDest = new char[lgrTotale];
537             char * x = newDest;
538             char * a = (char *)destination;
539             char * b = a + l;
540             char * c = b + l;
541
542             for (int j=0;j<l; j++) {
543                *(x++) = *(a++);
544                *(x++) = *(b++);
545                *(x++) = *(c++);  
546             }           
547             memmove(destination,newDest,lgrTotale);
548             delete[] newDest;
549         }         
550          break;
551        }     
552        case 2:                      
553          //       Palettes were found
554          //       Let the user deal with them !
555          return lgrTotale;        
556    } 
557    // now, it's an RGB image
558    // Lets's write it in the Header
559
560    // CreateOrReplaceIfExist ?
561
562    std::string spp = "3";        // Samples Per Pixel
563    Header->SetEntryByNumber(spp,0x0028,0x0002);
564    std::string rgb="RGB ";   // Photometric Interpretation
565    Header->SetEntryByNumber(rgb,0x0028,0x0004);
566
567    std::string planConfig = "0"; // Planar Configuration
568    Header->SetEntryByNumber(planConfig,0x0028,0x0006);
569          
570          /// \todo Drop Palette Color out of the Header? 
571    return lgrTotale; 
572 }
573
574 /**
575  * \ingroup   gdcmFile
576  * \brief performs a shadow copy (not a deep copy) of the user given
577  *        pixel area.
578  *        'image' Pixels are presented as C-like 2D arrays : line per line.
579  *        'volume'Pixels are presented as C-like 3D arrays : lane per plane 
580  * \warning user is kindly requested NOT TO 'free' the Pixel area
581  * @param inData user supplied pixel area
582  * @param ExpectedSize total image size, in Bytes
583  *
584  * @return boolean      
585  */
586 bool gdcmFile::SetImageData(void * inData, size_t ExpectedSize) {
587    Header->SetImageDataSize(ExpectedSize);
588    PixelData = inData;
589    lgrTotale = ExpectedSize;
590    return(true);
591 }
592
593 /**
594  * \ingroup   gdcmFile
595  * \brief Writes on disk A SINGLE Dicom file
596  *        NO test is performed on  processor "Endiannity".
597  *        It's up to the user to call his Reader properly
598  * @param fileName name of the file to be created
599  *                 (any already existing file is over written)
600  * @return false if write fails 
601  */
602
603 bool gdcmFile::WriteRawData (std::string fileName) {
604    FILE * fp1;
605    fp1 = fopen(fileName.c_str(),"wb");
606    if (fp1 == NULL) {
607       printf("Fail to open (write) file [%s] \n",fileName.c_str());
608       return (false);
609    }    
610    fwrite (PixelData,lgrTotale, 1, fp1);
611    fclose (fp1);
612    return(true);
613 }
614
615 /**
616  * \ingroup   gdcmFile
617  * \brief Writes on disk A SINGLE Dicom file, 
618  *        using the Implicit Value Representation convention
619  *        NO test is performed on  processor "Endiannity".
620  * @param fileName name of the file to be created
621  *                 (any already existing file is overwritten)
622  * @return false if write fails 
623  */
624
625 bool gdcmFile::WriteDcmImplVR (std::string fileName) {
626    return WriteBase(fileName, ImplicitVR);
627 }
628
629 /**
630  * \ingroup   gdcmFile
631  * \brief Writes on disk A SINGLE Dicom file, 
632  *        using the Implicit Value Representation convention
633  *        NO test is performed on  processor "Endiannity". * @param fileName name of the file to be created
634  *                 (any already existing file is overwritten)
635  * @return false if write fails 
636  */
637  
638 bool gdcmFile::WriteDcmImplVR (const char* fileName) {
639    return WriteDcmImplVR (std::string (fileName));
640 }
641         
642 /**
643  * \ingroup   gdcmFile
644 * \brief Writes on disk A SINGLE Dicom file, 
645  *        using the Explicit Value Representation convention
646  *        NO test is performed on  processor "Endiannity". * @param fileName name of the file to be created
647  *                 (any already existing file is overwritten)
648  * @return false if write fails 
649  */
650
651 bool gdcmFile::WriteDcmExplVR (std::string fileName) {
652    return WriteBase(fileName, ExplicitVR);
653 }
654         
655 /**
656  * \ingroup   gdcmFile
657  * \brief Writes on disk A SINGLE Dicom file, 
658  *        using the ACR-NEMA convention
659  *        NO test is performed on  processor "Endiannity".
660  *        (a l'attention des logiciels cliniques 
661  *        qui ne prennent en entrée QUE des images ACR ...
662  * \warning if a DICOM_V3 header is supplied,
663  *         groups < 0x0008 and shadow groups are ignored
664  * \warning NO TEST is performed on processor "Endiannity".
665  * @param fileName name of the file to be created
666  *                 (any already existing file is overwritten)
667  * @return false if write fails         
668  */
669
670 bool gdcmFile::WriteAcr (std::string fileName) {
671    return WriteBase(fileName, ACR);
672 }
673
674 //-----------------------------------------------------------------------------
675 // Protected
676 /**
677  * \ingroup   gdcmFile
678  * \brief NOT a end user inteded function
679  *        (used by WriteDcmExplVR, WriteDcmImplVR, WriteAcr, etc)
680  * @param fileName name of the file to be created
681  *                 (any already existing file is overwritten)
682  * @param  type file type (ExplicitVR, ImplicitVR, ...)
683  * @return false if write fails         
684  */
685 bool gdcmFile::WriteBase (std::string fileName, FileType type) {
686
687    FILE * fp1;
688    
689    if (PixelRead==-1 && type != ExplicitVR) {
690       return false;                
691    }
692
693    fp1 = fopen(fileName.c_str(),"wb");
694    if (fp1 == NULL) {
695       printf("Failed to open (write) File [%s] \n",fileName.c_str());
696       return (false);
697    }
698
699    if ( (type == ImplicitVR) || (type == ExplicitVR) ) {
700       char * filePreamble;
701       // writing Dicom File Preamble
702       filePreamble=new char[128];
703       fwrite(filePreamble,128,1,fp1);
704       fwrite("DICM",4,1,fp1);
705       delete[] filePreamble;
706    }
707
708    // --------------------------------------------------------------
709    // Special Patch to allow gdcm to re-write ACR-LibIDO formated images
710    //
711    // if recognition code tells us we dealt with a LibIDO image
712    // we reproduce on disk the switch between lineNumber and columnNumber
713    // just before writting ...
714    
715    /// \todo the best trick would be *change* the recognition code
716    ///       but pb expected if user deals with, e.g. COMPLEX images
717
718    std::string rows, columns; 
719    if ( Header->GetFileType() == ACR_LIBIDO){
720          rows    = Header->GetEntryByNumber(0x0028, 0x0010);
721          columns = Header->GetEntryByNumber(0x0028, 0x0011);
722          Header->SetEntryByNumber(columns,  0x0028, 0x0010);
723          Header->SetEntryByNumber(rows   ,  0x0028, 0x0011);
724    }    
725    // ----------------- End of Special Patch ----------------
726    
727    /// \todo get the grPixel, numPixel values (for some ACR-NEMA images only)
728    
729    guint16 grPixel =Header->GetGrPixel();
730    guint16 numPixel=Header->GetNumPixel();;
731     
732    // Update Pixel Data Length
733    // the *last* of the (GrPixel, NumPixel), if many.
734           
735    TagKey key = gdcmDictEntry::TranslateToKey(grPixel, numPixel); 
736    TagHeaderEntryHT::iterator p2;
737    gdcmHeaderEntry * PixelElement;
738    
739    IterHT it= Header->GetEntry().equal_range(key); // get a pair of iterators first-last synonym   
740
741    if (Header->GetEntry().count(key) == 1) // only the first is significant
742       p2=it.first; // iterator on the first (unique) synonym
743    else
744       p2=it.second;// iterator on the last synonym
745    
746    PixelElement=p2->second;        // H Table target column (2-nd col)
747   // PixelElement->SetPrintLevel(2);
748   // PixelElement->Print();      
749  
750    if (PixelRead==1)
751       PixelElement->SetLength(lgrTotaleRaw);
752    else if (PixelRead==0)
753       PixelElement->SetLength(lgrTotale);
754    
755    //PixelElement->SetPrintLevel(2);
756    //PixelElement->Print();    
757    Header->Write(fp1, type);
758
759    // --------------------------------------------------------------
760    // Special Patch to allow gdcm to re-write ACR-LibIDO formated images
761    // 
762    // ...and we restore the Header to be Dicom Compliant again 
763    // just after writting
764
765    if (Header->GetFileType() == ACR_LIBIDO){
766          Header->SetEntryByNumber(rows   , 0x0028, 0x0010);
767          Header->SetEntryByNumber(columns, 0x0028, 0x0011);
768    }    
769    // ----------------- End of Special Patch ----------------
770    
771    fwrite(PixelData, lgrTotale, 1, fp1);
772    fclose (fp1);
773    return(true);
774 }
775
776 //-----------------------------------------------------------------------------
777 // Private
778 /**
779  * \ingroup gdcmFile
780  * \brief   Swap the bytes, according to swap code.
781  * \warning not end user intended
782  * @param   im area to deal with
783  * @param   swap swap code
784  * @param   lgr Area Length
785  * @param   nb Pixels Bit number 
786  */
787 void gdcmFile::SwapZone(void* im, int swap, int lgr, int nb) {
788 guint32 s32;
789 guint16 fort,faible;
790 int i;
791
792 if(nb == 16)  
793    switch(swap) {
794       case 0:
795       case 12:
796       case 1234:
797          break;
798                 
799       case 21:
800       case 3412:
801       case 2143:
802       case 4321:
803
804          for(i=0;i<lgr/2;i++) {
805             ((unsigned short int*)im)[i]= ((((unsigned short int*)im)[i])>>8)
806                                         | ((((unsigned short int*)im)[i])<<8);
807         }
808          break;
809                         
810       default:
811          printf("SWAP value (16 bits) not allowed : %d\n", swap);
812    } 
813  
814 if( nb == 32 )
815    switch (swap) {
816       case 0:
817       case 1234:
818          break;
819
820       case 4321:
821          for(i=0;i<lgr/4;i++) {
822             faible=  ((unsigned long int*)im)[i]&0x0000ffff;    /* 4321 */
823             fort  =((unsigned long int*)im)[i]>>16;
824             fort=  (fort>>8)   | (fort<<8);
825             faible=(faible>>8) | (faible<<8);
826             s32=faible;
827             ((unsigned long int*)im)[i]=(s32<<16)|fort;
828          }
829          break;
830
831       case 2143:
832          for(i=0;i<lgr/4;i++) {
833             faible=  ((unsigned long int*)im)[i]&0x0000ffff;    /* 2143 */
834             fort=((unsigned long int*)im)[i]>>16;
835             fort=  (fort>>8)   | (fort<<8);
836             faible=(faible>>8) | (faible<<8);
837             s32=fort; 
838             ((unsigned long int*)im)[i]=(s32<<16)|faible;
839          }
840          break;
841   
842       case 3412:
843          for(i=0;i<lgr/4;i++) {
844             faible=  ((unsigned long int*)im)[i]&0x0000ffff;    /* 3412 */
845             fort=((unsigned long int*)im)[i]>>16;                  
846             s32=faible; 
847             ((unsigned long int*)im)[i]=(s32<<16)|fort;
848          }                 
849          break; 
850                                 
851       default:
852          printf("SWAP value (32 bits) not allowed : %d\n", swap);
853    } 
854 return;
855 }
856
857 /**
858  * \ingroup gdcmFile
859  * \brief   Read pixel data from disk (optionaly decompressing) into the
860  *          caller specified memory location.
861  * @param   destination where the pixel data should be stored.
862  *
863  */
864 bool gdcmFile::ReadPixelData(void* destination) {
865
866    FILE *fp;
867
868    if ( !(fp=Header->OpenFile()))
869       return false;
870    if ( fseek(fp, Header->GetPixelOffset(), SEEK_SET) == -1 ) {
871       Header->CloseFile();
872       return false;
873    }
874    // ----------------------  Compacted File (12 Bits Per Pixel)
875    /* unpack 12 Bits pixels into 16 Bits pixels */
876    /* 2 pixels 12bit =     [0xABCDEF]           */
877    /* 2 pixels 16bit = [0x0ABD] + [0x0FCE]      */
878    
879    if (Header->GetBitsAllocated()==12) {
880       int nbPixels = Header->GetXSize() * Header->GetYSize();
881       unsigned char b0, b1, b2;
882       
883       unsigned short int* pdestination = (unsigned short int*)destination;    
884       for(int p=0;p<nbPixels;p+=2) {
885          fread(&b0,1,1,fp);
886          fread(&b1,1,1,fp);
887          fread(&b2,1,1,fp);      
888          //Two steps is necessary to please VC++
889          *pdestination++ =  ((b0 >> 4) << 8) + ((b0 & 0x0f) << 4) + (b1 & 0x0f);
890                               /* A */            /* B */             /* D */
891          *pdestination++ =  ((b2 & 0x0f) << 8) + ((b1 >> 4) << 4) + (b2 >> 4);
892                              /* F */               /* C */           /* E */
893                   
894         // Troubles expected on Big-Endian processors ?       
895       }
896
897       Header->CloseFile();
898       return(true);
899    }        
900
901    // ----------------------  Uncompressed File
902    if ( !Header->IsDicomV3()                             ||
903         Header->IsImplicitVRLittleEndianTransferSyntax() ||
904         Header->IsExplicitVRLittleEndianTransferSyntax() ||
905         Header->IsExplicitVRBigEndianTransferSyntax()    ||
906         Header->IsDeflatedExplicitVRLittleEndianTransferSyntax() ) {
907
908       size_t ItemRead = fread(destination, Header->GetPixelAreaLength(), 1, fp);
909       if ( ItemRead != 1 ) {
910          Header->CloseFile();
911          return false;
912       } else {
913          Header->CloseFile();
914          return true;
915       }
916    } 
917
918    // ---------------------- Run Length Encoding
919    if (Header->IsRLELossLessTransferSyntax()) {
920       bool res = (bool)gdcm_read_RLE_file (fp,destination);
921       Header->CloseFile();
922       return res; 
923    }  
924     
925    // --------------- SingleFrame/Multiframe JPEG Lossless/Lossy/2000 
926    int nb;
927    std::string str_nb=Header->GetEntryByNumber(0x0028,0x0100);
928    if (str_nb == GDCM_UNFOUND ) {
929       nb = 16;
930    } else {
931       nb = atoi(str_nb.c_str() );
932       if (nb == 12) nb =16;  // ?? 12 should be ACR-NEMA only ?
933    }
934
935    int nBytes= nb/8;
936    
937    int taille = Header->GetXSize() * Header->GetYSize()  
938                * Header->GetSamplesPerPixel();    
939    long fragmentBegining; // for ftell, fseek
940
941    bool jpg2000 =     Header->IsJPEG2000();
942    bool jpgLossless = Header->IsJPEGLossless();
943     
944    bool res = true;
945    guint16 ItemTagGr,ItemTagEl;
946    int ln;  
947    
948    //  Position on begining of Jpeg Pixels
949    
950    fread(&ItemTagGr,2,1,fp);  // Reading (fffe) : Item Tag Gr
951    fread(&ItemTagEl,2,1,fp);  // Reading (e000) : Item Tag El
952    if(Header->GetSwapCode()) {
953       ItemTagGr=Header->SwapShort(ItemTagGr); 
954       ItemTagEl=Header->SwapShort(ItemTagEl);            
955    }
956    fread(&ln,4,1,fp); 
957    if(Header->GetSwapCode()) 
958       ln=Header->SwapLong(ln);    // Basic Offset Table Item length
959       
960    if (ln != 0) {
961       // What is it used for ?!?
962       char *BasicOffsetTableItemValue = new char[ln+1];
963       fread(BasicOffsetTableItemValue,ln,1,fp); 
964    }
965    
966    // first Fragment initialisation
967    fread(&ItemTagGr,2,1,fp);  // Reading (fffe) : Item Tag Gr
968    fread(&ItemTagEl,2,1,fp);  // Reading (e000) : Item Tag El
969    if(Header->GetSwapCode()) {
970       ItemTagGr=Header->SwapShort(ItemTagGr); 
971       ItemTagEl=Header->SwapShort(ItemTagEl);            
972    }
973            
974    // parsing fragments until Sequence Delim. Tag found
975    while ( ( ItemTagGr == 0xfffe) && (ItemTagEl != 0xe0dd) ) { 
976       // --- for each Fragment
977
978       fread(&ln,4,1,fp); 
979       if(Header->GetSwapCode()) 
980          ln=Header->SwapLong(ln);    // Fragment Item length
981    
982       fragmentBegining=ftell(fp);   
983
984       if (jpg2000) {          // JPEG 2000 :    call to ???
985  
986          res = (bool)gdcm_read_JPEG2000_file (fp,destination);  // Not Yet written 
987
988       } // ------------------------------------- endif (JPEG2000)
989         
990       else if (jpgLossless) { // JPEG LossLess : call to xmedcom JPEG
991                    
992          JPEGLosslessDecodeImage (fp,  // Reading Fragment pixels
993                                      (unsigned short *)destination,
994                                      Header->GetPixelSize()*8* Header->GetSamplesPerPixel(),
995                                      ln);                                                          
996          res=1; // in order not to break the loop
997   
998       } // ------------------------------------- endif (JPEGLossless)
999                
1000       else {                   // JPEG Lossy : call to IJG 6b
1001
1002          if  (Header->GetBitsStored() == 8) {
1003             res = (bool)gdcm_read_JPEG_file (fp,destination);  // Reading Fragment pixels         
1004          } else {
1005             res = (bool)gdcm_read_JPEG_file12 (fp,destination);// Reading Fragment pixels  
1006          } 
1007       }  // ------------------------------------- endif (JPEGLossy)    
1008          
1009       if (!res) break;
1010                
1011       destination = (char *)destination + taille * nBytes; // location in user's memory 
1012                                                            // for next fragment (if any) 
1013       
1014       fseek(fp,fragmentBegining,SEEK_SET); // To be sure we start 
1015       fseek(fp,ln,SEEK_CUR);               // at the begining of next fragment
1016       
1017       ItemTagGr = ItemTagEl =0;
1018       fread(&ItemTagGr,2,1,fp);  // Reading (fffe) : Item Tag Gr
1019       fread(&ItemTagEl,2,1,fp);  // Reading (e000) : Item Tag El
1020       if(Header->GetSwapCode()) {
1021          ItemTagGr=Header->SwapShort(ItemTagGr); 
1022          ItemTagEl=Header->SwapShort(ItemTagEl);            
1023       } 
1024    
1025    }     // endWhile parsing fragments until Sequence Delim. Tag found    
1026  
1027    Header->CloseFile();
1028    return res;
1029 }
1030 //-----------------------------------------------------------------------------