]> Creatis software - gdcm.git/blob - src/gdcmFileHelper.cxx
BUG: Remove my previous hack now this is properly fixed in gdcmBinEntry by JPR
[gdcm.git] / src / gdcmFileHelper.cxx
1 /*=========================================================================
2                                                                                 
3   Program:   gdcm
4   Module:    $RCSfile: gdcmFileHelper.cxx,v $
5   Language:  C++
6   Date:      $Date: 2005/02/05 01:37:08 $
7   Version:   $Revision: 1.13 $
8                                                                                 
9   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
10   l'Image). All rights reserved. See Doc/License.txt or
11   http://www.creatis.insa-lyon.fr/Public/Gdcm/License.html for details.
12                                                                                 
13      This software is distributed WITHOUT ANY WARRANTY; without even
14      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15      PURPOSE.  See the above copyright notices for more information.
16                                                                                 
17 =========================================================================*/
18
19 #include "gdcmFileHelper.h"
20 #include "gdcmGlobal.h"
21 #include "gdcmTS.h"
22 #include "gdcmDocument.h"
23 #include "gdcmDebug.h"
24 #include "gdcmUtil.h"
25 #include "gdcmBinEntry.h"
26 #include "gdcmValEntry.h"
27 #include "gdcmContentEntry.h"
28 #include "gdcmFile.h"
29 #include "gdcmPixelReadConvert.h"
30 #include "gdcmPixelWriteConvert.h"
31 #include "gdcmDocEntryArchive.h"
32
33 #include <fstream>
34
35 namespace gdcm 
36 {
37 //-------------------------------------------------------------------------
38 // Constructor / Destructor
39 /**
40  * \brief Constructor dedicated to deal with the *pixels* area of a ACR/DICOMV3
41  *        file (gdcm::File only deals with the ... header)
42  *        Opens (in read only and when possible) an existing file and checks
43  *        for DICOM compliance. Returns NULL on failure.
44  *        It will be up to the user to load the pixels into memory
45  * \note  the in-memory representation of all available tags found in
46  *        the DICOM header is post-poned to first header information access.
47  *        This avoid a double parsing of public part of the header when
48  *        one sets an a posteriori shadow dictionary (efficiency can be
49  *        seen as a side effect).   
50  */
51 FileHelper::FileHelper( )
52 {
53    FileInternal = new File( );
54    SelfHeader = true;
55    Initialize();
56 }
57
58 /**
59  * \brief Constructor dedicated to deal with the *pixels* area of a ACR/DICOMV3
60  *        file (File only deals with the ... header)
61  *        Opens (in read only and when possible) an existing file and checks
62  *        for DICOM compliance. Returns NULL on failure.
63  *        It will be up to the user to load the pixels into memory
64  * \note  the in-memory representation of all available tags found in
65  *        the DICOM header is post-poned to first header information access.
66  *        This avoid a double parsing of public part of the header when
67  *        user sets an a posteriori shadow dictionary (efficiency can be
68  *        seen as a side effect).   
69  * @param header already built Header
70  */
71 FileHelper::FileHelper(File *header)
72 {
73    FileInternal = header;
74    SelfHeader = false;
75    Initialize();
76 }
77
78 /**
79  * \brief Constructor dedicated to deal with the *pixels* area of a ACR/DICOMV3
80  *        file (gdcm::File only deals with the ... header)
81  *        Opens (in read only and when possible) an existing file and checks
82  *        for DICOM compliance. Returns NULL on failure.
83  *        It will be up to the user to load the pixels into memory
84  * \note  the in-memory representation of all available tags found in
85  *        the DICOM header is post-poned to first header information access.
86  *        This avoid a double parsing of public part of the header when
87  *        one sets an a posteriori shadow dictionary (efficiency can be
88  *        seen as a side effect).   
89  * @param filename file to be opened for parsing
90  */
91 FileHelper::FileHelper(std::string const &filename )
92 {
93    FileInternal = new File( filename );
94    SelfHeader = true;
95    Initialize();
96 }
97
98 /**
99  * \brief canonical destructor
100  * \note  If the header (gdcm::File) was created by the FileHelper constructor,
101  *        it is destroyed by the FileHelper
102  */
103 FileHelper::~FileHelper()
104
105    if( PixelReadConverter )
106    {
107       delete PixelReadConverter;
108    }
109    if( PixelWriteConverter )
110    {
111       delete PixelWriteConverter;
112    }
113    if( Archive )
114    {
115       delete Archive;
116    }
117
118    if( SelfHeader )
119    {
120       delete FileInternal;
121    }
122    FileInternal = 0;
123 }
124
125 //-----------------------------------------------------------------------------
126 // Public
127 /**
128  * \brief   Accesses an existing DocEntry (i.e. a Dicom Element)
129  *          through it's (group, element) and modifies it's content with
130  *          the given value.
131  * @param   content new value (string) to substitute with
132  * @param   group  group number of the Dicom Element to modify
133  * @param   elem element number of the Dicom Element to modify
134  */
135 bool FileHelper::SetValEntry(std::string const &content,
136                              uint16_t group, uint16_t elem)
137
138    return FileInternal->SetValEntry(content,group,elem);
139 }
140
141
142 /**
143  * \brief   Accesses an existing DocEntry (i.e. a Dicom Element)
144  *          through it's (group, element) and modifies it's content with
145  *          the given value.
146  * @param   content new value (void*  -> uint8_t*) to substitute with
147  * @param   lgth new value length
148  * @param   group  group number of the Dicom Element to modify
149  * @param   elem element number of the Dicom Element to modify
150  */
151 bool FileHelper::SetBinEntry(uint8_t *content, int lgth,
152                              uint16_t group, uint16_t elem)
153 {
154    return FileInternal->SetBinEntry(content,lgth,group,elem);
155 }
156
157 /**
158  * \brief   Modifies the value of a given DocEntry (Dicom entry)
159  *          when it exists. Create it with the given value when unexistant.
160  * @param   content (string) Value to be set
161  * @param   group   Group number of the Entry 
162  * @param   elem  Element number of the Entry
163  * \return  pointer to the modified/created Dicom entry (NULL when creation
164  *          failed).
165  */ 
166 ValEntry *FileHelper::InsertValEntry(std::string const &content,
167                                      uint16_t group, uint16_t elem)
168 {
169    return FileInternal->InsertValEntry(content,group,elem);
170 }
171
172 /**
173  * \brief   Modifies the value of a given DocEntry (Dicom entry)
174  *          when it exists. Create it with the given value when unexistant.
175  *          A copy of the binArea is made to be kept in the Document.
176  * @param   binArea (binary) value to be set
177  * @param   lgth new value length
178  * @param   group   Group number of the Entry 
179  * @param   elem  Element number of the Entry
180  * \return  pointer to the modified/created Dicom entry (NULL when creation
181  *          failed).
182  */
183 BinEntry *FileHelper::InsertBinEntry(uint8_t *binArea, int lgth,
184                                      uint16_t group, uint16_t elem)
185 {
186    return FileInternal->InsertBinEntry(binArea,lgth,group,elem);
187 }
188
189 /**
190  * \brief   Modifies the value of a given DocEntry (Dicom entry)
191  *          when it exists. Create it with the given value when unexistant.
192  *          A copy of the binArea is made to be kept in the Document.
193  * @param   group   Group number of the Entry 
194  * @param   elem  Element number of the Entry
195  * \return  pointer to the modified/created Dicom entry (NULL when creation
196  *          failed).
197  */
198 SeqEntry *FileHelper::InsertSeqEntry(uint16_t group, uint16_t elem)
199 {
200    return FileInternal->InsertSeqEntry(group,elem);
201 }
202
203 /**
204  * \brief   Get the size of the image data
205  *          If the image can be RGB (with a lut or by default), the size 
206  *          corresponds to the RGB image
207  *         (use GetImageDataRawSize if you want to be sure to get *only*
208  *          the size of the pixels)
209  * @return  The image size
210  */
211 size_t FileHelper::GetImageDataSize()
212 {
213    if ( PixelWriteConverter->GetUserData() )
214    {
215       return PixelWriteConverter->GetUserDataSize();
216    }
217
218    return PixelReadConverter->GetRGBSize();
219 }
220
221 /**
222  * \brief   Get the size of the image data
223  *          If the image could be converted to RGB using a LUT, 
224  *          this transformation is not taken into account by GetImageDataRawSize
225  *          (use GetImageDataSize if you wish)
226  * @return  The raw image size
227  */
228 size_t FileHelper::GetImageDataRawSize()
229 {
230    if ( PixelWriteConverter->GetUserData() )
231    {
232       return PixelWriteConverter->GetUserDataSize();
233    }
234
235    return PixelReadConverter->GetRawSize();
236 }
237
238 /**
239  * \brief   - Allocates necessary memory,
240  *          - Reads the pixels from disk (uncompress if necessary),
241  *          - Transforms YBR pixels, if any, into RGB pixels,
242  *          - Transforms 3 planes R, G, B, if any, into a single RGB Plane
243  *          - Transforms single Grey plane + 3 Palettes into a RGB Plane
244  *          - Copies the pixel data (image[s]/volume[s]) to newly allocated zone.
245  * @return  Pointer to newly allocated pixel data.
246  *          NULL if alloc fails 
247  */
248 uint8_t *FileHelper::GetImageData()
249 {
250    if ( PixelWriteConverter->GetUserData() )
251    {
252       return PixelWriteConverter->GetUserData();
253    }
254
255    if ( ! GetRaw() )
256    {
257       // If the decompression failed nothing can be done.
258       return 0;
259    }
260
261    if ( FileInternal->HasLUT() && PixelReadConverter->BuildRGBImage() )
262    {
263       return PixelReadConverter->GetRGB();
264    }
265    else
266    {
267       // When no LUT or LUT conversion fails, return the Raw
268       return PixelReadConverter->GetRaw();
269    }
270 }
271
272 /**
273  * \brief   Allocates necessary memory, 
274  *          Transforms YBR pixels (if any) into RGB pixels
275  *          Transforms 3 planes R, G, B  (if any) into a single RGB Plane
276  *          Copies the pixel data (image[s]/volume[s]) to newly allocated zone. 
277  *          DOES NOT transform Grey plane + 3 Palettes into a RGB Plane
278  * @return  Pointer to newly allocated pixel data.
279  * \        NULL if alloc fails 
280  */
281 uint8_t *FileHelper::GetImageDataRaw ()
282 {
283    return GetRaw();
284 }
285
286 /**
287  * \brief
288  *          Read the pixels from disk (uncompress if necessary),
289  *          Transforms YBR pixels, if any, into RGB pixels
290  *          Transforms 3 planes R, G, B, if any, into a single RGB Plane
291  *          Transforms single Grey plane + 3 Palettes into a RGB Plane   
292  *          Copies at most MaxSize bytes of pixel data to caller allocated
293  *          memory space.
294  * \warning This function allows people that want to build a volume
295  *          from an image stack *not to* have, first to get the image pixels, 
296  *          and then move them to the volume area.
297  *          It's absolutely useless for any VTK user since vtk chooses 
298  *          to invert the lines of an image, that is the last line comes first
299  *          (for some axis related reasons?). Hence he will have 
300  *          to load the image line by line, starting from the end.
301  *          VTK users have to call GetImageData
302  *     
303  * @param   destination Address (in caller's memory space) at which the
304  *          pixel data should be copied
305  * @param   maxSize Maximum number of bytes to be copied. When MaxSize
306  *          is not sufficient to hold the pixel data the copy is not
307  *          executed (i.e. no partial copy).
308  * @return  On success, the number of bytes actually copied. Zero on
309  *          failure e.g. MaxSize is lower than necessary.
310  */
311 size_t FileHelper::GetImageDataIntoVector (void *destination, size_t maxSize)
312 {
313    if ( ! GetRaw() )
314    {
315       // If the decompression failed nothing can be done.
316       return 0;
317    }
318
319    if ( FileInternal->HasLUT() && PixelReadConverter->BuildRGBImage() )
320    {
321       if ( PixelReadConverter->GetRGBSize() > maxSize )
322       {
323          gdcmWarningMacro( "Pixel data bigger than caller's expected MaxSize");
324          return 0;
325       }
326       memcpy( destination,
327               (void*)PixelReadConverter->GetRGB(),
328               PixelReadConverter->GetRGBSize() );
329       return PixelReadConverter->GetRGBSize();
330    }
331
332    // Either no LUT conversion necessary or LUT conversion failed
333    if ( PixelReadConverter->GetRawSize() > maxSize )
334    {
335       gdcmWarningMacro( "Pixel data bigger than caller's expected MaxSize");
336       return 0;
337    }
338    memcpy( destination,
339            (void*)PixelReadConverter->GetRaw(),
340            PixelReadConverter->GetRawSize() );
341    return PixelReadConverter->GetRawSize();
342 }
343
344 /**
345  * \brief   Points the internal pointer to the callers inData
346  *          image representation, BUT WITHOUT COPYING THE DATA.
347  *          'image' Pixels are presented as C-like 2D arrays : line per line.
348  *          'volume'Pixels are presented as C-like 3D arrays : plane per plane 
349  * \warning Since the pixels are not copied, it is the caller's responsability
350  *          not to deallocate its data before gdcm uses them (e.g. with
351  *          the Write() method )
352  * @param inData user supplied pixel area (uint8_t* is just for the compiler.
353  *               user is allowed to pass any kind of pixelsn since the size is
354  *               given in bytes) 
355  * @param expectedSize total image size, *in Bytes*
356  *
357  * @return boolean
358  */
359 void FileHelper::SetImageData(uint8_t *inData, size_t expectedSize)
360 {
361    SetUserData(inData,expectedSize);
362 }
363
364 /**
365  * \brief   Set the image data defined by the user
366  * \warning When writting the file, this data are get as default data to write
367  * @param inData user supplied pixel area (uint8_t* is just for the compiler.
368  *               user is allowed to pass any kind of pixelsn since the size is
369  *               given in bytes) 
370  * @param expectedSize total image size, *in Bytes*
371  
372  */
373 void FileHelper::SetUserData(uint8_t *inData, size_t expectedSize)
374 {
375    PixelWriteConverter->SetUserData(inData,expectedSize);
376 }
377
378 /**
379  * \brief   Get the image data defined by the user
380  * \warning When writting the file, this data are get as default data to write
381  */
382 uint8_t *FileHelper::GetUserData()
383 {
384    return PixelWriteConverter->GetUserData();
385 }
386
387 /**
388  * \brief   Get the image data size defined by the user
389  * \warning When writting the file, this data are get as default data to write
390  */
391 size_t FileHelper::GetUserDataSize()
392 {
393    return PixelWriteConverter->GetUserDataSize();
394 }
395
396 /**
397  * \brief   Get the image data from the file.
398  *          If a LUT is found, the data are expanded to be RGB
399  */
400 uint8_t *FileHelper::GetRGBData()
401 {
402    return PixelReadConverter->GetRGB();
403 }
404
405 /**
406  * \brief   Get the image data size from the file.
407  *          If a LUT is found, the data are expanded to be RGB
408  */
409 size_t FileHelper::GetRGBDataSize()
410 {
411    return PixelReadConverter->GetRGBSize();
412 }
413
414 /**
415  * \brief   Get the image data from the file.
416  *          If a LUT is found, the data are not expanded !
417  */
418 uint8_t *FileHelper::GetRawData()
419 {
420    return PixelReadConverter->GetRaw();
421 }
422
423 /**
424  * \brief   Get the image data size from the file.
425  *          If a LUT is found, the data are not expanded !
426  */
427 size_t FileHelper::GetRawDataSize()
428 {
429    return PixelReadConverter->GetRawSize();
430 }
431
432 /**
433  * \brief Access to the underlying \ref PixelReadConverter RGBA LUT
434  */
435 uint8_t* FileHelper::GetLutRGBA()
436 {
437    return PixelReadConverter->GetLutRGBA();
438 }
439
440 /**
441  * \brief Writes on disk A SINGLE Dicom file
442  *        NO test is performed on  processor "Endiannity".
443  *        It's up to the user to call his Reader properly
444  * @param fileName name of the file to be created
445  *                 (any already existing file is over written)
446  * @return false if write fails
447  */
448 bool FileHelper::WriteRawData(std::string const &fileName)
449 {
450   std::ofstream fp1(fileName.c_str(), std::ios::out | std::ios::binary );
451    if (!fp1)
452    {
453       gdcmWarningMacro( "Fail to open (write) file:" << fileName.c_str());
454       return false;
455    }
456
457    if( PixelWriteConverter->GetUserData() )
458    {
459       fp1.write( (char*)PixelWriteConverter->GetUserData(), 
460                  PixelWriteConverter->GetUserDataSize() );
461    }
462    else if ( PixelReadConverter->GetRGB() )
463    {
464       fp1.write( (char*)PixelReadConverter->GetRGB(), 
465                  PixelReadConverter->GetRGBSize());
466    }
467    else if ( PixelReadConverter->GetRaw() )
468    {
469       fp1.write( (char*)PixelReadConverter->GetRaw(), 
470                  PixelReadConverter->GetRawSize());
471    }
472    else
473    {
474       gdcmErrorMacro( "Nothing written." );
475    }
476
477    fp1.close();
478
479    return true;
480 }
481
482 /**
483  * \brief Writes on disk A SINGLE Dicom file, 
484  *        using the Implicit Value Representation convention
485  *        NO test is performed on  processor "Endiannity".
486  * @param fileName name of the file to be created
487  *                 (any already existing file is overwritten)
488  * @return false if write fails
489  */
490
491 bool FileHelper::WriteDcmImplVR (std::string const &fileName)
492 {
493    SetWriteTypeToDcmImplVR();
494    return Write(fileName);
495 }
496
497 /**
498 * \brief Writes on disk A SINGLE Dicom file, 
499  *        using the Explicit Value Representation convention
500  *        NO test is performed on  processor "Endiannity". 
501  * @param fileName name of the file to be created
502  *                 (any already existing file is overwritten)
503  * @return false if write fails
504  */
505
506 bool FileHelper::WriteDcmExplVR (std::string const &fileName)
507 {
508    SetWriteTypeToDcmExplVR();
509    return Write(fileName);
510 }
511
512 /**
513  * \brief Writes on disk A SINGLE Dicom file, 
514  *        using the ACR-NEMA convention
515  *        NO test is performed on  processor "Endiannity".
516  *        (a l'attention des logiciels cliniques 
517  *        qui ne prennent en entrée QUE des images ACR ...
518  * \warning if a DICOM_V3 header is supplied,
519  *         groups < 0x0008 and shadow groups are ignored
520  * \warning NO TEST is performed on processor "Endiannity".
521  * @param fileName name of the file to be created
522  *                 (any already existing file is overwritten)
523  * @return false if write fails
524  */
525
526 bool FileHelper::WriteAcr (std::string const &fileName)
527 {
528    SetWriteTypeToAcr();
529    return Write(fileName);
530 }
531
532 /**
533  * \brief Writes on disk A SINGLE Dicom file, 
534  * @param fileName name of the file to be created
535  *                 (any already existing file is overwritten)
536  * @return false if write fails
537  */
538 bool FileHelper::Write(std::string const &fileName)
539 {
540    switch(WriteType)
541    {
542       case ImplicitVR:
543          SetWriteFileTypeToImplicitVR();
544          break;
545       case ExplicitVR:
546          SetWriteFileTypeToExplicitVR();
547          break;
548       case ACR:
549       case ACR_LIBIDO:
550          SetWriteFileTypeToACR();
551          break;
552       default:
553          SetWriteFileTypeToExplicitVR();
554    }
555
556    // --------------------------------------------------------------
557    // Special Patch to allow gdcm to re-write ACR-LibIDO formated images
558    //
559    // if recognition code tells us we dealt with a LibIDO image
560    // we reproduce on disk the switch between lineNumber and columnNumber
561    // just before writting ...
562    /// \todo the best trick would be *change* the recognition code
563    ///       but pb expected if user deals with, e.g. COMPLEX images
564    if( WriteType == ACR_LIBIDO )
565    {
566       SetWriteToLibido();
567    }
568    else
569    {
570       SetWriteToNoLibido();
571    }
572    // ----------------- End of Special Patch ----------------
573   
574    switch(WriteMode)
575    {
576       case WMODE_RAW :
577          SetWriteToRaw();
578          break;
579       case WMODE_RGB :
580          SetWriteToRGB();
581          break;
582    }
583
584    bool check = CheckWriteIntegrity();
585    if(check)
586    {
587       check = FileInternal->Write(fileName,WriteType);
588    }
589
590    RestoreWrite();
591    RestoreWriteFileType();
592
593    // --------------------------------------------------------------
594    // Special Patch to allow gdcm to re-write ACR-LibIDO formated images
595    // 
596    // ...and we restore the header to be Dicom Compliant again 
597    // just after writting
598    RestoreWriteOfLibido();
599    // ----------------- End of Special Patch ----------------
600
601    return check;
602 }
603
604 //-----------------------------------------------------------------------------
605 // Protected
606 /**
607  * \brief Check the write integrity
608  *
609  * The tests made are :
610  *  - verify the size of the image to write with the possible write
611  *    when the user set an image data
612  * @return true if check is successfull
613  */
614 bool FileHelper::CheckWriteIntegrity()
615 {
616    if(PixelWriteConverter->GetUserData())
617    {
618       int numberBitsAllocated = FileInternal->GetBitsAllocated();
619       if ( numberBitsAllocated == 0 || numberBitsAllocated == 12 )
620       {
621          numberBitsAllocated = 16;
622       }
623
624       size_t decSize = FileInternal->GetXSize()
625                     * FileInternal->GetYSize() 
626                     * FileInternal->GetZSize()
627                     * ( numberBitsAllocated / 8 )
628                     * FileInternal->GetSamplesPerPixel();
629       size_t rgbSize = decSize;
630       if( FileInternal->HasLUT() )
631          rgbSize = decSize * 3;
632
633       switch(WriteMode)
634       {
635          case WMODE_RAW :
636             if( decSize!=PixelWriteConverter->GetUserDataSize() )
637             {
638                gdcmWarningMacro( "Data size (Raw) is incorrect. Should be " 
639                            << decSize << " / Found :" 
640                            << PixelWriteConverter->GetUserDataSize() );
641                return false;
642             }
643             break;
644          case WMODE_RGB :
645             if( rgbSize!=PixelWriteConverter->GetUserDataSize() )
646             {
647                gdcmWarningMacro( "Data size (RGB) is incorrect. Should be " 
648                           << decSize << " / Found " 
649                           << PixelWriteConverter->GetUserDataSize() );
650                return false;
651             }
652             break;
653       }
654    }
655    
656    return true;
657 }
658
659 /**
660  * \brief Update the File to write RAW datas  
661  */ 
662 void FileHelper::SetWriteToRaw()
663 {
664    if( FileInternal->GetNumberOfScalarComponents() == 3 
665     && !FileInternal->HasLUT())
666    {
667       SetWriteToRGB();
668    } 
669    else
670    {
671       ValEntry *photInt = CopyValEntry(0x0028,0x0004);
672       if(FileInternal->HasLUT())
673       {
674          photInt->SetValue("PALETTE COLOR ");
675       }
676       else
677       {
678          photInt->SetValue("MONOCHROME1 ");
679       }
680
681       PixelWriteConverter->SetReadData(PixelReadConverter->GetRaw(),
682                                        PixelReadConverter->GetRawSize());
683
684       BinEntry *pixel = 
685          CopyBinEntry(GetFile()->GetGrPixel(),GetFile()->GetNumPixel());
686       pixel->SetValue(GDCM_BINLOADED);
687       pixel->SetBinArea(PixelWriteConverter->GetData(),false);
688       pixel->SetLength(PixelWriteConverter->GetDataSize());
689
690       Archive->Push(photInt);
691       Archive->Push(pixel);
692    }
693 }
694
695 /**
696  * \brief Update the File to write RGB datas  
697  */ 
698 void FileHelper::SetWriteToRGB()
699 {
700    if(FileInternal->GetNumberOfScalarComponents()==3)
701    {
702       PixelReadConverter->BuildRGBImage();
703       
704       ValEntry *spp = CopyValEntry(0x0028,0x0002);
705       spp->SetValue("3 ");
706
707       ValEntry *planConfig = CopyValEntry(0x0028,0x0006);
708       planConfig->SetValue("0 ");
709
710       ValEntry *photInt = CopyValEntry(0x0028,0x0004);
711       photInt->SetValue("RGB ");
712
713       if(PixelReadConverter->GetRGB())
714       {
715          PixelWriteConverter->SetReadData(PixelReadConverter->GetRGB(),
716                                           PixelReadConverter->GetRGBSize());
717       }
718       else // Raw data
719       {
720          PixelWriteConverter->SetReadData(PixelReadConverter->GetRaw(),
721                                           PixelReadConverter->GetRawSize());
722       }
723
724       BinEntry *pixel = 
725          CopyBinEntry(GetFile()->GetGrPixel(),GetFile()->GetNumPixel());
726       pixel->SetValue(GDCM_BINLOADED);
727       pixel->SetBinArea(PixelWriteConverter->GetData(),false);
728       pixel->SetLength(PixelWriteConverter->GetDataSize());
729
730       Archive->Push(spp);
731       Archive->Push(planConfig);
732       Archive->Push(photInt);
733       Archive->Push(pixel);
734
735       // Remove any LUT
736       Archive->Push(0x0028,0x1101);
737       Archive->Push(0x0028,0x1102);
738       Archive->Push(0x0028,0x1103);
739       Archive->Push(0x0028,0x1201);
740       Archive->Push(0x0028,0x1202);
741       Archive->Push(0x0028,0x1203);
742
743       // For old ACR-NEMA
744       // Thus, we have a RGB image and the bits allocated = 24 and 
745       // samples per pixels = 1 (in the read file)
746       if(FileInternal->GetBitsAllocated()==24) 
747       {
748          ValEntry *bitsAlloc = CopyValEntry(0x0028,0x0100);
749          bitsAlloc->SetValue("8 ");
750
751          ValEntry *bitsStored = CopyValEntry(0x0028,0x0101);
752          bitsStored->SetValue("8 ");
753
754          ValEntry *highBit = CopyValEntry(0x0028,0x0102);
755          highBit->SetValue("7 ");
756
757          Archive->Push(bitsAlloc);
758          Archive->Push(bitsStored);
759          Archive->Push(highBit);
760       }
761    }
762    else
763    {
764       SetWriteToRaw();
765    }
766 }
767
768 /**
769  * \brief Restore the File write mode  
770  */ 
771 void FileHelper::RestoreWrite()
772 {
773    Archive->Restore(0x0028,0x0002);
774    Archive->Restore(0x0028,0x0004);
775    Archive->Restore(0x0028,0x0006);
776    Archive->Restore(GetFile()->GetGrPixel(),GetFile()->GetNumPixel());
777
778    // For old ACR-NEMA (24 bits problem)
779    Archive->Restore(0x0028,0x0100);
780    Archive->Restore(0x0028,0x0101);
781    Archive->Restore(0x0028,0x0102);
782
783    // For the LUT
784    Archive->Restore(0x0028,0x1101);
785    Archive->Restore(0x0028,0x1102);
786    Archive->Restore(0x0028,0x1103);
787    Archive->Restore(0x0028,0x1201);
788    Archive->Restore(0x0028,0x1202);
789    Archive->Restore(0x0028,0x1203);
790 }
791
792 /**
793  * \brief Set in the File the write type to ACR
794  */ 
795 void FileHelper::SetWriteFileTypeToACR()
796 {
797    Archive->Push(0x0002,0x0010);
798 }
799
800 /**
801  * \brief Set in the File the write type to Explicit VR   
802  */ 
803 void FileHelper::SetWriteFileTypeToExplicitVR()
804 {
805    std::string ts = Util::DicomString( 
806       Global::GetTS()->GetSpecialTransferSyntax(TS::ExplicitVRLittleEndian) );
807
808    ValEntry *tss = CopyValEntry(0x0002,0x0010);
809    tss->SetValue(ts);
810
811    Archive->Push(tss);
812 }
813
814 /**
815  * \brief Set in the File the write type to Implicit VR   
816  */ 
817 void FileHelper::SetWriteFileTypeToImplicitVR()
818 {
819    std::string ts = Util::DicomString(
820       Global::GetTS()->GetSpecialTransferSyntax(TS::ImplicitVRLittleEndian) );
821
822    ValEntry *tss = CopyValEntry(0x0002,0x0010);
823    tss->SetValue(ts);
824
825    Archive->Push(tss);
826 }
827
828
829 /**
830  * \brief Restore in the File the write type
831  */ 
832 void FileHelper::RestoreWriteFileType()
833 {
834    Archive->Restore(0x0002,0x0010);
835 }
836
837 /**
838  * \brief Set the Write not to Libido format
839  */ 
840 void FileHelper::SetWriteToLibido()
841 {
842    ValEntry *oldRow = dynamic_cast<ValEntry *>
843                 (FileInternal->GetDocEntry(0x0028, 0x0010));
844    ValEntry *oldCol = dynamic_cast<ValEntry *>
845                 (FileInternal->GetDocEntry(0x0028, 0x0011));
846    
847    if( oldRow && oldCol )
848    {
849       std::string rows, columns; 
850
851       ValEntry *newRow=new ValEntry(oldRow->GetDictEntry());
852       ValEntry *newCol=new ValEntry(oldCol->GetDictEntry());
853
854       newRow->Copy(oldCol);
855       newCol->Copy(oldRow);
856
857       newRow->SetValue(oldCol->GetValue());
858       newCol->SetValue(oldRow->GetValue());
859
860       Archive->Push(newRow);
861       Archive->Push(newCol);
862    }
863
864    ValEntry *libidoCode = CopyValEntry(0x0008,0x0010);
865    libidoCode->SetValue("ACRNEMA_LIBIDO_1.1");
866    Archive->Push(libidoCode);
867 }
868
869 /**
870  * \brief Set the Write not to No Libido format
871  */ 
872 void FileHelper::SetWriteToNoLibido()
873 {
874    ValEntry *recCode = dynamic_cast<ValEntry *>
875                 (FileInternal->GetDocEntry(0x0008,0x0010));
876    if( recCode )
877    {
878       if( recCode->GetValue() == "ACRNEMA_LIBIDO_1.1" )
879       {
880          ValEntry *libidoCode = CopyValEntry(0x0008,0x0010);
881          libidoCode->SetValue("");
882          Archive->Push(libidoCode);
883       }
884    }
885 }
886
887 /**
888  * \brief Restore the Write format
889  */ 
890 void FileHelper::RestoreWriteOfLibido()
891 {
892    Archive->Restore(0x0028,0x0010);
893    Archive->Restore(0x0028,0x0011);
894    Archive->Restore(0x0008,0x0010);
895 }
896
897 /**
898  * \brief Copy a ValEntry content
899  * @param   group   Group number of the Entry 
900  * @param   elem  Element number of the Entry
901  * \return  pointer to the modified/created Val Entry (NULL when creation
902  *          failed).
903  */ 
904 ValEntry *FileHelper::CopyValEntry(uint16_t group,uint16_t elem)
905 {
906    DocEntry *oldE = FileInternal->GetDocEntry(group, elem);
907    ValEntry *newE;
908
909    if(oldE)
910    {
911       newE = new ValEntry(oldE->GetDictEntry());
912       newE->Copy(oldE);
913    }
914    else
915    {
916       newE = GetFile()->NewValEntry(group,elem);
917    }
918
919    return newE;
920 }
921
922 /**
923  * \brief   Modifies the value of a given Bin Entry (Dicom Element)
924  *          when it exists. Create it with the given value when unexistant.
925  * @param   group   Group number of the Entry 
926  * @param   elem  Element number of the Entry
927  * \return  pointer to the modified/created Bin Entry (NULL when creation
928  *          failed).
929  */ 
930 BinEntry *FileHelper::CopyBinEntry(uint16_t group,uint16_t elem)
931 {
932    DocEntry *oldE = FileInternal->GetDocEntry(group, elem);
933    BinEntry *newE;
934
935    if(oldE)
936    {
937       newE = new BinEntry(oldE->GetDictEntry());
938       newE->Copy(oldE);
939    }
940    else
941    {
942       newE = GetFile()->NewBinEntry(group,elem);
943    }
944
945    return newE;
946 }
947
948 //-----------------------------------------------------------------------------
949 // Private
950 /**
951  * \brief Factorization for various forms of constructors.
952  */
953 void FileHelper::Initialize()
954 {
955    WriteMode = WMODE_RAW;
956    WriteType = ExplicitVR;
957
958    PixelReadConverter = new PixelReadConvert;
959    PixelWriteConverter = new PixelWriteConvert;
960    Archive = new DocEntryArchive( FileInternal );
961
962    if ( FileInternal->IsReadable() )
963    {
964       PixelReadConverter->GrabInformationsFromFile( FileInternal );
965    }
966 }
967
968 /**
969  * \brief   
970  */ 
971 uint8_t *FileHelper::GetRaw()
972 {
973    uint8_t *raw = PixelReadConverter->GetRaw();
974    if ( ! raw )
975    {
976       // The Raw image migth not be loaded yet:
977       std::ifstream *fp = FileInternal->OpenFile();
978       PixelReadConverter->ReadAndDecompressPixelData( fp );
979       if(fp) 
980          FileInternal->CloseFile();
981
982       raw = PixelReadConverter->GetRaw();
983       if ( ! raw )
984       {
985          gdcmWarningMacro( "Read/decompress of pixel data apparently went wrong.");
986          return 0;
987       }
988    }
989
990    return raw;
991 }
992
993 //-----------------------------------------------------------------------------
994 // Print
995 void FileHelper::Print(std::ostream &os, std::string const &)
996 {
997    FileInternal->SetPrintLevel(PrintLevel);
998    FileInternal->Print(os);
999
1000    PixelReadConverter->SetPrintLevel(PrintLevel);
1001    PixelReadConverter->Print(os);
1002 }
1003
1004 //-----------------------------------------------------------------------------
1005 } // end namespace gdcm