]> Creatis software - gdcm.git/blob - src/gdcmFileHelper.cxx
Should suppress some warnings from Borland compiler
[gdcm.git] / src / gdcmFileHelper.cxx
1 /*=========================================================================
2                                                                                 
3   Program:   gdcm
4   Module:    $RCSfile: gdcmFileHelper.cxx,v $
5   Language:  C++
6
7   Date:      $Date: 2005/04/19 09:58:19 $
8   Version:   $Revision: 1.33 $
9                                                                                 
10   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
11   l'Image). All rights reserved. See Doc/License.txt or
12   http://www.creatis.insa-lyon.fr/Public/Gdcm/License.html for details.
13                                                                                 
14      This software is distributed WITHOUT ANY WARRANTY; without even
15      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
16      PURPOSE.  See the above copyright notices for more information.
17                                                                                 
18 =========================================================================*/
19
20 #include "gdcmFileHelper.h"
21 #include "gdcmGlobal.h"
22 #include "gdcmTS.h"
23 #include "gdcmDocument.h"
24 #include "gdcmDebug.h"
25 #include "gdcmUtil.h"
26 #include "gdcmBinEntry.h"
27 #include "gdcmValEntry.h"
28 #include "gdcmSeqEntry.h"
29 #include "gdcmSQItem.h"
30 #include "gdcmContentEntry.h"
31 #include "gdcmFile.h"
32 #include "gdcmPixelReadConvert.h"
33 #include "gdcmPixelWriteConvert.h"
34 #include "gdcmDocEntryArchive.h"
35 #include "gdcmDictSet.h"
36
37 #include <fstream>
38
39 /*
40 // ----------------------------- WARNING -------------------------
41
42 These lines will be moved to the document-to-be 'User's Guide'
43
44 // To read an image, user needs a gdcm::File
45 gdcm::File *f1 = new gdcm::File(fileName);
46 // user can now check some values
47 std::string v = f1->GetEntryValue(groupNb,ElementNb);
48 // to get the pixels, user needs a gdcm::FileHelper
49 gdcm::FileHelper *fh1 = new gdcm::FileHelper(f1);
50 // user may ask not to convert Palette to RGB
51 uint8_t *pixels = fh1->GetImageDataRaw();
52 int imageLength = fh1->GetImageDataRawSize();
53 // He can now use the pixels, create a new image, ...
54 uint8_t *userPixels = ...
55
56 To re-write the image, user re-uses the gdcm::FileHelper
57
58 fh1->SetImageData( userPixels, userPixelsLength);
59 fh1->SetTypeToRaw(); // Even if it was possible to convert Palette to RGB
60                      // (WriteMode is set)
61  
62 fh1->SetWriteTypeToDcmExpl(); // he wants Explicit Value Representation
63                               // Little Endian is the default
64                               // no other value is allowed
65                                 (-->SetWriteType(ExplicitVR);)
66                                    -->WriteType = ExplicitVR;
67 fh1->Write(newFileName);      // overwrites the file, if any
68
69 // or :
70 fh1->WriteDcmExplVR(newFileName);
71
72
73 // ----------------------------- WARNING -------------------------
74
75 These lines will be moved to the document-to-be 'Developer's Guide'
76
77 WriteMode : WMODE_RAW / WMODE_RGB
78 WriteType : ImplicitVR, ExplicitVR, ACR, ACR_LIBIDO
79
80 fh1->Write(newFileName);
81    SetWriteFileTypeToImplicitVR() / SetWriteFileTypeToExplicitVR();
82    (modifies TransferSyntax)
83    SetWriteToRaw(); / SetWriteToRGB();
84       (modifies, when necessary : photochromatic interpretation, 
85          samples per pixel, Planar configuration, 
86          bits allocated, bits stored, high bit -ACR 24 bits-
87          Pixels element VR, pushes out the LUT )
88    CheckWriteIntegrity();
89       (checks user given pixels length)
90    FileInternal->Write(fileName,WriteType)
91    fp = opens file(fileName);
92    ComputeGroup0002Length(writetype);
93    BitsAllocated 12->16
94       RemoveEntryNoDestroy(palettes, etc)
95       Document::WriteContent(fp, writetype);
96    RestoreWrite();
97       (moves back to the File all the archived elements)
98    RestoreWriteFileType();
99       (pushes back group 0002, with TransferSyntax)
100 */
101
102
103
104
105 namespace gdcm 
106 {
107 //-------------------------------------------------------------------------
108 // Constructor / Destructor
109 /**
110  * \brief Constructor dedicated to deal with the *pixels* area of a ACR/DICOMV3
111  *        file (gdcm::File only deals with the ... header)
112  *        Opens (in read only and when possible) an existing file and checks
113  *        for DICOM compliance. Returns NULL on failure.
114  *        It will be up to the user to load the pixels into memory
115  * \note  the in-memory representation of all available tags found in
116  *        the DICOM header is post-poned to first header information access.
117  *        This avoid a double parsing of public part of the header when
118  *        one sets an a posteriori shadow dictionary (efficiency can be
119  *        seen as a side effect).   
120  */
121 FileHelper::FileHelper( )
122 {
123    FileInternal = new File( );
124    SelfHeader = true;
125    Initialize();
126 }
127
128 /**
129  * \brief Constructor dedicated to deal with the *pixels* area of a ACR/DICOMV3
130  *        file (File only deals with the ... header)
131  *        Opens (in read only and when possible) an existing file and checks
132  *        for DICOM compliance. Returns NULL on failure.
133  *        It will be up to the user to load the pixels into memory
134  * \note  the in-memory representation of all available tags found in
135  *        the DICOM header is post-poned to first header information access.
136  *        This avoid a double parsing of public part of the header when
137  *        user sets an a posteriori shadow dictionary (efficiency can be
138  *        seen as a side effect).   
139  * @param header already built Header
140  */
141 FileHelper::FileHelper(File *header)
142 {
143    FileInternal = header;
144    SelfHeader = false;
145    Initialize();
146 }
147
148 /**
149  * \brief Constructor dedicated to deal with the *pixels* area of a ACR/DICOMV3
150  *        file (gdcm::File only deals with the ... header)
151  *        Opens (in read only and when possible) an existing file and checks
152  *        for DICOM compliance. Returns NULL on failure.
153  *        It will be up to the user to load the pixels into memory
154  * \note  the in-memory representation of all available tags found in
155  *        the DICOM header is post-poned to first header information access.
156  *        This avoid a double parsing of public part of the header when
157  *        one sets an a posteriori shadow dictionary (efficiency can be
158  *        seen as a side effect).   
159  * @param filename file to be opened for parsing
160  */
161 FileHelper::FileHelper(std::string const &filename )
162 {
163    FileInternal = new File( filename );
164    SelfHeader = true;
165    Initialize();
166 }
167
168 /**
169  * \brief canonical destructor
170  * \note  If the header (gdcm::File) was created by the FileHelper constructor,
171  *        it is destroyed by the FileHelper
172  */
173 FileHelper::~FileHelper()
174
175    if( PixelReadConverter )
176    {
177       delete PixelReadConverter;
178    }
179    if( PixelWriteConverter )
180    {
181       delete PixelWriteConverter;
182    }
183    if( Archive )
184    {
185       delete Archive;
186    }
187
188    if( SelfHeader )
189    {
190       delete FileInternal;
191    }
192    FileInternal = 0;
193 }
194
195 //-----------------------------------------------------------------------------
196 // Public
197 /**
198  * \brief   Accesses an existing DocEntry (i.e. a Dicom Element)
199  *          through it's (group, element) and modifies it's content with
200  *          the given value.
201  * @param   content new value (string) to substitute with
202  * @param   group  group number of the Dicom Element to modify
203  * @param   elem element number of the Dicom Element to modify
204  * \return  false if DocEntry not found
205  */
206 bool FileHelper::SetValEntry(std::string const &content,
207                              uint16_t group, uint16_t elem)
208
209    return FileInternal->SetValEntry(content, group, elem);
210 }
211
212
213 /**
214  * \brief   Accesses an existing DocEntry (i.e. a Dicom Element)
215  *          through it's (group, element) and modifies it's content with
216  *          the given value.
217  * @param   content new value (void*  -> uint8_t*) to substitute with
218  * @param   lgth new value length
219  * @param   group  group number of the Dicom Element to modify
220  * @param   elem element number of the Dicom Element to modify
221  * \return  false if DocEntry not found
222  */
223 bool FileHelper::SetBinEntry(uint8_t *content, int lgth,
224                              uint16_t group, uint16_t elem)
225 {
226    return FileInternal->SetBinEntry(content, lgth, group, elem);
227 }
228
229 /**
230  * \brief   Modifies the value of a given DocEntry (Dicom entry)
231  *          when it exists. Creates it with the given value when unexistant.
232  * @param   content (string)value to be set
233  * @param   group   Group number of the Entry 
234  * @param   elem  Element number of the Entry
235  * \return  pointer to the modified/created Dicom entry (NULL when creation
236  *          failed).
237  */ 
238 ValEntry *FileHelper::InsertValEntry(std::string const &content,
239                                      uint16_t group, uint16_t elem)
240 {
241    return FileInternal->InsertValEntry(content,group,elem);
242 }
243
244 /**
245  * \brief   Modifies the value of a given DocEntry (Dicom entry)
246  *          when it exists. Creates it with the given value when unexistant.
247  *          A copy of the binArea is made to be kept in the Document.
248  * @param   binArea (binary)value to be set
249  * @param   lgth new value length
250  * @param   group   Group number of the Entry 
251  * @param   elem  Element number of the Entry
252  * \return  pointer to the modified/created Dicom entry (NULL when creation
253  *          failed).
254  */
255 BinEntry *FileHelper::InsertBinEntry(uint8_t *binArea, int lgth,
256                                      uint16_t group, uint16_t elem)
257 {
258    return FileInternal->InsertBinEntry(binArea, lgth, group, elem);
259 }
260
261 /**
262  * \brief   Modifies the value of a given DocEntry (Dicom entry)
263  *          when it exists. Creates it, empty (?!) when unexistant.
264  * @param   group   Group number of the Entry 
265  * @param   elem  Element number of the Entry
266  * \return  pointer to the modified/created Dicom entry (NULL when creation
267  *          failed).
268  */
269 SeqEntry *FileHelper::InsertSeqEntry(uint16_t group, uint16_t elem)
270 {
271    return FileInternal->InsertSeqEntry(group, elem);
272 }
273
274 /**
275  * \brief   Get the size of the image data
276  *          If the image can be RGB (with a lut or by default), the size 
277  *          corresponds to the RGB image
278  *         (use GetImageDataRawSize if you want to be sure to get *only*
279  *          the size of the pixels)
280  * @return  The image size
281  */
282 size_t FileHelper::GetImageDataSize()
283 {
284    if ( PixelWriteConverter->GetUserData() )
285    {
286       return PixelWriteConverter->GetUserDataSize();
287    }
288
289    return PixelReadConverter->GetRGBSize();
290 }
291
292 /**
293  * \brief   Get the size of the image data
294  *          If the image could be converted to RGB using a LUT, 
295  *          this transformation is not taken into account by GetImageDataRawSize
296  *          (use GetImageDataSize if you wish)
297  * @return  The raw image size
298  */
299 size_t FileHelper::GetImageDataRawSize()
300 {
301    if ( PixelWriteConverter->GetUserData() )
302    {
303       return PixelWriteConverter->GetUserDataSize();
304    }
305
306    return PixelReadConverter->GetRawSize();
307 }
308
309 /**
310  * \brief   - Allocates necessary memory,
311  *          - Reads the pixels from disk (uncompress if necessary),
312  *          - Transforms YBR pixels, if any, into RGB pixels,
313  *          - Transforms 3 planes R, G, B, if any, into a single RGB Plane
314  *          - Transforms single Grey plane + 3 Palettes into a RGB Plane
315  *          - Copies the pixel data (image[s]/volume[s]) to newly allocated zone.
316  * @return  Pointer to newly allocated pixel data.
317  *          NULL if alloc fails 
318  */
319 uint8_t *FileHelper::GetImageData()
320 {
321    if ( PixelWriteConverter->GetUserData() )
322    {
323       return PixelWriteConverter->GetUserData();
324    }
325
326    if ( ! GetRaw() )
327    {
328       // If the decompression failed nothing can be done.
329       return 0;
330    }
331
332    if ( FileInternal->HasLUT() && PixelReadConverter->BuildRGBImage() )
333    {
334       return PixelReadConverter->GetRGB();
335    }
336    else
337    {
338       // When no LUT or LUT conversion fails, return the Raw
339       return PixelReadConverter->GetRaw();
340    }
341 }
342
343 /**
344  * \brief   Allocates necessary memory, 
345  *          Transforms YBR pixels (if any) into RGB pixels
346  *          Transforms 3 planes R, G, B  (if any) into a single RGB Plane
347  *          Copies the pixel data (image[s]/volume[s]) to newly allocated zone. 
348  *          DOES NOT transform Grey plane + 3 Palettes into a RGB Plane
349  * @return  Pointer to newly allocated pixel data.
350  *          NULL if alloc fails 
351  */
352 uint8_t *FileHelper::GetImageDataRaw ()
353 {
354    return GetRaw();
355 }
356
357 /**
358  * \brief
359  *          Read the pixels from disk (uncompress if necessary),
360  *          Transforms YBR pixels, if any, into RGB pixels
361  *          Transforms 3 planes R, G, B, if any, into a single RGB Plane
362  *          Transforms single Grey plane + 3 Palettes into a RGB Plane   
363  *          Copies at most MaxSize bytes of pixel data to caller allocated
364  *          memory space.
365  * \warning This function allows people that want to build a volume
366  *          from an image stack *not to* have, first to get the image pixels, 
367  *          and then move them to the volume area.
368  *          It's absolutely useless for any VTK user since vtk chooses 
369  *          to invert the lines of an image, that is the last line comes first
370  *          (for some axis related reasons?). Hence he will have 
371  *          to load the image line by line, starting from the end.
372  *          VTK users have to call GetImageData
373  *     
374  * @param   destination Address (in caller's memory space) at which the
375  *          pixel data should be copied
376  * @param   maxSize Maximum number of bytes to be copied. When MaxSize
377  *          is not sufficient to hold the pixel data the copy is not
378  *          executed (i.e. no partial copy).
379  * @return  On success, the number of bytes actually copied. Zero on
380  *          failure e.g. MaxSize is lower than necessary.
381  */
382 size_t FileHelper::GetImageDataIntoVector (void *destination, size_t maxSize)
383 {
384    if ( ! GetRaw() )
385    {
386       // If the decompression failed nothing can be done.
387       return 0;
388    }
389
390    if ( FileInternal->HasLUT() && PixelReadConverter->BuildRGBImage() )
391    {
392       if ( PixelReadConverter->GetRGBSize() > maxSize )
393       {
394          gdcmWarningMacro( "Pixel data bigger than caller's expected MaxSize");
395          return 0;
396       }
397       memcpy( destination,
398               (void*)PixelReadConverter->GetRGB(),
399               PixelReadConverter->GetRGBSize() );
400       return PixelReadConverter->GetRGBSize();
401    }
402
403    // Either no LUT conversion necessary or LUT conversion failed
404    if ( PixelReadConverter->GetRawSize() > maxSize )
405    {
406       gdcmWarningMacro( "Pixel data bigger than caller's expected MaxSize");
407       return 0;
408    }
409    memcpy( destination,
410            (void*)PixelReadConverter->GetRaw(),
411            PixelReadConverter->GetRawSize() );
412    return PixelReadConverter->GetRawSize();
413 }
414
415 /**
416  * \brief   Points the internal pointer to the callers inData
417  *          image representation, BUT WITHOUT COPYING THE DATA.
418  *          'image' Pixels are presented as C-like 2D arrays : line per line.
419  *          'volume'Pixels are presented as C-like 3D arrays : plane per plane 
420  * \warning Since the pixels are not copied, it is the caller's responsability
421  *          not to deallocate its data before gdcm uses them (e.g. with
422  *          the Write() method )
423  * @param inData user supplied pixel area (uint8_t* is just for the compiler.
424  *               user is allowed to pass any kind of pixelsn since the size is
425  *               given in bytes) 
426  * @param expectedSize total image size, *in Bytes*
427  */
428 void FileHelper::SetImageData(uint8_t *inData, size_t expectedSize)
429 {
430    SetUserData(inData, expectedSize);
431 }
432
433 /**
434  * \brief   Set the image data defined by the user
435  * \warning When writting the file, this data are get as default data to write
436  * @param inData user supplied pixel area (uint8_t* is just for the compiler.
437  *               user is allowed to pass any kind of pixels since the size is
438  *               given in bytes) 
439  * @param expectedSize total image size, *in Bytes* 
440  */
441 void FileHelper::SetUserData(uint8_t *inData, size_t expectedSize)
442 {
443    PixelWriteConverter->SetUserData(inData, expectedSize);
444 }
445
446 /**
447  * \brief   Get the image data defined by the user
448  * \warning When writting the file, this data are get as default data to write
449  */
450 uint8_t *FileHelper::GetUserData()
451 {
452    return PixelWriteConverter->GetUserData();
453 }
454
455 /**
456  * \brief   Get the image data size defined by the user
457  * \warning When writting the file, this data are get as default data to write
458  */
459 size_t FileHelper::GetUserDataSize()
460 {
461    return PixelWriteConverter->GetUserDataSize();
462 }
463
464 /**
465  * \brief   Get the image data from the file.
466  *          If a LUT is found, the data are expanded to be RGB
467  */
468 uint8_t *FileHelper::GetRGBData()
469 {
470    return PixelReadConverter->GetRGB();
471 }
472
473 /**
474  * \brief   Get the image data size from the file.
475  *          If a LUT is found, the data are expanded to be RGB
476  */
477 size_t FileHelper::GetRGBDataSize()
478 {
479    return PixelReadConverter->GetRGBSize();
480 }
481
482 /**
483  * \brief   Get the image data from the file.
484  *          Even when a LUT is found, the data are not expanded to RGB!
485  */
486 uint8_t *FileHelper::GetRawData()
487 {
488    return PixelReadConverter->GetRaw();
489 }
490
491 /**
492  * \brief   Get the image data size from the file.
493  *          Even when a LUT is found, the data are not expanded to RGB!
494  */
495 size_t FileHelper::GetRawDataSize()
496 {
497    return PixelReadConverter->GetRawSize();
498 }
499
500 /**
501  * \brief Access to the underlying \ref PixelReadConverter RGBA LUT
502  */
503 uint8_t* FileHelper::GetLutRGBA()
504 {
505    return PixelReadConverter->GetLutRGBA();
506 }
507
508 /**
509  * \brief Writes on disk A SINGLE Dicom file
510  *        NO test is performed on  processor "Endiannity".
511  *        It's up to the user to call his Reader properly
512  * @param fileName name of the file to be created
513  *                 (any already existing file is over written)
514  * @return false if write fails
515  */
516 bool FileHelper::WriteRawData(std::string const &fileName)
517 {
518    std::ofstream fp1(fileName.c_str(), std::ios::out | std::ios::binary );
519    if (!fp1)
520    {
521       gdcmWarningMacro( "Fail to open (write) file:" << fileName.c_str());
522       return false;
523    }
524
525    if( PixelWriteConverter->GetUserData() )
526    {
527       fp1.write( (char*)PixelWriteConverter->GetUserData(), 
528                  PixelWriteConverter->GetUserDataSize() );
529    }
530    else if ( PixelReadConverter->GetRGB() )
531    {
532       fp1.write( (char*)PixelReadConverter->GetRGB(), 
533                  PixelReadConverter->GetRGBSize());
534    }
535    else if ( PixelReadConverter->GetRaw() )
536    {
537       fp1.write( (char*)PixelReadConverter->GetRaw(), 
538                  PixelReadConverter->GetRawSize());
539    }
540    else
541    {
542       gdcmErrorMacro( "Nothing written." );
543    }
544
545    fp1.close();
546
547    return true;
548 }
549
550 /**
551  * \brief Writes on disk A SINGLE Dicom file, 
552  *        using the Implicit Value Representation convention
553  *        NO test is performed on  processor "Endiannity".
554  * @param fileName name of the file to be created
555  *                 (any already existing file is overwritten)
556  * @return false if write fails
557  */
558
559 bool FileHelper::WriteDcmImplVR (std::string const &fileName)
560 {
561    SetWriteTypeToDcmImplVR();
562    return Write(fileName);
563 }
564
565 /**
566 * \brief Writes on disk A SINGLE Dicom file, 
567  *        using the Explicit Value Representation convention
568  *        NO test is performed on  processor "Endiannity". 
569  * @param fileName name of the file to be created
570  *                 (any already existing file is overwritten)
571  * @return false if write fails
572  */
573
574 bool FileHelper::WriteDcmExplVR (std::string const &fileName)
575 {
576    SetWriteTypeToDcmExplVR();
577    return Write(fileName);
578 }
579
580 /**
581  * \brief Writes on disk A SINGLE Dicom file, 
582  *        using the ACR-NEMA convention
583  *        NO test is performed on  processor "Endiannity".
584  *        (a l'attention des logiciels cliniques 
585  *        qui ne prennent en entrée QUE des images ACR ...
586  * \warning if a DICOM_V3 header is supplied,
587  *         groups < 0x0008 and shadow groups are ignored
588  * \warning NO TEST is performed on processor "Endiannity".
589  * @param fileName name of the file to be created
590  *                 (any already existing file is overwritten)
591  * @return false if write fails
592  */
593
594 bool FileHelper::WriteAcr (std::string const &fileName)
595 {
596    SetWriteTypeToAcr();
597    return Write(fileName);
598 }
599
600 /**
601  * \brief Writes on disk A SINGLE Dicom file, 
602  * @param fileName name of the file to be created
603  *                 (any already existing file is overwritten)
604  * @return false if write fails
605  */
606 bool FileHelper::Write(std::string const &fileName)
607 {
608    switch(WriteType)
609    {
610       case ImplicitVR:
611          SetWriteFileTypeToImplicitVR();
612          CheckMandatoryElements();
613          break;
614       case Unknown:  // should never happen; ExplicitVR is the default value
615       case ExplicitVR:
616          SetWriteFileTypeToExplicitVR();
617          CheckMandatoryElements();
618          break;
619       case ACR:
620       case ACR_LIBIDO:
621       // Just to avoid further trouble if user create a file ex-nihilo,
622       // wants to write it as an ACR-NEMA file,
623       // and forget to create any Entry belonging to group 0008
624       // (shame on him !)
625       // We add Recognition Code (RET)
626         if ( ! FileInternal->GetValEntry(0x0008, 0x0010) )
627             FileInternal->InsertValEntry("", 0x0008, 0x0010);
628          SetWriteFileTypeToACR();
629          SetWriteFileTypeToImplicitVR();
630          CheckMandatoryElements();
631          break;
632
633    }
634
635    // --------------------------------------------------------------
636    // Special Patch to allow gdcm to re-write ACR-LibIDO formated images
637    //
638    // if recognition code tells us we dealt with a LibIDO image
639    // we reproduce on disk the switch between lineNumber and columnNumber
640    // just before writting ...
641    /// \todo the best trick would be *change* the recognition code
642    ///       but pb expected if user deals with, e.g. COMPLEX images
643    
644    if( WriteType == ACR_LIBIDO )
645    {
646       SetWriteToLibido();
647    }
648    else
649    {
650       SetWriteToNoLibido();
651    }
652    // ----------------- End of Special Patch ----------------
653   
654    switch(WriteMode)
655    {
656       case WMODE_RAW :
657          SetWriteToRaw(); // modifies and pushes to the archive, when necessary
658          break;
659       case WMODE_RGB :
660          SetWriteToRGB(); // modifies and pushes to the archive, when necessary
661          break;
662    }
663
664    bool check = CheckWriteIntegrity(); // verifies length
665    if(check)
666    {
667       check = FileInternal->Write(fileName,WriteType);
668    }
669
670    RestoreWrite();
671    RestoreWriteFileType();
672    RestoreWriteMandatory();
673
674    // --------------------------------------------------------------
675    // Special Patch to allow gdcm to re-write ACR-LibIDO formated images
676    // 
677    // ...and we restore the header to be Dicom Compliant again 
678    // just after writting
679    RestoreWriteOfLibido();
680    // ----------------- End of Special Patch ----------------
681
682    return check;
683 }
684
685 //-----------------------------------------------------------------------------
686 // Protected
687 /**
688  * \brief Checks the write integrity
689  *
690  * The tests made are :
691  *  - verify the size of the image to write with the possible write
692  *    when the user set an image data
693  * @return true if check is successfull
694  */
695 bool FileHelper::CheckWriteIntegrity()
696 {
697    if(PixelWriteConverter->GetUserData())
698    {
699       int numberBitsAllocated = FileInternal->GetBitsAllocated();
700       if ( numberBitsAllocated == 0 || numberBitsAllocated == 12 )
701       {
702          numberBitsAllocated = 16;
703       }
704
705       size_t decSize = FileInternal->GetXSize()
706                     * FileInternal->GetYSize() 
707                     * FileInternal->GetZSize()
708                     * ( numberBitsAllocated / 8 )
709                     * FileInternal->GetSamplesPerPixel();
710       size_t rgbSize = decSize;
711       if( FileInternal->HasLUT() )
712          rgbSize = decSize * 3;
713
714       switch(WriteMode)
715       {
716          case WMODE_RAW :
717             if( decSize!=PixelWriteConverter->GetUserDataSize() )
718             {
719                gdcmWarningMacro( "Data size (Raw) is incorrect. Should be " 
720                            << decSize << " / Found :" 
721                            << PixelWriteConverter->GetUserDataSize() );
722                return false;
723             }
724             break;
725          case WMODE_RGB :
726             if( rgbSize!=PixelWriteConverter->GetUserDataSize() )
727             {
728                gdcmWarningMacro( "Data size (RGB) is incorrect. Should be " 
729                           << decSize << " / Found " 
730                           << PixelWriteConverter->GetUserDataSize() );
731                return false;
732             }
733             break;
734       }
735    }
736    
737    return true;
738 }
739
740 /**
741  * \brief Updates the File to write RAW data (as opposed to RGB data)
742  *       (modifies, when necessary, photochromatic interpretation, 
743  *       bits allocated, Pixels element VR)
744  */ 
745 void FileHelper::SetWriteToRaw()
746 {
747    if( FileInternal->GetNumberOfScalarComponents() == 3 
748     && !FileInternal->HasLUT())
749    {
750       SetWriteToRGB();
751    } 
752    else
753    {
754       ValEntry *photInt = CopyValEntry(0x0028,0x0004);
755       if(FileInternal->HasLUT())
756       {
757          photInt->SetValue("PALETTE COLOR ");
758       }
759       else
760       {
761          photInt->SetValue("MONOCHROME2 ");
762       }
763
764       PixelWriteConverter->SetReadData(PixelReadConverter->GetRaw(),
765                                        PixelReadConverter->GetRawSize());
766
767       std::string vr = "OB";
768       if( FileInternal->GetBitsAllocated()>8 )
769          vr = "OW";
770       if( FileInternal->GetBitsAllocated()==24 ) // For RGB ACR files 
771          vr = "OB";
772       BinEntry *pixel = 
773          CopyBinEntry(GetFile()->GetGrPixel(),GetFile()->GetNumPixel(),vr);
774       pixel->SetValue(GDCM_BINLOADED);
775       pixel->SetBinArea(PixelWriteConverter->GetData(),false);
776       pixel->SetLength(PixelWriteConverter->GetDataSize());
777
778       Archive->Push(photInt);
779       Archive->Push(pixel);
780    }
781 }
782
783 /**
784  * \brief Updates the File to write RGB data (as opposed to RAW data)
785  *       (modifies, when necessary, photochromatic interpretation, 
786  *       samples per pixel, Planar configuration, 
787  *       bits allocated, bits stored, high bit -ACR 24 bits-
788  *       Pixels element VR, pushes out the LUT, )
789  */ 
790 void FileHelper::SetWriteToRGB()
791 {
792    if(FileInternal->GetNumberOfScalarComponents()==3)
793    {
794       PixelReadConverter->BuildRGBImage();
795       
796       ValEntry *spp = CopyValEntry(0x0028,0x0002);
797       spp->SetValue("3 ");
798
799       ValEntry *planConfig = CopyValEntry(0x0028,0x0006);
800       planConfig->SetValue("0 ");
801
802       ValEntry *photInt = CopyValEntry(0x0028,0x0004);
803       photInt->SetValue("RGB ");
804
805       if(PixelReadConverter->GetRGB())
806       {
807          PixelWriteConverter->SetReadData(PixelReadConverter->GetRGB(),
808                                           PixelReadConverter->GetRGBSize());
809       }
810       else // Raw data
811       {
812          PixelWriteConverter->SetReadData(PixelReadConverter->GetRaw(),
813                                           PixelReadConverter->GetRawSize());
814       }
815
816       std::string vr = "OB";
817       if( FileInternal->GetBitsAllocated()>8 )
818          vr = "OW";
819       if( FileInternal->GetBitsAllocated()==24 ) // For RGB ACR files 
820          vr = "OB";
821       BinEntry *pixel = 
822          CopyBinEntry(GetFile()->GetGrPixel(),GetFile()->GetNumPixel(),vr);
823       pixel->SetValue(GDCM_BINLOADED);
824       pixel->SetBinArea(PixelWriteConverter->GetData(),false);
825       pixel->SetLength(PixelWriteConverter->GetDataSize());
826
827       Archive->Push(spp);
828       Archive->Push(planConfig);
829       Archive->Push(photInt);
830       Archive->Push(pixel);
831
832       // Remove any LUT
833       Archive->Push(0x0028,0x1101);
834       Archive->Push(0x0028,0x1102);
835       Archive->Push(0x0028,0x1103);
836       Archive->Push(0x0028,0x1201);
837       Archive->Push(0x0028,0x1202);
838       Archive->Push(0x0028,0x1203);
839
840       // For old '24 Bits' ACR-NEMA
841       // Thus, we have a RGB image and the bits allocated = 24 and 
842       // samples per pixels = 1 (in the read file)
843       if(FileInternal->GetBitsAllocated()==24) 
844       {
845          ValEntry *bitsAlloc = CopyValEntry(0x0028,0x0100);
846          bitsAlloc->SetValue("8 ");
847
848          ValEntry *bitsStored = CopyValEntry(0x0028,0x0101);
849          bitsStored->SetValue("8 ");
850
851          ValEntry *highBit = CopyValEntry(0x0028,0x0102);
852          highBit->SetValue("7 ");
853
854          Archive->Push(bitsAlloc);
855          Archive->Push(bitsStored);
856          Archive->Push(highBit);
857       }
858    }
859    else
860    {
861       SetWriteToRaw();
862    }
863 }
864
865 /**
866  * \brief Restore the File write mode  
867  */ 
868 void FileHelper::RestoreWrite()
869 {
870    Archive->Restore(0x0028,0x0002);
871    Archive->Restore(0x0028,0x0004);
872    Archive->Restore(0x0028,0x0006);
873    Archive->Restore(GetFile()->GetGrPixel(),GetFile()->GetNumPixel());
874
875    // For old ACR-NEMA (24 bits problem)
876    Archive->Restore(0x0028,0x0100);
877    Archive->Restore(0x0028,0x0101);
878    Archive->Restore(0x0028,0x0102);
879
880    // For the LUT
881    Archive->Restore(0x0028,0x1101);
882    Archive->Restore(0x0028,0x1102);
883    Archive->Restore(0x0028,0x1103);
884    Archive->Restore(0x0028,0x1201);
885    Archive->Restore(0x0028,0x1202);
886    Archive->Restore(0x0028,0x1203);
887
888    // group 0002 may be pushed out for ACR-NEMA writting purposes 
889    Archive->Restore(0x0002,0x0000);
890    Archive->Restore(0x0002,0x0001);
891    Archive->Restore(0x0002,0x0002);
892    Archive->Restore(0x0002,0x0003);
893    Archive->Restore(0x0002,0x0010);
894    Archive->Restore(0x0002,0x0012);
895    Archive->Restore(0x0002,0x0013);
896    Archive->Restore(0x0002,0x0016);
897    Archive->Restore(0x0002,0x0100);
898    Archive->Restore(0x0002,0x0102);
899 }
900
901 /**
902  * \brief Pushes out the whole group 0002
903  *        FIXME : better, set a flag to tell the writer not to write it ...
904  *        FIXME : method should probably have an other name !
905  *                SetWriteFileTypeToACR is NOT opposed to 
906  *                SetWriteFileTypeToExplicitVR and SetWriteFileTypeToImplicitVR
907  */ 
908 void FileHelper::SetWriteFileTypeToACR()
909 {
910    Archive->Push(0x0002,0x0000);
911    Archive->Push(0x0002,0x0001);
912    Archive->Push(0x0002,0x0002);
913    Archive->Push(0x0002,0x0003);
914    Archive->Push(0x0002,0x0010);
915    Archive->Push(0x0002,0x0012);
916    Archive->Push(0x0002,0x0013);
917    Archive->Push(0x0002,0x0016);
918    Archive->Push(0x0002,0x0100);
919    Archive->Push(0x0002,0x0102);
920 }
921
922 /**
923  * \brief Sets in the File the TransferSyntax to 'Explicit VR Little Endian"   
924  */ 
925 void FileHelper::SetWriteFileTypeToExplicitVR()
926 {
927    std::string ts = Util::DicomString( 
928       Global::GetTS()->GetSpecialTransferSyntax(TS::ExplicitVRLittleEndian) );
929
930    ValEntry *tss = CopyValEntry(0x0002,0x0010);
931    tss->SetValue(ts);
932
933    Archive->Push(tss);
934 }
935
936 /**
937  * \brief Sets in the File the TransferSyntax to 'Implicit VR Little Endian"   
938  */ 
939 void FileHelper::SetWriteFileTypeToImplicitVR()
940 {
941    std::string ts = Util::DicomString(
942       Global::GetTS()->GetSpecialTransferSyntax(TS::ImplicitVRLittleEndian) );
943
944    ValEntry *tss = CopyValEntry(0x0002,0x0010);
945    tss->SetValue(ts);
946
947    Archive->Push(tss);
948 }
949
950
951 /**
952  * \brief Restore in the File the initial group 0002
953  */ 
954 void FileHelper::RestoreWriteFileType()
955 {
956 }
957
958 /**
959  * \brief Set the Write not to Libido format
960  */ 
961 void FileHelper::SetWriteToLibido()
962 {
963    ValEntry *oldRow = dynamic_cast<ValEntry *>
964                 (FileInternal->GetDocEntry(0x0028, 0x0010));
965    ValEntry *oldCol = dynamic_cast<ValEntry *>
966                 (FileInternal->GetDocEntry(0x0028, 0x0011));
967    
968    if( oldRow && oldCol )
969    {
970       std::string rows, columns; 
971
972       ValEntry *newRow=new ValEntry(oldRow->GetDictEntry());
973       ValEntry *newCol=new ValEntry(oldCol->GetDictEntry());
974
975       newRow->Copy(oldCol);
976       newCol->Copy(oldRow);
977
978       newRow->SetValue(oldCol->GetValue());
979       newCol->SetValue(oldRow->GetValue());
980
981       Archive->Push(newRow);
982       Archive->Push(newCol);
983    }
984
985    ValEntry *libidoCode = CopyValEntry(0x0008,0x0010);
986    libidoCode->SetValue("ACRNEMA_LIBIDO_1.1");
987    Archive->Push(libidoCode);
988 }
989
990 /**
991  * \brief Set the Write not to No Libido format
992  */ 
993 void FileHelper::SetWriteToNoLibido()
994 {
995    ValEntry *recCode = dynamic_cast<ValEntry *>
996                 (FileInternal->GetDocEntry(0x0008,0x0010));
997    if( recCode )
998    {
999       if( recCode->GetValue() == "ACRNEMA_LIBIDO_1.1" )
1000       {
1001          ValEntry *libidoCode = CopyValEntry(0x0008,0x0010);
1002          libidoCode->SetValue("");
1003          Archive->Push(libidoCode);
1004       }
1005    }
1006 }
1007
1008 /**
1009  * \brief Restore the Write format
1010  */ 
1011 void FileHelper::RestoreWriteOfLibido()
1012 {
1013    Archive->Restore(0x0028,0x0010);
1014    Archive->Restore(0x0028,0x0011);
1015    Archive->Restore(0x0008,0x0010);
1016
1017    // Restore 'LibIDO-special' entries, if any
1018    Archive->Restore(0x0028,0x0015);
1019    Archive->Restore(0x0028,0x0016);
1020    Archive->Restore(0x0028,0x0017);
1021    Archive->Restore(0x0028,0x00199);
1022 }
1023
1024 /**
1025  * \brief Duplicates a ValEntry or creates it.
1026  * @param   group   Group number of the Entry 
1027  * @param   elem  Element number of the Entry
1028  * \return  pointer to the new Val Entry (NULL when creation failed).          
1029  */ 
1030 ValEntry *FileHelper::CopyValEntry(uint16_t group, uint16_t elem)
1031 {
1032    DocEntry *oldE = FileInternal->GetDocEntry(group, elem);
1033    ValEntry *newE;
1034
1035    if( oldE )
1036    {
1037       newE = new ValEntry(oldE->GetDictEntry());
1038       newE->Copy(oldE);
1039    }
1040    else
1041    {
1042       newE = GetFile()->NewValEntry(group, elem);
1043    }
1044
1045    return newE;
1046 }
1047
1048 /**
1049  * \brief   Duplicates a BinEntry or creates it.
1050  * @param   group   Group number of the Entry 
1051  * @param   elem  Element number of the Entry
1052  * @param   vr  Value Representation of the Entry
1053  *          FIXME : what is it used for?
1054  * \return  pointer to the new Bin Entry (NULL when creation failed).
1055  */ 
1056 BinEntry *FileHelper::CopyBinEntry(uint16_t group, uint16_t elem,
1057                                    const std::string &vr)
1058 {
1059    DocEntry *oldE = FileInternal->GetDocEntry(group, elem);
1060    BinEntry *newE;
1061
1062    if( oldE ) 
1063       if( oldE->GetVR()!=vr )
1064          oldE = NULL;
1065
1066    if( oldE )
1067    {
1068       newE = new BinEntry(oldE->GetDictEntry());
1069       newE->Copy(oldE);
1070    }
1071    else
1072    {
1073       newE = GetFile()->NewBinEntry(group, elem, vr);
1074    }
1075
1076    return newE;
1077 }
1078
1079 /**
1080  * \brief   This method is called automatically, just before writting
1081  *         in order to produce a 'True Dicom V3' image
1082  *         We cannot know *how* the user made the File (reading an old ACR-NEMA
1083  *         file or a not very clean DICOM file ...) 
1084  *          
1085  *          Just before writting :
1086  *             - we check the Entries
1087  *             - we create the mandatory entries if they are missing
1088  *             - we modify the values if necessary
1089  *             - we push the sensitive entries to the Archive
1090  *          The writing process will restore the entries as they where before 
1091  *          entering FileHelper::CheckMandatoryElements, so the user will always
1092  *          see the entries just as he left them.
1093  * 
1094  * \todo : - warn the user if we had to add some entries :
1095  *         even if a mandatory entry is missing, we add it, with a default value
1096  *         (we don't want to give up the writting process if user forgot to
1097  *         specify Lena's Patient ID, for instance ...)
1098  *         - read the whole PS 3.3 Part of DICOM  (890 pages)
1099  *         and write a *full* checker (probably one method per Modality ...)
1100  *         Any contribution is welcome. 
1101  *         - write a user callable full checker, to allow post reading
1102  *         and/or pre writting image consistency check.           
1103  */ 
1104  
1105 void FileHelper::CheckMandatoryElements()
1106 {
1107    // just to remember : 'official' 0002 group
1108
1109    //0002 0000 UL 1 Meta Group Length
1110    //0002 0001 OB 1 File Meta Information Version
1111    //0002 0002 UI 1 Media Stored SOP Class UID
1112    //0002 0003 UI 1 Media Stored SOP Instance UID
1113    //0002 0010 UI 1 Transfer Syntax UID
1114    //0002 0012 UI 1 Implementation Class UID
1115    //0002 0013 SH 1 Implementation Version Name
1116    //0002 0016 AE 1 Source Application Entity Title
1117    //0002 0100 UI 1 Private Information Creator
1118    //0002 0102 OB 1 Private Information
1119   
1120    // Create them if not found
1121    // Always modify the value
1122    // Push the entries to the archive.
1123    ValEntry *e_0002_0000 = CopyValEntry(0x0002,0x0000);
1124       e_0002_0000->SetValue("0"); // for the moment
1125       Archive->Push(e_0002_0000);
1126   
1127    BinEntry *e_0002_0001 = CopyBinEntry(0x0002,0x0001, "OB");
1128       e_0002_0001->SetBinArea((uint8_t*)Util::GetFileMetaInformationVersion(),
1129                                false);
1130       e_0002_0001->SetLength(2);
1131       Archive->Push(e_0002_0001);
1132
1133    ValEntry *e_0002_0002 = CopyValEntry(0x0002,0x0002);
1134       // [Secondary Capture Image Storage]
1135       e_0002_0002->SetValue("1.2.840.10008.5.1.4.1.1.7"); 
1136       Archive->Push(e_0002_0002);
1137  
1138    // 'Media Stored SOP Instance UID'   
1139    ValEntry *e_0002_0003 = CopyValEntry(0x0002,0x0003);
1140       e_0002_0003->SetValue(Util::CreateUniqueUID());
1141       Archive->Push(e_0002_0003); 
1142
1143    // 'Implementation Class UID'
1144    ValEntry *e_0002_0012 = CopyValEntry(0x0002,0x0012);
1145       e_0002_0012->SetValue(Util::CreateUniqueUID());
1146       Archive->Push(e_0002_0012); 
1147
1148    // 'Implementation Version Name'
1149    ValEntry *e_0002_0013 = CopyValEntry(0x0002,0x0013);
1150       e_0002_0013->SetValue("GDCM 1.0");
1151       Archive->Push(e_0002_0013);
1152
1153    //'Source Application Entity Title' Not Mandatory
1154    //ValEntry *e_0002_0016 = CopyValEntry(0x0002,0x0016);
1155    //   e_0002_0016->SetValue("1.2.840.10008.5.1.4.1.1.7");
1156    //   Archive->Push(e_0002_0016);
1157
1158    // Push out 'LibIDO-special' entries, if any
1159    Archive->Push(0x0028,0x0015);
1160    Archive->Push(0x0028,0x0016);
1161    Archive->Push(0x0028,0x0017);
1162    Archive->Push(0x0028,0x00199);
1163
1164    // --- Check UID-related Entries ---
1165
1166    // If 'SOP Class UID' exists ('true DICOM' image)
1167    // we create the 'Source Image Sequence' SeqEntry
1168    // to hold informations about the Source Image
1169
1170    ValEntry *e_0008_0016 = FileInternal->GetValEntry(0x0008, 0x0016);
1171    if ( e_0008_0016 != 0 )
1172    {
1173       // Create 'Source Image Sequence' SeqEntry
1174       SeqEntry *s = new SeqEntry (
1175             Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x2112) );
1176       SQItem *sqi = new SQItem(1);
1177       // (we assume 'SOP Instance UID' exists too) 
1178       // create 'Referenced SOP Class UID'
1179       ValEntry *e_0008_1150 = new ValEntry(
1180             Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x1150) );
1181       e_0008_1150->SetValue( e_0008_0016->GetValue());
1182       sqi->AddEntry(e_0008_1150);
1183       
1184       // create 'Referenced SOP Instance UID'
1185       ValEntry *e_0008_0018 = FileInternal->GetValEntry(0x0008, 0x0018);
1186       ValEntry *e_0008_1155 = new ValEntry(
1187             Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x1155) );
1188       e_0008_1155->SetValue( e_0008_0018->GetValue());
1189       sqi->AddEntry(e_0008_1155);
1190
1191       s->AddSQItem(sqi,1); 
1192       // temporarily replaces any previous 'Source Image Sequence' 
1193       Archive->Push(s);
1194  
1195       // 'Image Type' (The written image is no longer an 'ORIGINAL' one)
1196       ValEntry *e_0008_0008 = CopyValEntry(0x0008,0x0008);
1197       e_0008_0008->SetValue("DERIVED\\PRIMARY");
1198       Archive->Push(e_0008_0008);
1199    } 
1200    else
1201    {
1202       // There was no 'SOP Class UID'.
1203       // the source image was NOT a true Dicom one.
1204       // We consider the image is a 'Secondary Capture' one
1205       // SOP Class UID
1206       e_0008_0016  =  new ValEntry( 
1207             Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0016) );
1208       // [Secondary Capture Image Storage]
1209       e_0008_0016 ->SetValue("1.2.840.10008.5.1.4.1.1.7"); 
1210       Archive->Push(e_0008_0016); 
1211    }
1212
1213 // ---- The user will never have to take any action on the following ----.
1214
1215    // new value for 'SOP Instance UID'
1216    ValEntry *e_0008_0018 = new ValEntry(
1217          Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0018) );
1218    e_0008_0018->SetValue( Util::CreateUniqueUID() );
1219    Archive->Push(e_0008_0018);
1220
1221    // Instance Creation Date
1222    ValEntry *e_0008_0012 = CopyValEntry(0x0008,0x0012);
1223    std::string date = Util::GetCurrentDate();
1224    e_0008_0012->SetValue(date.c_str());
1225    Archive->Push(e_0008_0012);
1226  
1227    // Instance Creation Time
1228    ValEntry *e_0008_0013 = CopyValEntry(0x0008,0x0013);
1229    std::string time = Util::GetCurrentTime();
1230    e_0008_0013->SetValue(time.c_str());
1231    Archive->Push(e_0008_0013);
1232
1233 // ----- Add Mandatory Entries if missing ---
1234
1235 // Entries whose type is 1 are mandatory, with a mandatory value
1236 // Entries whose type is 1c are mandatory-inside-a-Sequence
1237 // Entries whose type is 2 are mandatory, with a optional value
1238 // Entries whose type is 2c are mandatory-inside-a-Sequence
1239 // Entries whose type is 3 are optional
1240
1241    // 'Serie Instance UID'
1242    // Keep the value if exists
1243    // The user is allowed to create his own Series, 
1244    // keeping the same 'Serie Instance UID' for various images
1245    // The user shouldn't add any image to a 'Manufacturer Serie'
1246    // but there is no way no to allowed him to do that 
1247    ValEntry *e_0020_000e = FileInternal->GetValEntry(0x0020, 0x000e);
1248    if ( !e_0020_000e )
1249    {
1250       e_0020_000e = new ValEntry(
1251            Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0020, 0x000e) );
1252       e_0020_000e->SetValue(Util::CreateUniqueUID() );
1253       Archive->Push(e_0020_000e);
1254    } 
1255
1256    // 'Study Instance UID'
1257    // Keep the value if exists
1258    // The user is allowed to create his own Study, 
1259    //          keeping the same 'Study Instance UID' for various images
1260    // The user may add images to a 'Manufacturer Study',
1261    //          adding new series to an already existing Study 
1262    ValEntry *e_0020_000d = FileInternal->GetValEntry(0x0020, 0x000d);
1263    if ( !e_0020_000d )
1264    {
1265       e_0020_000d = new ValEntry(
1266             Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0020, 0x000d) );
1267       e_0020_000d->SetValue(Util::CreateUniqueUID() );
1268       Archive->Push(e_0020_000d);
1269    }
1270
1271    // Modality : if missing we set it to 'OTher'
1272    ValEntry *e_0008_0060 = FileInternal->GetValEntry(0x0008, 0x0060);
1273    if ( !e_0008_0060 )
1274    {
1275       e_0008_0060 = new ValEntry(
1276             Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0060) );
1277       e_0008_0060->SetValue("OT");
1278       Archive->Push(e_0008_0060);
1279    } 
1280
1281    // Manufacturer : if missing we set it to 'GDCM Factory'
1282    ValEntry *e_0008_0070 = FileInternal->GetValEntry(0x0008, 0x0070);
1283    if ( !e_0008_0070 )
1284    {
1285       e_0008_0070 = new ValEntry(
1286             Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0070) );
1287       e_0008_0070->SetValue("GDCM Factory");
1288       Archive->Push(e_0008_0070);
1289    } 
1290
1291    // Institution Name : if missing we set it to 'GDCM Hospital'
1292    ValEntry *e_0008_0080 = FileInternal->GetValEntry(0x0008, 0x0080);
1293    if ( !e_0008_0080 )
1294    {
1295       e_0008_0080 = new ValEntry(
1296             Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0080) );
1297       e_0008_0080->SetValue("GDCM Hospital");
1298       Archive->Push(e_0008_0080);
1299    } 
1300
1301    // Patient's Name : if missing, we set it to 'GDCM^Patient'
1302    ValEntry *e_0010_0010 = FileInternal->GetValEntry(0x0010, 0x0010);
1303    if ( !e_0010_0010 )
1304    {
1305       e_0010_0010 = new ValEntry(
1306             Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0010, 0x0010) );
1307       e_0010_0010->SetValue("GDCM^Patient");
1308       Archive->Push(e_0010_0010);
1309    } 
1310
1311    // Patient's Birth Date : 'type 2' entry -> must exist, value not mandatory
1312    ValEntry *e_0010_0030 = FileInternal->GetValEntry(0x0010, 0x0030);
1313    if ( !e_0010_0030 )
1314    {
1315       e_0010_0030 = new ValEntry(
1316             Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0010, 0x0030) );
1317       e_0010_0030->SetValue("");
1318       Archive->Push(e_0010_0030);
1319    }
1320
1321    // Patient's Sex :'type 2' entry -> must exist, value not mandatory
1322    ValEntry *e_0010_0040 = FileInternal->GetValEntry(0x0010, 0x0040);
1323    if ( !e_0010_0040 )
1324    {
1325       e_0010_0040 = new ValEntry(
1326             Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0010, 0x0040) );
1327       e_0010_0040->SetValue("");
1328       Archive->Push(e_0010_0040);
1329    }
1330
1331    // Referring Physician's Name :'type 2' entry -> must exist, value not mandatory
1332    ValEntry *e_0008_0090 = FileInternal->GetValEntry(0x0008, 0x0090);
1333    if ( !e_0008_0090 )
1334    {
1335       e_0008_0090 = new ValEntry(
1336             Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0090) );
1337       e_0008_0090->SetValue("");
1338       Archive->Push(e_0008_0090);
1339    }
1340  
1341    // Remove some inconstencies (probably some more will be added)
1342
1343    // if (0028 0008)Number of Frames exists
1344    //    Push out (0020 0052),Frame of Reference UID
1345    //    (only meaningfull within a Serie)
1346    ValEntry *e_0028_0008 = FileInternal->GetValEntry(0x0028, 0x0008);
1347    if ( !e_0028_0008 )
1348    {
1349       Archive->Push(0x0020, 0X0052);
1350    }
1351
1352  
1353 /**
1354  * \brief Restore in the File the initial group 0002
1355  */
1356 void FileHelper::RestoreWriteMandatory()
1357 {
1358    // group 0002 may be pushed out for ACR-NEMA writting purposes 
1359    Archive->Restore(0x0002,0x0000);
1360    Archive->Restore(0x0002,0x0001);
1361    Archive->Restore(0x0002,0x0002);
1362    Archive->Restore(0x0002,0x0003);
1363    Archive->Restore(0x0002,0x0012);
1364    Archive->Restore(0x0002,0x0013);
1365    Archive->Restore(0x0002,0x0016);
1366    Archive->Restore(0x0002,0x0100);
1367    Archive->Restore(0x0002,0x0102);
1368 }
1369
1370 //-----------------------------------------------------------------------------
1371 // Private
1372 /**
1373  * \brief Factorization for various forms of constructors.
1374  */
1375 void FileHelper::Initialize()
1376 {
1377    WriteMode = WMODE_RAW;
1378    WriteType = ExplicitVR;
1379
1380    PixelReadConverter  = new PixelReadConvert;
1381    PixelWriteConverter = new PixelWriteConvert;
1382    Archive = new DocEntryArchive( FileInternal );
1383
1384    if ( FileInternal->IsReadable() )
1385    {
1386       PixelReadConverter->GrabInformationsFromFile( FileInternal );
1387    }
1388 }
1389
1390 /**
1391  * \brief   
1392  */ 
1393 uint8_t *FileHelper::GetRaw()
1394 {
1395    uint8_t *raw = PixelReadConverter->GetRaw();
1396    if ( ! raw )
1397    {
1398       // The Raw image migth not be loaded yet:
1399       std::ifstream *fp = FileInternal->OpenFile();
1400       PixelReadConverter->ReadAndDecompressPixelData( fp );
1401       if(fp) 
1402          FileInternal->CloseFile();
1403
1404       raw = PixelReadConverter->GetRaw();
1405       if ( ! raw )
1406       {
1407          gdcmWarningMacro( "Read/decompress of pixel data apparently went wrong.");
1408          return 0;
1409       }
1410    }
1411
1412    return raw;
1413 }
1414
1415 //-----------------------------------------------------------------------------
1416 // Print
1417 void FileHelper::Print(std::ostream &os, std::string const &)
1418 {
1419    FileInternal->SetPrintLevel(PrintLevel);
1420    FileInternal->Print(os);
1421
1422    PixelReadConverter->SetPrintLevel(PrintLevel);
1423    PixelReadConverter->Print(os);
1424 }
1425
1426 //-----------------------------------------------------------------------------
1427 } // end namespace gdcm