X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmFileHelper.cxx;h=3357faa8f85dde82ad697a17ba18de0a89c7d912;hb=928d3c30e40ab7f3d12bfd038ce8a48befcddce8;hp=996b67ec06302f07ed738607ecb26d40b96f8954;hpb=3f99e798955f65c1b906ad65016d1b49bde25ef8;p=gdcm.git

diff --git a/src/gdcmFileHelper.cxx b/src/gdcmFileHelper.cxx
index 996b67ec..3357faa8 100644
--- a/src/gdcmFileHelper.cxx
+++ b/src/gdcmFileHelper.cxx
@@ -3,8 +3,9 @@
   Program:   gdcm
   Module:    $RCSfile: gdcmFileHelper.cxx,v $
   Language:  C++
-  Date:      $Date: 2005/02/17 11:00:33 $
-  Version:   $Revision: 1.17 $
+
+  Date:      $Date: 2005/10/21 10:29:51 $
+  Version:   $Revision: 1.66 $
                                                                                 
   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
   l'Image). All rights reserved. See Doc/License.txt or
@@ -22,16 +23,93 @@
 #include "gdcmDocument.h"
 #include "gdcmDebug.h"
 #include "gdcmUtil.h"
-#include "gdcmBinEntry.h"
-#include "gdcmValEntry.h"
-#include "gdcmContentEntry.h"
+#include "gdcmSeqEntry.h"
+#include "gdcmSQItem.h"
+#include "gdcmDataEntry.h"
 #include "gdcmFile.h"
 #include "gdcmPixelReadConvert.h"
 #include "gdcmPixelWriteConvert.h"
 #include "gdcmDocEntryArchive.h"
+#include "gdcmDictSet.h"
 
 #include <fstream>
 
+/*
+// ----------------------------- WARNING -------------------------
+
+These lines will be moved to the document-to-be 'User's Guide'
+
+// To read an image, user needs a gdcm::File
+gdcm::File *f = new gdcm::File(fileName);
+// or (advanced) :
+// user may also decide he doesn't want to load some parts of the header
+gdcm::File *f = new gdcm::File();
+f->SetFileName(fileName);
+   f->SetLoadMode(LD_NOSEQ);             // or      
+   f->SetLoadMode(LD_NOSHADOW);          // or
+   f->SetLoadMode(LD_NOSEQ | LD_NOSHADOW); // or
+   f->SetLoadMode(LD_NOSHADOWSEQ);
+f->Load();
+
+// user can now check some values
+std::string v = f->GetEntryValue(groupNb,ElementNb);
+
+// to get the pixels, user needs a gdcm::FileHelper
+gdcm::FileHelper *fh = new gdcm::FileHelper(f);
+// user may ask not to convert Palette to RGB
+uint8_t *pixels = fh->GetImageDataRaw();
+int imageLength = fh->GetImageDataRawSize();
+// He can now use the pixels, create a new image, ...
+uint8_t *userPixels = ...
+
+To re-write the image, user re-uses the gdcm::FileHelper
+
+fh->SetImageData( userPixels, userPixelsLength);
+fh->SetTypeToRaw(); // Even if it was possible to convert Palette to RGB
+                     // (WriteMode is set)
+ 
+fh->SetWriteTypeToDcmExpl(); // he wants Explicit Value Representation
+                              // Little Endian is the default
+                              // no other value is allowed
+                                (-->SetWriteType(ExplicitVR);)
+                                   -->WriteType = ExplicitVR;
+fh->Write(newFileName);      // overwrites the file, if any
+
+// or :
+fh->WriteDcmExplVR(newFileName);
+
+
+// ----------------------------- WARNING -------------------------
+
+These lines will be moved to the document-to-be 'Developer's Guide'
+
+WriteMode : WMODE_RAW / WMODE_RGB
+WriteType : ImplicitVR, ExplicitVR, ACR, ACR_LIBIDO
+
+fh1->Write(newFileName);
+   SetWriteFileTypeToImplicitVR() / SetWriteFileTypeToExplicitVR();
+   (modifies TransferSyntax)
+   SetWriteToRaw(); / SetWriteToRGB();
+      (modifies, when necessary : photochromatic interpretation, 
+         samples per pixel, Planar configuration, 
+         bits allocated, bits stored, high bit -ACR 24 bits-
+         Pixels element VR, pushes out the LUT )
+   CheckWriteIntegrity();
+      (checks user given pixels length)
+   FileInternal->Write(fileName,WriteType)
+   fp = opens file(fileName);
+   ComputeGroup0002Length( );
+   BitsAllocated 12->16
+      RemoveEntryNoDestroy(palettes, etc)
+      Document::WriteContent(fp, writetype);
+   RestoreWrite();
+      (moves back to the File all the archived elements)
+   RestoreWriteFileType();
+      (pushes back group 0002, with TransferSyntax)
+*/
+
+
+
 
 namespace gdcm 
 {
@@ -43,6 +121,7 @@ namespace gdcm
  *        Opens (in read only and when possible) an existing file and checks
  *        for DICOM compliance. Returns NULL on failure.
  *        It will be up to the user to load the pixels into memory
+ *        ( GetImageDataSize() + GetImageData() methods)
  * \note  the in-memory representation of all available tags found in
  *        the DICOM header is post-poned to first header information access.
  *        This avoid a double parsing of public part of the header when
@@ -50,7 +129,7 @@ namespace gdcm
  *        seen as a side effect).   
  */
 FileHelper::FileHelper( )
-{
+{ 
    FileInternal = new File( );
    SelfHeader = true;
    Initialize();
@@ -62,6 +141,7 @@ FileHelper::FileHelper( )
  *        Opens (in read only and when possible) an existing file and checks
  *        for DICOM compliance. Returns NULL on failure.
  *        It will be up to the user to load the pixels into memory
+ *        ( GetImageDataSize() + GetImageData() methods)
  * \note  the in-memory representation of all available tags found in
  *        the DICOM header is post-poned to first header information access.
  *        This avoid a double parsing of public part of the header when
@@ -74,10 +154,16 @@ FileHelper::FileHelper(File *header)
    FileInternal = header;
    SelfHeader = false;
    Initialize();
+   if ( FileInternal->IsReadable() )
+   {
+      PixelReadConverter->GrabInformationsFromFile( FileInternal );
+   }
 }
 
+#ifndef GDCM_LEGACY_REMOVE
 /**
- * \brief Constructor dedicated to deal with the *pixels* area of a ACR/DICOMV3
+ * \brief DEPRECATED : use SetFilename() + SetLoadMode() + Load() methods
+ *        Constructor dedicated to deal with the *pixels* area of a ACR/DICOMV3
  *        file (gdcm::File only deals with the ... header)
  *        Opens (in read only and when possible) an existing file and checks
  *        for DICOM compliance. Returns NULL on failure.
@@ -88,13 +174,21 @@ FileHelper::FileHelper(File *header)
  *        one sets an a posteriori shadow dictionary (efficiency can be
  *        seen as a side effect).   
  * @param filename file to be opened for parsing
+ * @deprecated  use SetFilename() + Load() methods
  */
 FileHelper::FileHelper(std::string const &filename )
 {
-   FileInternal = new File( filename );
+   FileInternal = new File( );
+   FileInternal->SetFileName( filename );
+   FileInternal->Load();
    SelfHeader = true;
    Initialize();
+   if ( FileInternal->IsReadable() )
+   {
+      PixelReadConverter->GrabInformationsFromFile( FileInternal );
+   }
 }
+#endif
 
 /**
  * \brief canonical destructor
@@ -103,20 +197,20 @@ FileHelper::FileHelper(std::string const &filename )
  */
 FileHelper::~FileHelper()
 { 
-   if( PixelReadConverter )
+   if ( PixelReadConverter )
    {
       delete PixelReadConverter;
    }
-   if( PixelWriteConverter )
+   if ( PixelWriteConverter )
    {
       delete PixelWriteConverter;
    }
-   if( Archive )
+   if ( Archive )
    {
       delete Archive;
    }
 
-   if( SelfHeader )
+   if ( SelfHeader )
    {
       delete FileInternal;
    }
@@ -125,6 +219,43 @@ FileHelper::~FileHelper()
 
 //-----------------------------------------------------------------------------
 // Public
+
+/**
+ * \brief Sets the LoadMode of the internal gdcm::File as a boolean string. 
+ *        NO_SEQ, NO_SHADOW, NO_SHADOWSEQ
+ *... (nothing more, right now)
+ *        WARNING : before using NO_SHADOW, be sure *all* your files
+ *        contain accurate values in the 0x0000 element (if any) 
+ *        of *each* Shadow Group. The parser will fail if the size is wrong !
+ * @param   loadMode Load mode to be used    
+ */
+void FileHelper::SetLoadMode(int loadMode) 
+{ 
+   GetFile()->SetLoadMode( loadMode ); 
+}
+/**
+ * \brief Sets the LoadMode of the internal gdcm::File
+ * @param  fileName name of the file to be open  
+ */
+void FileHelper::SetFileName(std::string const &fileName)
+{
+   FileInternal->SetFileName( fileName );
+}
+
+/**
+ * \brief   Loader  
+ * @return false if file cannot be open or no swap info was found,
+ *         or no tag was found.
+ */
+bool FileHelper::Load()
+{ 
+   if ( !FileInternal->Load() )
+      return false;
+
+   PixelReadConverter->GrabInformationsFromFile( FileInternal );
+   return true;
+}
+
 /**
  * \brief   Accesses an existing DocEntry (i.e. a Dicom Element)
  *          through it's (group, element) and modifies it's content with
@@ -134,10 +265,10 @@ FileHelper::~FileHelper()
  * @param   elem element number of the Dicom Element to modify
  * \return  false if DocEntry not found
  */
-bool FileHelper::SetValEntry(std::string const &content,
-                             uint16_t group, uint16_t elem)
+bool FileHelper::SetEntryString(std::string const &content,
+                                    uint16_t group, uint16_t elem)
 { 
-   return FileInternal->SetValEntry(content, group, elem);
+   return FileInternal->SetEntryString(content, group, elem);
 }
 
 
@@ -151,10 +282,10 @@ bool FileHelper::SetValEntry(std::string const &content,
  * @param   elem element number of the Dicom Element to modify
  * \return  false if DocEntry not found
  */
-bool FileHelper::SetBinEntry(uint8_t *content, int lgth,
-                             uint16_t group, uint16_t elem)
+bool FileHelper::SetEntryBinArea(uint8_t *content, int lgth,
+                                     uint16_t group, uint16_t elem)
 {
-   return FileInternal->SetBinEntry(content, lgth, group, elem);
+   return FileInternal->SetEntryBinArea(content, lgth, group, elem);
 }
 
 /**
@@ -166,10 +297,10 @@ bool FileHelper::SetBinEntry(uint8_t *content, int lgth,
  * \return  pointer to the modified/created Dicom entry (NULL when creation
  *          failed).
  */ 
-ValEntry *FileHelper::InsertValEntry(std::string const &content,
-                                     uint16_t group, uint16_t elem)
+DataEntry *FileHelper::InsertEntryString(std::string const &content,
+                                                uint16_t group, uint16_t elem)
 {
-   return FileInternal->InsertValEntry(content,group,elem);
+   return FileInternal->InsertEntryString(content, group, elem);
 }
 
 /**
@@ -183,10 +314,10 @@ ValEntry *FileHelper::InsertValEntry(std::string const &content,
  * \return  pointer to the modified/created Dicom entry (NULL when creation
  *          failed).
  */
-BinEntry *FileHelper::InsertBinEntry(uint8_t *binArea, int lgth,
-                                     uint16_t group, uint16_t elem)
+DataEntry *FileHelper::InsertEntryBinArea(uint8_t *binArea, int lgth,
+                                                 uint16_t group, uint16_t elem)
 {
-   return FileInternal->InsertBinEntry(binArea, lgth, group, elem);
+   return FileInternal->InsertEntryBinArea(binArea, lgth, group, elem);
 }
 
 /**
@@ -216,7 +347,6 @@ size_t FileHelper::GetImageDataSize()
    {
       return PixelWriteConverter->GetUserDataSize();
    }
-
    return PixelReadConverter->GetRGBSize();
 }
 
@@ -233,7 +363,6 @@ size_t FileHelper::GetImageDataRawSize()
    {
       return PixelWriteConverter->GetUserDataSize();
    }
-
    return PixelReadConverter->GetRawSize();
 }
 
@@ -285,9 +414,11 @@ uint8_t *FileHelper::GetImageDataRaw ()
    return GetRaw();
 }
 
+#ifndef GDCM_LEGACY_REMOVE
 /**
- * \brief
- *          Read the pixels from disk (uncompress if necessary),
+ * \brief   Useless function, since PixelReadConverter forces us 
+ *          copy the Pixels anyway.  
+ *          Reads the pixels from disk (uncompress if necessary),
  *          Transforms YBR pixels, if any, into RGB pixels
  *          Transforms 3 planes R, G, B, if any, into a single RGB Plane
  *          Transforms single Grey plane + 3 Palettes into a RGB Plane   
@@ -338,10 +469,11 @@ size_t FileHelper::GetImageDataIntoVector (void *destination, size_t maxSize)
       return 0;
    }
    memcpy( destination,
-           (void*)PixelReadConverter->GetRaw(),
+           (void *)PixelReadConverter->GetRaw(),
            PixelReadConverter->GetRawSize() );
    return PixelReadConverter->GetRawSize();
 }
+#endif
 
 /**
  * \brief   Points the internal pointer to the callers inData
@@ -433,9 +565,27 @@ size_t FileHelper::GetRawDataSize()
  */
 uint8_t* FileHelper::GetLutRGBA()
 {
+   if ( PixelReadConverter->GetLutRGBA() ==0 )
+      PixelReadConverter->BuildLUTRGBA();
    return PixelReadConverter->GetLutRGBA();
 }
 
+/**
+ * \brief Access to the underlying \ref PixelReadConverter RGBA LUT Item Number
+ */
+int FileHelper::GetLutItemNumber()
+{
+   return PixelReadConverter->GetLutItemNumber();
+}
+
+/**
+ * \brief Access to the underlying \ref PixelReadConverter RGBA LUT Item Size
+ */
+int FileHelper::GetLutItemSize()
+{
+   return PixelReadConverter->GetLutItemSize();
+}
+
 /**
  * \brief Writes on disk A SINGLE Dicom file
  *        NO test is performed on  processor "Endiannity".
@@ -446,26 +596,26 @@ uint8_t* FileHelper::GetLutRGBA()
  */
 bool FileHelper::WriteRawData(std::string const &fileName)
 {
-  std::ofstream fp1(fileName.c_str(), std::ios::out | std::ios::binary );
+   std::ofstream fp1(fileName.c_str(), std::ios::out | std::ios::binary );
    if (!fp1)
    {
       gdcmWarningMacro( "Fail to open (write) file:" << fileName.c_str());
       return false;
    }
 
-   if( PixelWriteConverter->GetUserData() )
+   if ( PixelWriteConverter->GetUserData() )
    {
-      fp1.write( (char*)PixelWriteConverter->GetUserData(), 
+      fp1.write( (char *)PixelWriteConverter->GetUserData(), 
                  PixelWriteConverter->GetUserDataSize() );
    }
    else if ( PixelReadConverter->GetRGB() )
    {
-      fp1.write( (char*)PixelReadConverter->GetRGB(), 
+      fp1.write( (char *)PixelReadConverter->GetRGB(), 
                  PixelReadConverter->GetRGBSize());
    }
    else if ( PixelReadConverter->GetRaw() )
    {
-      fp1.write( (char*)PixelReadConverter->GetRaw(), 
+      fp1.write( (char *)PixelReadConverter->GetRaw(), 
                  PixelReadConverter->GetRawSize());
    }
    else
@@ -481,7 +631,7 @@ bool FileHelper::WriteRawData(std::string const &fileName)
 /**
  * \brief Writes on disk A SINGLE Dicom file, 
  *        using the Implicit Value Representation convention
- *        NO test is performed on  processor "Endiannity".
+ *        NO test is performed on  processor "Endianity".
  * @param fileName name of the file to be created
  *                 (any already existing file is overwritten)
  * @return false if write fails
@@ -540,20 +690,30 @@ bool FileHelper::Write(std::string const &fileName)
    {
       case ImplicitVR:
          SetWriteFileTypeToImplicitVR();
-         CheckMetaElements();
          break;
+      case Unknown:  // should never happen; ExplicitVR is the default value
       case ExplicitVR:
          SetWriteFileTypeToExplicitVR();
-         CheckMetaElements();
          break;
       case ACR:
       case ACR_LIBIDO:
+      // NOTHING is done here just for LibIDO.
+      // Just to avoid further trouble if user creates a file ex-nihilo,
+      // wants to write it as an ACR-NEMA file,
+      // and forgets to create any Entry belonging to group 0008
+      // (shame on him !)
+      // We add Recognition Code (RET)
+        if ( ! FileInternal->GetDataEntry(0x0008, 0x0010) )
+            FileInternal->InsertEntryString("ACR-NEMA V1.0 ", 0x0008, 0x0010);
          SetWriteFileTypeToACR();
+        // SetWriteFileTypeToImplicitVR(); // ACR IS implicit VR !
+         break;
+      case JPEG:
+         SetWriteFileTypeToJPEG();
+         std::cerr << "Writting as JPEG" << std::endl;
          break;
-      default:
-         SetWriteFileTypeToExplicitVR();
-         CheckMetaElements();
    }
+   CheckMandatoryElements();
 
    // --------------------------------------------------------------
    // Special Patch to allow gdcm to re-write ACR-LibIDO formated images
@@ -563,7 +723,8 @@ bool FileHelper::Write(std::string const &fileName)
    // just before writting ...
    /// \todo the best trick would be *change* the recognition code
    ///       but pb expected if user deals with, e.g. COMPLEX images
-   if( WriteType == ACR_LIBIDO )
+   
+   if ( WriteType == ACR_LIBIDO )
    {
       SetWriteToLibido();
    }
@@ -584,13 +745,15 @@ bool FileHelper::Write(std::string const &fileName)
    }
 
    bool check = CheckWriteIntegrity(); // verifies length
-   if(check)
+   if (WriteType == JPEG ) check = true;
+   if (check)
    {
       check = FileInternal->Write(fileName,WriteType);
    }
 
    RestoreWrite();
    RestoreWriteFileType();
+   RestoreWriteMandatory();
 
    // --------------------------------------------------------------
    // Special Patch to allow gdcm to re-write ACR-LibIDO formated images
@@ -615,27 +778,30 @@ bool FileHelper::Write(std::string const &fileName)
  */
 bool FileHelper::CheckWriteIntegrity()
 {
-   if(PixelWriteConverter->GetUserData())
+   if ( PixelWriteConverter->GetUserData() )
    {
       int numberBitsAllocated = FileInternal->GetBitsAllocated();
       if ( numberBitsAllocated == 0 || numberBitsAllocated == 12 )
       {
+         gdcmWarningMacro( "numberBitsAllocated changed from " 
+                          << numberBitsAllocated << " to 16 " 
+                          << " for consistency purpose" );
          numberBitsAllocated = 16;
       }
 
       size_t decSize = FileInternal->GetXSize()
-                    * FileInternal->GetYSize() 
-                    * FileInternal->GetZSize()
-                    * ( numberBitsAllocated / 8 )
-                    * FileInternal->GetSamplesPerPixel();
+                     * FileInternal->GetYSize() 
+                     * FileInternal->GetZSize()
+                     * FileInternal->GetSamplesPerPixel()
+                     * ( numberBitsAllocated / 8 );
       size_t rgbSize = decSize;
-      if( FileInternal->HasLUT() )
+      if ( FileInternal->HasLUT() )
          rgbSize = decSize * 3;
 
       switch(WriteMode)
       {
          case WMODE_RAW :
-            if( decSize!=PixelWriteConverter->GetUserDataSize() )
+            if ( decSize!=PixelWriteConverter->GetUserDataSize() )
             {
                gdcmWarningMacro( "Data size (Raw) is incorrect. Should be " 
                            << decSize << " / Found :" 
@@ -644,7 +810,7 @@ bool FileHelper::CheckWriteIntegrity()
             }
             break;
          case WMODE_RGB :
-            if( rgbSize!=PixelWriteConverter->GetUserDataSize() )
+            if ( rgbSize!=PixelWriteConverter->GetUserDataSize() )
             {
                gdcmWarningMacro( "Data size (RGB) is incorrect. Should be " 
                           << decSize << " / Found " 
@@ -654,7 +820,7 @@ bool FileHelper::CheckWriteIntegrity()
             break;
       }
    }
-   
+
    return true;
 }
 
@@ -665,34 +831,34 @@ bool FileHelper::CheckWriteIntegrity()
  */ 
 void FileHelper::SetWriteToRaw()
 {
-   if( FileInternal->GetNumberOfScalarComponents() == 3 
-    && !FileInternal->HasLUT())
+   if ( FileInternal->GetNumberOfScalarComponents() == 3 
+    && !FileInternal->HasLUT() )
    {
       SetWriteToRGB();
    } 
    else
    {
-      ValEntry *photInt = CopyValEntry(0x0028,0x0004);
-      if(FileInternal->HasLUT())
+      DataEntry *photInt = CopyDataEntry(0x0028,0x0004);
+      if (FileInternal->HasLUT() )
       {
-         photInt->SetValue("PALETTE COLOR ");
+         photInt->SetString("PALETTE COLOR ");
       }
       else
       {
-         photInt->SetValue("MONOCHROME2 ");
+         photInt->SetString("MONOCHROME2 ");
       }
 
       PixelWriteConverter->SetReadData(PixelReadConverter->GetRaw(),
                                        PixelReadConverter->GetRawSize());
 
       std::string vr = "OB";
-      if( FileInternal->GetBitsAllocated()>8 )
+      if ( FileInternal->GetBitsAllocated()>8 )
          vr = "OW";
-      if( FileInternal->GetBitsAllocated()==24 ) // For RGB ACR files 
+      if ( FileInternal->GetBitsAllocated()==24 ) // For RGB ACR files 
          vr = "OB";
-      BinEntry *pixel = 
-         CopyBinEntry(GetFile()->GetGrPixel(),GetFile()->GetNumPixel(),vr);
-      pixel->SetValue(GDCM_BINLOADED);
+      DataEntry *pixel = 
+         CopyDataEntry(GetFile()->GetGrPixel(),GetFile()->GetNumPixel(),vr);
+      pixel->SetFlag(DataEntry::FLAG_PIXELDATA);
       pixel->SetBinArea(PixelWriteConverter->GetData(),false);
       pixel->SetLength(PixelWriteConverter->GetDataSize());
 
@@ -710,20 +876,20 @@ void FileHelper::SetWriteToRaw()
  */ 
 void FileHelper::SetWriteToRGB()
 {
-   if(FileInternal->GetNumberOfScalarComponents()==3)
+   if ( FileInternal->GetNumberOfScalarComponents()==3 )
    {
       PixelReadConverter->BuildRGBImage();
       
-      ValEntry *spp = CopyValEntry(0x0028,0x0002);
-      spp->SetValue("3 ");
+      DataEntry *spp = CopyDataEntry(0x0028,0x0002);
+      spp->SetString("3 ");
 
-      ValEntry *planConfig = CopyValEntry(0x0028,0x0006);
-      planConfig->SetValue("0 ");
+      DataEntry *planConfig = CopyDataEntry(0x0028,0x0006);
+      planConfig->SetString("0 ");
 
-      ValEntry *photInt = CopyValEntry(0x0028,0x0004);
-      photInt->SetValue("RGB ");
+      DataEntry *photInt = CopyDataEntry(0x0028,0x0004);
+      photInt->SetString("RGB ");
 
-      if(PixelReadConverter->GetRGB())
+      if ( PixelReadConverter->GetRGB() )
       {
          PixelWriteConverter->SetReadData(PixelReadConverter->GetRGB(),
                                           PixelReadConverter->GetRGBSize());
@@ -735,13 +901,13 @@ void FileHelper::SetWriteToRGB()
       }
 
       std::string vr = "OB";
-      if( FileInternal->GetBitsAllocated()>8 )
+      if ( FileInternal->GetBitsAllocated()>8 )
          vr = "OW";
-      if( FileInternal->GetBitsAllocated()==24 ) // For RGB ACR files 
+      if ( FileInternal->GetBitsAllocated()==24 ) // For RGB ACR files 
          vr = "OB";
-      BinEntry *pixel = 
-         CopyBinEntry(GetFile()->GetGrPixel(),GetFile()->GetNumPixel(),vr);
-      pixel->SetValue(GDCM_BINLOADED);
+      DataEntry *pixel = 
+         CopyDataEntry(GetFile()->GetGrPixel(),GetFile()->GetNumPixel(),vr);
+      pixel->SetFlag(DataEntry::FLAG_PIXELDATA);
       pixel->SetBinArea(PixelWriteConverter->GetData(),false);
       pixel->SetLength(PixelWriteConverter->GetDataSize());
 
@@ -758,19 +924,22 @@ void FileHelper::SetWriteToRGB()
       Archive->Push(0x0028,0x1202);
       Archive->Push(0x0028,0x1203);
 
+      // push out Palette Color Lookup Table UID, if any
+      Archive->Push(0x0028,0x1199);
+
       // For old '24 Bits' ACR-NEMA
       // Thus, we have a RGB image and the bits allocated = 24 and 
       // samples per pixels = 1 (in the read file)
-      if(FileInternal->GetBitsAllocated()==24) 
+      if ( FileInternal->GetBitsAllocated()==24 ) 
       {
-         ValEntry *bitsAlloc = CopyValEntry(0x0028,0x0100);
-         bitsAlloc->SetValue("8 ");
+         DataEntry *bitsAlloc = CopyDataEntry(0x0028,0x0100);
+         bitsAlloc->SetString("8 ");
 
-         ValEntry *bitsStored = CopyValEntry(0x0028,0x0101);
-         bitsStored->SetValue("8 ");
+         DataEntry *bitsStored = CopyDataEntry(0x0028,0x0101);
+         bitsStored->SetString("8 ");
 
-         ValEntry *highBit = CopyValEntry(0x0028,0x0102);
-         highBit->SetValue("7 ");
+         DataEntry *highBit = CopyDataEntry(0x0028,0x0102);
+         highBit->SetString("7 ");
 
          Archive->Push(bitsAlloc);
          Archive->Push(bitsStored);
@@ -806,6 +975,10 @@ void FileHelper::RestoreWrite()
    Archive->Restore(0x0028,0x1202);
    Archive->Restore(0x0028,0x1203);
 
+   // For the Palette Color Lookup Table UID
+   Archive->Restore(0x0028,0x1203); 
+
+
    // group 0002 may be pushed out for ACR-NEMA writting purposes 
    Archive->Restore(0x0002,0x0000);
    Archive->Restore(0x0002,0x0001);
@@ -832,7 +1005,7 @@ void FileHelper::SetWriteFileTypeToACR()
    Archive->Push(0x0002,0x0001);
    Archive->Push(0x0002,0x0002);
    Archive->Push(0x0002,0x0003);
-   Archive->Push(0x0002,0x0010);// Only TransferSyntax was pushed out !
+   Archive->Push(0x0002,0x0010);
    Archive->Push(0x0002,0x0012);
    Archive->Push(0x0002,0x0013);
    Archive->Push(0x0002,0x0016);
@@ -843,13 +1016,24 @@ void FileHelper::SetWriteFileTypeToACR()
 /**
  * \brief Sets in the File the TransferSyntax to 'Explicit VR Little Endian"   
  */ 
+void FileHelper::SetWriteFileTypeToJPEG()
+{
+   std::string ts = Util::DicomString( 
+      Global::GetTS()->GetSpecialTransferSyntax(TS::JPEGBaselineProcess1) );
+
+   DataEntry *tss = CopyDataEntry(0x0002,0x0010);
+   tss->SetString(ts);
+
+   Archive->Push(tss);
+}
+
 void FileHelper::SetWriteFileTypeToExplicitVR()
 {
    std::string ts = Util::DicomString( 
       Global::GetTS()->GetSpecialTransferSyntax(TS::ExplicitVRLittleEndian) );
 
-   ValEntry *tss = CopyValEntry(0x0002,0x0010);
-   tss->SetValue(ts);
+   DataEntry *tss = CopyDataEntry(0x0002,0x0010);
+   tss->SetString(ts);
 
    Archive->Push(tss);
 }
@@ -862,8 +1046,8 @@ void FileHelper::SetWriteFileTypeToImplicitVR()
    std::string ts = Util::DicomString(
       Global::GetTS()->GetSpecialTransferSyntax(TS::ImplicitVRLittleEndian) );
 
-   ValEntry *tss = CopyValEntry(0x0002,0x0010);
-   tss->SetValue(ts);
+   DataEntry *tss = CopyDataEntry(0x0002,0x0010);
+   tss->SetString(ts);
 
    Archive->Push(tss);
 }
@@ -874,17 +1058,6 @@ void FileHelper::SetWriteFileTypeToImplicitVR()
  */ 
 void FileHelper::RestoreWriteFileType()
 {
-   // group 0002 may be pushed out for ACR-NEMA writting purposes 
-   Archive->Restore(0x0002,0x0000);
-   Archive->Restore(0x0002,0x0001);
-   Archive->Restore(0x0002,0x0002);
-   Archive->Restore(0x0002,0x0003);
-   Archive->Restore(0x0002,0x0010);//only TransferSyntax was pushed out/restored
-   Archive->Restore(0x0002,0x0012);
-   Archive->Restore(0x0002,0x0013);
-   Archive->Restore(0x0002,0x0016);
-   Archive->Restore(0x0002,0x0100);
-   Archive->Restore(0x0002,0x0102);
 }
 
 /**
@@ -892,30 +1065,28 @@ void FileHelper::RestoreWriteFileType()
  */ 
 void FileHelper::SetWriteToLibido()
 {
-   ValEntry *oldRow = dynamic_cast<ValEntry *>
-                (FileInternal->GetDocEntry(0x0028, 0x0010));
-   ValEntry *oldCol = dynamic_cast<ValEntry *>
-                (FileInternal->GetDocEntry(0x0028, 0x0011));
+   DataEntry *oldRow = FileInternal->GetDataEntry(0x0028, 0x0010);
+   DataEntry *oldCol = FileInternal->GetDataEntry(0x0028, 0x0011);
    
-   if( oldRow && oldCol )
+   if ( oldRow && oldCol )
    {
       std::string rows, columns; 
 
-      ValEntry *newRow=new ValEntry(oldRow->GetDictEntry());
-      ValEntry *newCol=new ValEntry(oldCol->GetDictEntry());
+      DataEntry *newRow=new DataEntry(oldRow->GetDictEntry());
+      DataEntry *newCol=new DataEntry(oldCol->GetDictEntry());
 
       newRow->Copy(oldCol);
       newCol->Copy(oldRow);
 
-      newRow->SetValue(oldCol->GetValue());
-      newCol->SetValue(oldRow->GetValue());
+      newRow->SetString(oldCol->GetString());
+      newCol->SetString(oldRow->GetString());
 
       Archive->Push(newRow);
       Archive->Push(newCol);
    }
 
-   ValEntry *libidoCode = CopyValEntry(0x0008,0x0010);
-   libidoCode->SetValue("ACRNEMA_LIBIDO_1.1");
+   DataEntry *libidoCode = CopyDataEntry(0x0008,0x0010);
+   libidoCode->SetString("ACRNEMA_LIBIDO_1.1");
    Archive->Push(libidoCode);
 }
 
@@ -924,14 +1095,13 @@ void FileHelper::SetWriteToLibido()
  */ 
 void FileHelper::SetWriteToNoLibido()
 {
-   ValEntry *recCode = dynamic_cast<ValEntry *>
-                (FileInternal->GetDocEntry(0x0008,0x0010));
-   if( recCode )
+   DataEntry *recCode = FileInternal->GetDataEntry(0x0008,0x0010);
+   if ( recCode )
    {
-      if( recCode->GetValue() == "ACRNEMA_LIBIDO_1.1" )
+      if ( recCode->GetString() == "ACRNEMA_LIBIDO_1.1" )
       {
-         ValEntry *libidoCode = CopyValEntry(0x0008,0x0010);
-         libidoCode->SetValue("");
+         DataEntry *libidoCode = CopyDataEntry(0x0008,0x0010);
+         libidoCode->SetString("");
          Archive->Push(libidoCode);
       }
    }
@@ -945,75 +1115,80 @@ void FileHelper::RestoreWriteOfLibido()
    Archive->Restore(0x0028,0x0010);
    Archive->Restore(0x0028,0x0011);
    Archive->Restore(0x0008,0x0010);
-}
 
-/**
- * \brief Duplicates a ValEntry or creates it.
- * @param   group   Group number of the Entry 
- * @param   elem  Element number of the Entry
- * \return  pointer to the new Val Entry (NULL when creation
- *          failed).
- */ 
-ValEntry *FileHelper::CopyValEntry(uint16_t group, uint16_t elem)
-{
-   DocEntry *oldE = FileInternal->GetDocEntry(group, elem);
-   ValEntry *newE;
-
-   if( oldE )
-   {
-      newE = new ValEntry(oldE->GetDictEntry());
-      newE->Copy(oldE);
-   }
-   else
-   {
-      newE = GetFile()->NewValEntry(group, elem);
-   }
-
-   return newE;
+   // Restore 'LibIDO-special' entries, if any
+   Archive->Restore(0x0028,0x0015);
+   Archive->Restore(0x0028,0x0016);
+   Archive->Restore(0x0028,0x0017);
+   Archive->Restore(0x0028,0x00199);
 }
 
 /**
- * \brief   Duplicates a BinEntry or creates it.
+ * \brief   Duplicates a DataEntry or creates it.
  * @param   group   Group number of the Entry 
  * @param   elem  Element number of the Entry
  * @param   vr  Value Representation of the Entry
  *          FIXME : what is it used for?
- * \return  pointer to the new Bin Entry (NULL when creation
- *          failed).
+ * \return  pointer to the new Bin Entry (NULL when creation failed).
  */ 
-BinEntry *FileHelper::CopyBinEntry(uint16_t group, uint16_t elem,
-                                   const std::string &vr)
+DataEntry *FileHelper::CopyDataEntry(uint16_t group, uint16_t elem,
+                                   const TagName &vr)
 {
    DocEntry *oldE = FileInternal->GetDocEntry(group, elem);
-   BinEntry *newE;
+   DataEntry *newE;
 
-   if( oldE )
-      if( oldE->GetVR()!=vr )
+   if ( oldE && vr != GDCM_VRUNKNOWN ) 
+      if ( oldE->GetVR() != vr )
          oldE = NULL;
 
-   if( oldE )
+   if ( oldE )
    {
-      newE = new BinEntry(oldE->GetDictEntry());
+      newE = new DataEntry(oldE->GetDictEntry());
       newE->Copy(oldE);
    }
    else
    {
-      newE = GetFile()->NewBinEntry(group, elem, vr);
+      newE = GetFile()->NewDataEntry(group, elem, vr);
    }
 
    return newE;
 }
 
 /**
- * \brief   Checks the MetaElements Group (0002).
- *          adds the mandatory Entries if not found
- *          (when user asks to write as a DICOM file, an ACR-NEMA file
- *           he read before)
+ * \brief   This method is called automatically, just before writting
+ *         in order to produce a 'True Dicom V3' image
+ *         We cannot know *how* the user made the File (reading an old ACR-NEMA
+ *         file or a not very clean DICOM file ...) 
+ *          
+ *          Just before writting :
+ *             - we check the Entries
+ *             - we create the mandatory entries if they are missing
+ *             - we modify the values if necessary
+ *             - we push the sensitive entries to the Archive
+ *          The writing process will restore the entries as they where before 
+ *          entering FileHelper::CheckMandatoryElements, so the user will always
+ *          see the entries just as he left them.
+ * 
+ * \todo : - warn the user if we had to add some entries :
+ *         even if a mandatory entry is missing, we add it, with a default value
+ *         (we don't want to give up the writting process if user forgot to
+ *         specify Lena's Patient ID, for instance ...)
+ *         - read the whole PS 3.3 Part of DICOM  (890 pages)
+ *         and write a *full* checker (probably one method per Modality ...)
+ *         Any contribution is welcome. 
+ *         - write a user callable full checker, to allow post reading
+ *         and/or pre writting image consistency check.           
  */ 
-void FileHelper::CheckMetaElements()
+ 
+void FileHelper::CheckMandatoryElements()
 {
+   std::string sop =  Util::CreateUniqueUID();
+   
    // just to remember : 'official' 0002 group
-
+   if ( WriteType != ACR && WriteType != ACR_LIBIDO )
+   {
+     // Group 000002 (Meta Elements) already pushed out
+  
    //0002 0000 UL 1 Meta Group Length
    //0002 0001 OB 1 File Meta Information Version
    //0002 0002 UI 1 Media Stored SOP Class UID
@@ -1024,46 +1199,265 @@ void FileHelper::CheckMetaElements()
    //0002 0016 AE 1 Source Application Entity Title
    //0002 0100 UI 1 Private Information Creator
    //0002 0102 OB 1 Private Information
-
-   std::string uid  = Util::CreateUniqueUID();
-   std::string uidMedia = uid;
-
+  
    // Create them if not found
-   ValEntry *e0000 = CopyValEntry(0x0002,0x0000);
-       e0000->SetValue("0"); // for the moment
-       Archive->Push(e0000);
+   // Always modify the value
+   // Push the entries to the archive.
+      CopyMandatoryEntry(0x0002,0x0000,"0");
   
-   BinEntry *e0001 = CopyBinEntry(0x0002,0x0001, "OB");
-      e0001->SetBinArea((uint8_t*)Util::GetFileMetaInformationVersion(), false);
-      e0001->SetLength(2);
+      DataEntry *e_0002_0001 = CopyDataEntry(0x0002,0x0001, "OB");
+      e_0002_0001->SetBinArea((uint8_t*)Util::GetFileMetaInformationVersion(),
+                               false);
+      e_0002_0001->SetLength(2);
+      Archive->Push(e_0002_0001);
+
+   // Potentialy post-processed image --> [Secondary Capture Image Storage]
+   // 'Media Storage SOP Class UID' 
+      CopyMandatoryEntry(0x0002,0x0002,"1.2.840.10008.5.1.4.1.1.7");    
+ 
+   // 'Media Storage SOP Instance UID'   
+      CopyMandatoryEntry(0x0002,0x0003,sop);
+      
+   // 'Implementation Class UID'
+      CopyMandatoryEntry(0x0002,0x0012,Util::CreateUniqueUID());
+
+   // 'Implementation Version Name'
+      std::string version = "GDCM ";
+      version += Util::GetVersion();
+      CopyMandatoryEntry(0x0002,0x0013,version);
+   }
+
+   // Push out 'LibIDO-special' entries, if any
+   Archive->Push(0x0028,0x0015);
+   Archive->Push(0x0028,0x0016);
+   Archive->Push(0x0028,0x0017);
+   Archive->Push(0x0028,0x00199);
+
+   // Deal with the pb of (Bits Stored = 12)
+   // - we're gonna write the image as Bits Stored = 16
+   if ( FileInternal->GetEntryString(0x0028,0x0100) ==  "12")
+   {
+      CopyMandatoryEntry(0x0028,0x0100,"16");
+   }
+
+   // Check if user wasn't drunk ;-)
 
-   ValEntry *e0002 = CopyValEntry(0x0002,0x0002);
+   std::ostringstream s;
+   // check 'Bits Allocated' vs decent values
+   int nbBitsAllocated = FileInternal->GetBitsAllocated();
+   if ( nbBitsAllocated == 0 || nbBitsAllocated > 32)
+   {
+      CopyMandatoryEntry(0x0028,0x0100,"16");
+      gdcmWarningMacro("(0028,0100) changed from "
+         << nbBitsAllocated << " to 16 for consistency purpose");
+      nbBitsAllocated = 16; 
+   }
+   // check 'Bits Stored' vs 'Bits Allocated'   
+   int nbBitsStored = FileInternal->GetBitsStored();
+   if ( nbBitsStored == 0 || nbBitsStored > nbBitsAllocated )
+   {
+      s.str("");
+      s << nbBitsAllocated;
+      CopyMandatoryEntry(0x0028,0x0101,s.str());
+      gdcmWarningMacro("(0028,0101) changed from "
+                       << nbBitsStored << " to " << nbBitsAllocated
+                       << " for consistency purpose" );
+      nbBitsStored = nbBitsAllocated; 
+    }
+   // check 'Hight Bit Position' vs 'Bits Allocated' and 'Bits Stored'
+   int highBitPosition = FileInternal->GetHighBitPosition();
+   if ( highBitPosition == 0 || 
+        highBitPosition > nbBitsAllocated-1 ||
+        highBitPosition < nbBitsStored-1  )
+   {
+      s.str("");
+      s << nbBitsStored - 1; 
+      CopyMandatoryEntry(0x0028,0x0102,s.str());
+      gdcmWarningMacro("(0028,0102) changed from "
+                       << highBitPosition << " to " << nbBitsAllocated-1
+                       << " for consistency purpose");
+   }
+  // --- Check UID-related Entries ---
+
+   // If 'SOP Class UID' exists ('true DICOM' image)
+   // we create the 'Source Image Sequence' SeqEntry
+   // to hold informations about the Source Image
+
+   DataEntry *e_0008_0016 = FileInternal->GetDataEntry(0x0008, 0x0016);
+   if ( e_0008_0016 )
+   {
+      // Create 'Source Image Sequence' SeqEntry
+      SeqEntry *sis = new SeqEntry (
+            Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x2112) );
+      SQItem *sqi = new SQItem(1);
+      // (we assume 'SOP Instance UID' exists too) 
+      // create 'Referenced SOP Class UID'
+      DataEntry *e_0008_1150 = new DataEntry(
+            Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x1150) );
+      e_0008_1150->SetString( e_0008_0016->GetString());
+      sqi->AddEntry(e_0008_1150);
+      
+      // create 'Referenced SOP Instance UID'
+      DataEntry *e_0008_0018 = FileInternal->GetDataEntry(0x0008, 0x0018);
+      DataEntry *e_0008_1155 = new DataEntry(
+            Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x1155) );
+      e_0008_1155->SetString( e_0008_0018->GetString());
+      sqi->AddEntry(e_0008_1155);
+
+      sis->AddSQItem(sqi,1); 
+      // temporarily replaces any previous 'Source Image Sequence' 
+      Archive->Push(sis);
+ 
+      // 'Image Type' (The written image is no longer an 'ORIGINAL' one)
+      CopyMandatoryEntry(0x0008,0x0008,"DERIVED\\PRIMARY");
+   } 
+   else
+   {
+      // There was no 'SOP Class UID'.
+      // the source image was NOT a true Dicom one.
+      // We consider the image is a 'Secondary Capture' one
+      // SOP Class UID
       // [Secondary Capture Image Storage]
-      e0002->SetValue("1.2.840.10008.5.1.4.1.1.7"); 
-      Archive->Push(e0002); 
+      SetMandatoryEntry(0x0008,0x0016,"1.2.840.10008.5.1.4.1.1.7");
+   }
+
+   // At the end, not to overwrite the original ones,
+   // needed by 'Referenced SOP Instance UID', 'Referenced SOP Class UID'   
+   // 'SOP Instance UID'  
+   CopyMandatoryEntry(0x0008,0x0018,sop);
+   // 'SOP Class UID' 
+   CopyMandatoryEntry(0x0008,0x0016,"1.2.840.10008.5.1.4.1.1.7"); 
+             
+// ---- The user will never have to take any action on the following ----.
+   // new value for 'SOP Instance UID'
+   //SetMandatoryEntry(0x0008,0x0018,Util::CreateUniqueUID());
+
+   // Instance Creation Date
+   CopyMandatoryEntry(0x0008,0x0012,Util::GetCurrentDate().c_str());
+ 
+   // Instance Creation Time
+   CopyMandatoryEntry(0x0008,0x0013,Util::GetCurrentTime().c_str());
+
+// ----- Add Mandatory Entries if missing ---
+// Entries whose type is 1 are mandatory, with a mandatory value
+// Entries whose type is 1c are mandatory-inside-a-Sequence
+// Entries whose type is 2 are mandatory, with a optional value
+// Entries whose type is 2c are mandatory-inside-a-Sequence
+// Entries whose type is 3 are optional
+
+   // 'Study Instance UID'
+   // Keep the value if exists
+   // The user is allowed to create his own Study, 
+   //          keeping the same 'Study Instance UID' for various images
+   // The user may add images to a 'Manufacturer Study',
+   //          adding new series to an already existing Study 
+   CheckMandatoryEntry(0x0020,0x000d,Util::CreateUniqueUID());
+
+   // 'Serie Instance UID'
+   // Keep the value if exists
+   // The user is allowed to create his own Series, 
+   // keeping the same 'Serie Instance UID' for various images
+   // The user shouldn't add any image to a 'Manufacturer Serie'
+   // but there is no way no to allowed him to do that 
+   CheckMandatoryEntry(0x0020,0x000e,Util::CreateUniqueUID());
    
-   ValEntry *e0003 = CopyValEntry(0x0002,0x0003);
-      e0003->SetValue(uidMedia.c_str());
-      Archive->Push(e0003); 
-
-   ValEntry *e0010 = CopyValEntry(0x0002,0x0010);
-      //Explicit VR - Little Endian 
-      e0010->SetValue("1.2.840.10008.1.2.1"); 
-      Archive->Push(e0010); 
-
-   ValEntry *e0012 = CopyValEntry(0x0002,0x0012);
-      e0012->SetValue("Implementation.Class.UID");
-      Archive->Push(e0012); 
-
-   ValEntry *e0013 = CopyValEntry(0x0002,0x0013);
-      e0013->SetValue("GDCM 1.0");
-      Archive->Push(e0013);
-
-   ValEntry *e0016 = CopyValEntry(0x0002,0x0016);
-      e0016->SetValue("1.2.840.10008.5.1.4.1.1.7");
-      Archive->Push(e0016);
+   // Modality : if missing we set it to 'OTher'
+   CheckMandatoryEntry(0x0008,0x0060,"OT");
+
+   // Manufacturer : if missing we set it to 'GDCM Factory'
+   CheckMandatoryEntry(0x0008,0x0070,"GDCM Factory");
+
+   // Institution Name : if missing we set it to 'GDCM Hospital'
+   CheckMandatoryEntry(0x0008,0x0080,"GDCM Hospital");
+
+   // Patient's Name : if missing, we set it to 'GDCM^Patient'
+   CheckMandatoryEntry(0x0010,0x0010,"GDCM^Patient");
+
+   // Patient's Birth Date : 'type 2' entry -> must exist, value not mandatory
+   CheckMandatoryEntry(0x0010,0x0030,"");
+
+   // Patient's Sex :'type 2' entry -> must exist, value not mandatory
+   CheckMandatoryEntry(0x0010,0x0040,"");
+
+   // Referring Physician's Name :'type 2' entry -> must exist, value not mandatory
+   CheckMandatoryEntry(0x0008,0x0090,"");
+
+    // Pixel Spacing : defaulted to 1.0\1.0
+   CheckMandatoryEntry(0x0028,0x0030,"1.0\\1.0");
+   
+   // Remove some inconstencies (probably some more will be added)
+
+   // if (0028 0008)Number of Frames exists
+   //    Push out (0020 0052),Frame of Reference UID
+   //    (only meaningfull within a Serie)
+   DataEntry *e_0028_0008 = FileInternal->GetDataEntry(0x0028, 0x0008);
+   if ( !e_0028_0008 )
+   {
+      Archive->Push(0x0020, 0X0052);
+   }
 } 
- 
+
+void FileHelper::CheckMandatoryEntry(uint16_t group,uint16_t elem,std::string value)
+{
+   DataEntry *entry = FileInternal->GetDataEntry(group,elem);
+   if ( !entry )
+   {
+      entry = new DataEntry(Global::GetDicts()->GetDefaultPubDict()->GetEntry(group,elem));
+      entry->SetString(value);
+      Archive->Push(entry);
+   }
+}
+
+void FileHelper::SetMandatoryEntry(uint16_t group,uint16_t elem,std::string value)
+{
+   DataEntry *entry = new DataEntry(Global::GetDicts()->GetDefaultPubDict()->GetEntry(group,elem));
+   entry->SetString(value);
+   Archive->Push(entry);
+}
+
+void FileHelper::CopyMandatoryEntry(uint16_t group,uint16_t elem,std::string value)
+{
+   DataEntry *entry = CopyDataEntry(group,elem);
+   entry->SetString(value);
+   Archive->Push(entry);
+}
+
+/**
+ * \brief Restore in the File the initial group 0002
+ */
+void FileHelper::RestoreWriteMandatory()
+{
+   // group 0002 may be pushed out for ACR-NEMA writting purposes 
+   Archive->Restore(0x0002,0x0000);
+   Archive->Restore(0x0002,0x0001);
+   Archive->Restore(0x0002,0x0002);
+   Archive->Restore(0x0002,0x0003);
+   Archive->Restore(0x0002,0x0010);
+   Archive->Restore(0x0002,0x0012);
+   Archive->Restore(0x0002,0x0013);
+   Archive->Restore(0x0002,0x0016);
+   Archive->Restore(0x0002,0x0100);
+   Archive->Restore(0x0002,0x0102);
+
+   Archive->Restore(0x0008,0x0012);
+   Archive->Restore(0x0008,0x0013);
+   Archive->Restore(0x0008,0x0016);
+   Archive->Restore(0x0008,0x0018);
+   Archive->Restore(0x0008,0x0060);
+   Archive->Restore(0x0008,0x0070);
+   Archive->Restore(0x0008,0x0080);
+   Archive->Restore(0x0008,0x0090);
+   Archive->Restore(0x0008,0x2112);
+
+   Archive->Restore(0x0010,0x0010);
+   Archive->Restore(0x0010,0x0030);
+   Archive->Restore(0x0010,0x0040);
+
+   Archive->Restore(0x0020,0x000d);
+   Archive->Restore(0x0020,0x000e);
+
+}
+
 //-----------------------------------------------------------------------------
 // Private
 /**
@@ -1071,31 +1465,33 @@ void FileHelper::CheckMetaElements()
  */
 void FileHelper::Initialize()
 {
+   UserFunction = 0;
+
    WriteMode = WMODE_RAW;
    WriteType = ExplicitVR;
 
-   PixelReadConverter = new PixelReadConvert;
+   PixelReadConverter  = new PixelReadConvert;
    PixelWriteConverter = new PixelWriteConvert;
    Archive = new DocEntryArchive( FileInternal );
-
-   if ( FileInternal->IsReadable() )
-   {
-      PixelReadConverter->GrabInformationsFromFile( FileInternal );
-   }
 }
 
 /**
- * \brief   
+ * \brief Reads/[decompresses] the pixels, 
+ *        *without* making RGB from Palette Colors 
+ * @return the pixels area, whatever its type 
+ *         (uint8_t is just for prototyping : feel free to Cast it) 
  */ 
 uint8_t *FileHelper::GetRaw()
 {
+   PixelReadConverter->SetUserFunction( UserFunction );
+
    uint8_t *raw = PixelReadConverter->GetRaw();
    if ( ! raw )
    {
       // The Raw image migth not be loaded yet:
       std::ifstream *fp = FileInternal->OpenFile();
       PixelReadConverter->ReadAndDecompressPixelData( fp );
-      if(fp) 
+      if ( fp ) 
          FileInternal->CloseFile();
 
       raw = PixelReadConverter->GetRaw();
@@ -1105,19 +1501,25 @@ uint8_t *FileHelper::GetRaw()
          return 0;
       }
    }
-
    return raw;
 }
 
 //-----------------------------------------------------------------------------
-// Print
+/**
+ * \brief   Prints the common part of DataEntry, SeqEntry
+ * @param   os ostream we want to print in
+ * @param indent (unused)
+ */
 void FileHelper::Print(std::ostream &os, std::string const &)
 {
    FileInternal->SetPrintLevel(PrintLevel);
    FileInternal->Print(os);
 
-   PixelReadConverter->SetPrintLevel(PrintLevel);
-   PixelReadConverter->Print(os);
+   if ( FileInternal->IsReadable() )
+   {
+      PixelReadConverter->SetPrintLevel(PrintLevel);
+      PixelReadConverter->Print(os);
+   }
 }
 
 //-----------------------------------------------------------------------------