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

diff --git a/src/gdcmFileHelper.cxx b/src/gdcmFileHelper.cxx
index 583a6192..3357faa8 100644
--- a/src/gdcmFileHelper.cxx
+++ b/src/gdcmFileHelper.cxx
@@ -4,8 +4,8 @@
   Module:    $RCSfile: gdcmFileHelper.cxx,v $
   Language:  C++
 
-  Date:      $Date: 2005/04/19 12:31:56 $
-  Version:   $Revision: 1.34 $
+  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
@@ -23,11 +23,9 @@
 #include "gdcmDocument.h"
 #include "gdcmDebug.h"
 #include "gdcmUtil.h"
-#include "gdcmBinEntry.h"
-#include "gdcmValEntry.h"
 #include "gdcmSeqEntry.h"
 #include "gdcmSQItem.h"
-#include "gdcmContentEntry.h"
+#include "gdcmDataEntry.h"
 #include "gdcmFile.h"
 #include "gdcmPixelReadConvert.h"
 #include "gdcmPixelWriteConvert.h"
@@ -42,32 +40,43 @@
 These lines will be moved to the document-to-be 'User's Guide'
 
 // To read an image, user needs a gdcm::File
-gdcm::File *f1 = new gdcm::File(fileName);
+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 = f1->GetEntryValue(groupNb,ElementNb);
+std::string v = f->GetEntryValue(groupNb,ElementNb);
+
 // to get the pixels, user needs a gdcm::FileHelper
-gdcm::FileHelper *fh1 = new gdcm::FileHelper(f1);
+gdcm::FileHelper *fh = new gdcm::FileHelper(f);
 // user may ask not to convert Palette to RGB
-uint8_t *pixels = fh1->GetImageDataRaw();
-int imageLength = fh1->GetImageDataRawSize();
+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
 
-fh1->SetImageData( userPixels, userPixelsLength);
-fh1->SetTypeToRaw(); // Even if it was possible to convert Palette to RGB
+fh->SetImageData( userPixels, userPixelsLength);
+fh->SetTypeToRaw(); // Even if it was possible to convert Palette to RGB
                      // (WriteMode is set)
  
-fh1->SetWriteTypeToDcmExpl(); // he wants Explicit Value Representation
+fh->SetWriteTypeToDcmExpl(); // he wants Explicit Value Representation
                               // Little Endian is the default
                               // no other value is allowed
                                 (-->SetWriteType(ExplicitVR);)
                                    -->WriteType = ExplicitVR;
-fh1->Write(newFileName);      // overwrites the file, if any
+fh->Write(newFileName);      // overwrites the file, if any
 
 // or :
-fh1->WriteDcmExplVR(newFileName);
+fh->WriteDcmExplVR(newFileName);
 
 
 // ----------------------------- WARNING -------------------------
@@ -89,7 +98,7 @@ fh1->Write(newFileName);
       (checks user given pixels length)
    FileInternal->Write(fileName,WriteType)
    fp = opens file(fileName);
-   ComputeGroup0002Length(writetype);
+   ComputeGroup0002Length( );
    BitsAllocated 12->16
       RemoveEntryNoDestroy(palettes, etc)
       Document::WriteContent(fp, writetype);
@@ -112,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
@@ -119,7 +129,7 @@ namespace gdcm
  *        seen as a side effect).   
  */
 FileHelper::FileHelper( )
-{
+{ 
    FileInternal = new File( );
    SelfHeader = true;
    Initialize();
@@ -131,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
@@ -143,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.
@@ -157,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
@@ -172,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;
    }
@@ -194,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
@@ -203,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);
 }
 
 
@@ -220,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);
 }
 
 /**
@@ -235,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);
 }
 
 /**
@@ -252,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);
 }
 
 /**
@@ -285,7 +347,6 @@ size_t FileHelper::GetImageDataSize()
    {
       return PixelWriteConverter->GetUserDataSize();
    }
-
    return PixelReadConverter->GetRGBSize();
 }
 
@@ -302,7 +363,6 @@ size_t FileHelper::GetImageDataRawSize()
    {
       return PixelWriteConverter->GetUserDataSize();
    }
-
    return PixelReadConverter->GetRawSize();
 }
 
@@ -354,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   
@@ -407,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
@@ -502,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".
@@ -522,19 +603,19 @@ bool FileHelper::WriteRawData(std::string const &fileName)
       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
@@ -550,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
@@ -609,28 +690,30 @@ bool FileHelper::Write(std::string const &fileName)
    {
       case ImplicitVR:
          SetWriteFileTypeToImplicitVR();
-         CheckMandatoryElements();
          break;
       case Unknown:  // should never happen; ExplicitVR is the default value
       case ExplicitVR:
          SetWriteFileTypeToExplicitVR();
-         CheckMandatoryElements();
          break;
       case ACR:
       case ACR_LIBIDO:
-      // Just to avoid further trouble if user create a file ex-nihilo,
+      // 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 forget to create any Entry belonging to group 0008
+      // and forgets to create any Entry belonging to group 0008
       // (shame on him !)
       // We add Recognition Code (RET)
-        if ( ! FileInternal->GetValEntry(0x0008, 0x0010) )
-            FileInternal->InsertValEntry("", 0x0008, 0x0010);
+        if ( ! FileInternal->GetDataEntry(0x0008, 0x0010) )
+            FileInternal->InsertEntryString("ACR-NEMA V1.0 ", 0x0008, 0x0010);
          SetWriteFileTypeToACR();
-         SetWriteFileTypeToImplicitVR();
-         CheckMandatoryElements();
+        // SetWriteFileTypeToImplicitVR(); // ACR IS implicit VR !
+         break;
+      case JPEG:
+         SetWriteFileTypeToJPEG();
+         std::cerr << "Writting as JPEG" << std::endl;
          break;
-
    }
+   CheckMandatoryElements();
 
    // --------------------------------------------------------------
    // Special Patch to allow gdcm to re-write ACR-LibIDO formated images
@@ -641,7 +724,7 @@ bool FileHelper::Write(std::string const &fileName)
    /// \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();
    }
@@ -662,7 +745,8 @@ 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);
    }
@@ -694,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 :" 
@@ -723,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 " 
@@ -733,7 +820,7 @@ bool FileHelper::CheckWriteIntegrity()
             break;
       }
    }
-   
+
    return true;
 }
 
@@ -744,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());
 
@@ -789,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());
@@ -814,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());
 
@@ -837,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);
@@ -885,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);
@@ -922,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);
 }
@@ -941,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);
 }
@@ -960,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);
 }
 
@@ -992,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);
       }
    }
@@ -1022,55 +1124,31 @@ void FileHelper::RestoreWriteOfLibido()
 }
 
 /**
- * \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;
-}
-
-/**
- * \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).
  */ 
-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;
@@ -1104,8 +1182,13 @@ BinEntry *FileHelper::CopyBinEntry(uint16_t group, uint16_t elem,
  
 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
@@ -1120,41 +1203,29 @@ void FileHelper::CheckMandatoryElements()
    // Create them if not found
    // Always modify the value
    // Push the entries to the archive.
-   ValEntry *e_0002_0000 = CopyValEntry(0x0002,0x0000);
-      e_0002_0000->SetValue("0"); // for the moment
-      Archive->Push(e_0002_0000);
+      CopyMandatoryEntry(0x0002,0x0000,"0");
   
-   BinEntry *e_0002_0001 = CopyBinEntry(0x0002,0x0001, "OB");
+      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);
 
-   // 'Media Stored SOP Class UID' 
-   ValEntry *e_0002_0002 = CopyValEntry(0x0002,0x0002);
-      // [Secondary Capture Image Storage]
-      e_0002_0002->SetValue("1.2.840.10008.5.1.4.1.1.7"); 
-      Archive->Push(e_0002_0002);
+   // 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 Stored SOP Instance UID'   
-   ValEntry *e_0002_0003 = CopyValEntry(0x0002,0x0003);
-      e_0002_0003->SetValue(Util::CreateUniqueUID());
-      Archive->Push(e_0002_0003); 
-
+   // 'Media Storage SOP Instance UID'   
+      CopyMandatoryEntry(0x0002,0x0003,sop);
+      
    // 'Implementation Class UID'
-   ValEntry *e_0002_0012 = CopyValEntry(0x0002,0x0012);
-      e_0002_0012->SetValue(Util::CreateUniqueUID());
-      Archive->Push(e_0002_0012); 
+      CopyMandatoryEntry(0x0002,0x0012,Util::CreateUniqueUID());
 
    // 'Implementation Version Name'
-   ValEntry *e_0002_0013 = CopyValEntry(0x0002,0x0013);
-      e_0002_0013->SetValue("GDCM 1.0");
-      Archive->Push(e_0002_0013);
-
-   //'Source Application Entity Title' Not Mandatory
-   //ValEntry *e_0002_0016 = CopyValEntry(0x0002,0x0016);
-   //   e_0002_0016->SetValue("1.2.840.10008.5.1.4.1.1.7");
-   //   Archive->Push(e_0002_0016);
+      std::string version = "GDCM ";
+      version += Util::GetVersion();
+      CopyMandatoryEntry(0x0002,0x0013,version);
+   }
 
    // Push out 'LibIDO-special' entries, if any
    Archive->Push(0x0028,0x0015);
@@ -1162,41 +1233,83 @@ void FileHelper::CheckMandatoryElements()
    Archive->Push(0x0028,0x0017);
    Archive->Push(0x0028,0x00199);
 
-   // --- Check UID-related Entries ---
+   // 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 ;-)
+
+   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
 
-   ValEntry *e_0008_0016 = FileInternal->GetValEntry(0x0008, 0x0016);
-   if ( e_0008_0016 != 0 )
+   DataEntry *e_0008_0016 = FileInternal->GetDataEntry(0x0008, 0x0016);
+   if ( e_0008_0016 )
    {
       // Create 'Source Image Sequence' SeqEntry
-      SeqEntry *s = new 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'
-      ValEntry *e_0008_1150 = new ValEntry(
+      DataEntry *e_0008_1150 = new DataEntry(
             Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x1150) );
-      e_0008_1150->SetValue( e_0008_0016->GetValue());
+      e_0008_1150->SetString( e_0008_0016->GetString());
       sqi->AddEntry(e_0008_1150);
       
       // create 'Referenced SOP Instance UID'
-      ValEntry *e_0008_0018 = FileInternal->GetValEntry(0x0008, 0x0018);
-      ValEntry *e_0008_1155 = new ValEntry(
+      DataEntry *e_0008_0018 = FileInternal->GetDataEntry(0x0008, 0x0018);
+      DataEntry *e_0008_1155 = new DataEntry(
             Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x1155) );
-      e_0008_1155->SetValue( e_0008_0018->GetValue());
+      e_0008_1155->SetString( e_0008_0018->GetString());
       sqi->AddEntry(e_0008_1155);
 
-      s->AddSQItem(sqi,1); 
+      sis->AddSQItem(sqi,1); 
       // temporarily replaces any previous 'Source Image Sequence' 
-      Archive->Push(s);
+      Archive->Push(sis);
  
       // 'Image Type' (The written image is no longer an 'ORIGINAL' one)
-      ValEntry *e_0008_0008 = CopyValEntry(0x0008,0x0008);
-      e_0008_0008->SetValue("DERIVED\\PRIMARY");
-      Archive->Push(e_0008_0008);
+      CopyMandatoryEntry(0x0008,0x0008,"DERIVED\\PRIMARY");
    } 
    else
    {
@@ -1204,153 +1317,111 @@ void FileHelper::CheckMandatoryElements()
       // the source image was NOT a true Dicom one.
       // We consider the image is a 'Secondary Capture' one
       // SOP Class UID
-      e_0008_0016  =  new ValEntry( 
-            Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0016) );
       // [Secondary Capture Image Storage]
-      e_0008_0016 ->SetValue("1.2.840.10008.5.1.4.1.1.7"); 
-      Archive->Push(e_0008_0016); 
+      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'
-   ValEntry *e_0008_0018 = new ValEntry(
-         Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0018) );
-   e_0008_0018->SetValue( Util::CreateUniqueUID() );
-   Archive->Push(e_0008_0018);
+   //SetMandatoryEntry(0x0008,0x0018,Util::CreateUniqueUID());
 
    // Instance Creation Date
-   ValEntry *e_0008_0012 = CopyValEntry(0x0008,0x0012);
-   std::string date = Util::GetCurrentDate();
-   e_0008_0012->SetValue(date.c_str());
-   Archive->Push(e_0008_0012);
+   CopyMandatoryEntry(0x0008,0x0012,Util::GetCurrentDate().c_str());
  
    // Instance Creation Time
-   ValEntry *e_0008_0013 = CopyValEntry(0x0008,0x0013);
-   std::string time = Util::GetCurrentTime();
-   e_0008_0013->SetValue(time.c_str());
-   Archive->Push(e_0008_0013);
+   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
 
-   // '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 
-   ValEntry *e_0020_000e = FileInternal->GetValEntry(0x0020, 0x000e);
-   if ( !e_0020_000e )
-   {
-      e_0020_000e = new ValEntry(
-           Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0020, 0x000e) );
-      e_0020_000e->SetValue(Util::CreateUniqueUID() );
-      Archive->Push(e_0020_000e);
-   } 
-
    // '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 
-   ValEntry *e_0020_000d = FileInternal->GetValEntry(0x0020, 0x000d);
-   if ( !e_0020_000d )
-   {
-      e_0020_000d = new ValEntry(
-            Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0020, 0x000d) );
-      e_0020_000d->SetValue(Util::CreateUniqueUID() );
-      Archive->Push(e_0020_000d);
-   }
+   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());
+   
    // Modality : if missing we set it to 'OTher'
-   ValEntry *e_0008_0060 = FileInternal->GetValEntry(0x0008, 0x0060);
-   if ( !e_0008_0060 )
-   {
-      e_0008_0060 = new ValEntry(
-            Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0060) );
-      e_0008_0060->SetValue("OT");
-      Archive->Push(e_0008_0060);
-   } 
+   CheckMandatoryEntry(0x0008,0x0060,"OT");
 
    // Manufacturer : if missing we set it to 'GDCM Factory'
-   ValEntry *e_0008_0070 = FileInternal->GetValEntry(0x0008, 0x0070);
-   if ( !e_0008_0070 )
-   {
-      e_0008_0070 = new ValEntry(
-            Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0070) );
-      e_0008_0070->SetValue("GDCM Factory");
-      Archive->Push(e_0008_0070);
-   } 
+   CheckMandatoryEntry(0x0008,0x0070,"GDCM Factory");
 
    // Institution Name : if missing we set it to 'GDCM Hospital'
-   ValEntry *e_0008_0080 = FileInternal->GetValEntry(0x0008, 0x0080);
-   if ( !e_0008_0080 )
-   {
-      e_0008_0080 = new ValEntry(
-            Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0080) );
-      e_0008_0080->SetValue("GDCM Hospital");
-      Archive->Push(e_0008_0080);
-   } 
+   CheckMandatoryEntry(0x0008,0x0080,"GDCM Hospital");
 
    // Patient's Name : if missing, we set it to 'GDCM^Patient'
-   ValEntry *e_0010_0010 = FileInternal->GetValEntry(0x0010, 0x0010);
-   if ( !e_0010_0010 )
-   {
-      e_0010_0010 = new ValEntry(
-            Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0010, 0x0010) );
-      e_0010_0010->SetValue("GDCM^Patient");
-      Archive->Push(e_0010_0010);
-   } 
+   CheckMandatoryEntry(0x0010,0x0010,"GDCM^Patient");
 
    // Patient's Birth Date : 'type 2' entry -> must exist, value not mandatory
-   ValEntry *e_0010_0030 = FileInternal->GetValEntry(0x0010, 0x0030);
-   if ( !e_0010_0030 )
-   {
-      e_0010_0030 = new ValEntry(
-            Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0010, 0x0030) );
-      e_0010_0030->SetValue("");
-      Archive->Push(e_0010_0030);
-   }
+   CheckMandatoryEntry(0x0010,0x0030,"");
 
    // Patient's Sex :'type 2' entry -> must exist, value not mandatory
-   ValEntry *e_0010_0040 = FileInternal->GetValEntry(0x0010, 0x0040);
-   if ( !e_0010_0040 )
-   {
-      e_0010_0040 = new ValEntry(
-            Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0010, 0x0040) );
-      e_0010_0040->SetValue("");
-      Archive->Push(e_0010_0040);
-   }
+   CheckMandatoryEntry(0x0010,0x0040,"");
 
    // Referring Physician's Name :'type 2' entry -> must exist, value not mandatory
-   ValEntry *e_0008_0090 = FileInternal->GetValEntry(0x0008, 0x0090);
-   if ( !e_0008_0090 )
-   {
-      e_0008_0090 = new ValEntry(
-            Global::GetDicts()->GetDefaultPubDict()->GetEntry(0x0008, 0x0090) );
-      e_0008_0090->SetValue("");
-      Archive->Push(e_0008_0090);
-   }
- 
+   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)
-   ValEntry *e_0028_0008 = FileInternal->GetValEntry(0x0028, 0x0008);
+   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
  */
@@ -1361,11 +1432,30 @@ void FileHelper::RestoreWriteMandatory()
    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);
+
 }
 
 //-----------------------------------------------------------------------------
@@ -1375,17 +1465,14 @@ void FileHelper::RestoreWriteMandatory()
  */
 void FileHelper::Initialize()
 {
+   UserFunction = 0;
+
    WriteMode = WMODE_RAW;
    WriteType = ExplicitVR;
 
    PixelReadConverter  = new PixelReadConvert;
    PixelWriteConverter = new PixelWriteConvert;
    Archive = new DocEntryArchive( FileInternal );
-
-   if ( FileInternal->IsReadable() )
-   {
-      PixelReadConverter->GrabInformationsFromFile( FileInternal );
-   }
 }
 
 /**
@@ -1396,13 +1483,15 @@ void FileHelper::Initialize()
  */ 
 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();
@@ -1412,13 +1501,12 @@ uint8_t *FileHelper::GetRaw()
          return 0;
       }
    }
-
    return raw;
 }
 
 //-----------------------------------------------------------------------------
 /**
- * \brief   Prints the common part of ValEntry, BinEntry, SeqEntry
+ * \brief   Prints the common part of DataEntry, SeqEntry
  * @param   os ostream we want to print in
  * @param indent (unused)
  */
@@ -1427,8 +1515,11 @@ 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);
+   }
 }
 
 //-----------------------------------------------------------------------------