]> Creatis software - gdcm.git/blobdiff - src/gdcmDocument.cxx
* gdcmPython/gdcm.i : bug fix. Now string are correctly converted in python
[gdcm.git] / src / gdcmDocument.cxx
index 1543981db19d37cd41083bd639b75620da689dd6..9c12f0ce8a8aa4f97e5210cd1c9dfec6311580ac 100644 (file)
@@ -3,8 +3,8 @@
   Program:   gdcm
   Module:    $RCSfile: gdcmDocument.cxx,v $
   Language:  C++
-  Date:      $Date: 2005/01/13 12:19:58 $
-  Version:   $Revision: 1.189 $
+  Date:      $Date: 2005/02/07 09:51:03 $
+  Version:   $Revision: 1.225 $
                                                                                 
   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
   l'Image). All rights reserved. See Doc/License.txt or
 #include "gdcmUtil.h"
 #include "gdcmDebug.h"
 #include "gdcmTS.h"
-#include "gdcmException.h"
 #include "gdcmDictSet.h"
-#include "gdcmRLEFramesInfo.h"
-#include "gdcmJPEGFragmentsInfo.h"
 #include "gdcmDocEntrySet.h"
 #include "gdcmSQItem.h"
 
 #include <vector>
 #include <iomanip>
+#include <fstream>
 
 // For nthos:
-#if defined(_MSC_VER) || defined(__BORLANDC__)
+#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__) 
    #include <winsock.h>
-#else
+#endif
+
+#ifdef CMAKE_HAVE_NETINET_IN_H
    #include <netinet/in.h>
 #endif
 
 namespace gdcm 
 {
-
 //-----------------------------------------------------------------------------
 // Refer to Document::CheckSwap()
 //const unsigned int Document::HEADER_LENGTH_TO_READ = 256;
@@ -54,16 +53,17 @@ const unsigned int Document::MAX_SIZE_PRINT_ELEMENT_VALUE = 0x7fffffff;
 
 //-----------------------------------------------------------------------------
 // Constructor / Destructor
-
+// Constructors and destructors are protected to avoid user to invoke directly
 /**
  * \brief   constructor  
- * @param   filename file to be opened for parsing
+ * @param   filename 'Document' (File or DicomDir) to be opened for parsing
  */
-Document::Document( std::string const &filename ) : ElementSet(-1)
+Document::Document( std::string const &filename ) 
+         :ElementSet(-1)
 {
    SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE); 
    Filename = filename;
-   Initialise();
+   Initialize();
 
    Fp = 0;
    if ( !OpenFile() )
@@ -73,13 +73,13 @@ Document::Document( std::string const &filename ) : ElementSet(-1)
 
    Group0002Parsed = false;
 
-   gdcmVerboseMacro( "Starting parsing of file: " << Filename.c_str());
+   gdcmWarningMacro( "Starting parsing of file: " << Filename.c_str());
   // Fp->seekg( 0,  std::ios::beg);
    
-   Fp->seekg(0,  std::ios::end);
+   Fp->seekg(0, std::ios::end);
    long lgt = Fp->tellg();
            
-   Fp->seekg( 0,  std::ios::beg);
+   Fp->seekg(0, std::ios::beg);
 
    CheckSwap();
    long beg = Fp->tellg();
@@ -91,21 +91,21 @@ Document::Document( std::string const &filename ) : ElementSet(-1)
    
    // Load 'non string' values
       
-   std::string PhotometricInterpretation = GetEntry(0x0028,0x0004);   
+   std::string PhotometricInterpretation = GetEntryValue(0x0028,0x0004);   
    if( PhotometricInterpretation == "PALETTE COLOR " )
    {
       LoadEntryBinArea(0x0028,0x1200);  // gray LUT   
       /// FIXME FIXME FIXME
       /// The tags refered by the three following lines used to be CORRECTLY
       /// defined as having an US Value Representation in the public
-      /// dictionnary. BUT the semantics implied by the three following
+      /// dictionary. BUT the semantics implied by the three following
       /// lines state that the corresponding tag contents are in fact
       /// the ones of a BinEntry.
-      /// In order to fix things "Quick and Dirty" the dictionnary was
+      /// In order to fix things "Quick and Dirty" the dictionary was
       /// altered on PURPOSE but now contains a WRONG value.
       /// In order to fix things and restore the dictionary to its
       /// correct value, one needs to decided of the semantics by deciding
-      /// wether the following tags are either:
+      /// whether the following tags are either:
       /// - multivaluated US, and hence loaded as ValEntry, but afterwards
       ///   also used as BinEntry, which requires the proper conversion,
       /// - OW, and hence loaded as BinEntry, but afterwards also used
@@ -126,7 +126,7 @@ Document::Document( std::string const &filename ) : ElementSet(-1)
 
    CloseFile(); 
   
-   // --------------------------------------------------------------
+   // ----------------------------
    // Specific code to allow gdcm to read ACR-LibIDO formated images
    // Note: ACR-LibIDO is an extension of the ACR standard that was
    //       used at CREATIS. For the time being (say a couple years)
@@ -137,30 +137,31 @@ Document::Document( std::string const &filename ) : ElementSet(-1)
    // we switch lineNumber and columnNumber
    //
    std::string RecCode;
-   RecCode = GetEntry(0x0008, 0x0010); // recognition code
+   RecCode = GetEntryValue(0x0008, 0x0010); // recognition code (RET)
    if (RecCode == "ACRNEMA_LIBIDO_1.1" ||
        RecCode == "CANRME_AILIBOD1_1." )  // for brain-damaged softwares
                                           // with "little-endian strings"
    {
          Filetype = ACR_LIBIDO; 
-         std::string rows    = GetEntry(0x0028, 0x0010);
-         std::string columns = GetEntry(0x0028, 0x0011);
-         SetEntry(columns, 0x0028, 0x0010);
-         SetEntry(rows   , 0x0028, 0x0011);
+         std::string rows    = GetEntryValue(0x0028, 0x0010);
+         std::string columns = GetEntryValue(0x0028, 0x0011);
+         SetValEntry(columns, 0x0028, 0x0010);
+         SetValEntry(rows   , 0x0028, 0x0011);
    }
-   // ----------------- End of ACR-LibIDO kludge ------------------ 
+   // --- End of ACR-LibIDO kludge --- 
 }
 
 /**
  * \brief This default constructor doesn't parse the file. You should
  *        then invoke \ref Document::SetFileName and then the parsing.
  */
-Document::Document() : ElementSet(-1)
+Document::Document() 
+         :ElementSet(-1)
 {
    Fp = 0;
 
    SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
-   Initialise();
+   Initialize();
    SwapCode = 1234;
    Filetype = ExplicitVR;
    Group0002Parsed = false;
@@ -173,32 +174,6 @@ Document::~Document ()
 {
    RefPubDict = NULL;
    RefShaDict = NULL;
-
-   delete RLEInfo;
-   delete JPEGInfo;
-}
-
-//-----------------------------------------------------------------------------
-// Print
-
-/**
-  * \brief   Prints The Dict Entries of THE public Dicom Dictionary
-  * @return
-  */  
-void Document::PrintPubDict(std::ostream &os)
-{
-   RefPubDict->SetPrintLevel(PrintLevel);
-   RefPubDict->Print(os);
-}
-
-/**
-  * \brief   Prints The Dict Entries of THE shadow Dicom Dictionary
-  * @return
-  */
-void Document::PrintShaDict(std::ostream &os)
-{
-   RefShaDict->SetPrintLevel(PrintLevel);
-   RefShaDict->Print(os);
 }
 
 //-----------------------------------------------------------------------------
@@ -251,19 +226,59 @@ bool Document::IsReadable()
 {
    if( Filetype == Unknown)
    {
-      gdcmVerboseMacro( "Wrong filetype");
+      gdcmWarningMacro( "Wrong filetype");
       return false;
    }
 
-   if( TagHT.empty() )
+   if ( IsEmpty() )
    { 
-      gdcmVerboseMacro( "No tags in internal hash table.");
+      gdcmWarningMacro( "No tag in internal hash table.");
       return false;
    }
 
    return true;
 }
 
+/**
+ * \brief   Predicate for dicom version 3 file.
+ * @return  True when the file is a dicom version 3.
+ */
+bool Document::IsDicomV3()
+{
+   // Checking if Transfer Syntax exists is enough
+   // Anyway, it's to late check if the 'Preamble' was found ...
+   // And ... would it be a rich idea to check ?
+   // (some 'no Preamble' DICOM images exist !)
+   return GetDocEntry(0x0002, 0x0010) != NULL;
+}
+
+/**
+ * \brief   Predicate for Papyrus file
+ *          Dedicated to whomsoever it may concern
+ * @return  True when the file is a Papyrus file.
+ */
+bool Document::IsPapyrus()
+{
+   // check for Papyrus private Sequence
+   DocEntry *e = GetDocEntry(0x0041, 0x1050);
+   if ( !e )
+      return false;
+   // check if it's actually a Sequence
+   if ( !dynamic_cast<SeqEntry*>(e) )
+      return  false;
+   return true;
+}
+
+/**
+ * \brief  returns the File Type 
+ *         (ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown)
+ * @return the FileType code
+ */
+FileType Document::GetFileType()
+{
+   return Filetype;
+}
+
 /**
  * \brief   Accessor to the Transfer Syntax (when present) of the
  *          current document (it internally handles reading the
@@ -302,28 +317,77 @@ std::string Document::GetTransferSyntax()
 }
 
 /**
- * \brief   Predicate for dicom version 3 file.
- * @return  True when the file is a dicom version 3.
+ * \brief Accesses the info from 0002,0010 : Transfer Syntax and TS
+ * @return The full Transfer Syntax Name (as opposed to Transfer Syntax UID)
  */
-bool Document::IsDicomV3()
+std::string Document::GetTransferSyntaxName()
 {
-   // Checking if Transfer Syntax exists is enough
-   // Anyway, it's to late check if the 'Preamble' was found ...
-   // And ... would it be a rich idea to check ?
-   // (some 'no Preamble' DICOM images exist !)
-   return GetDocEntry(0x0002, 0x0010) != NULL;
-}
+   // use the TS (TS : Transfer Syntax)
+   std::string transferSyntax = GetEntryValue(0x0002,0x0010);
+
+   if ( (transferSyntax.find(GDCM_NOTLOADED) < transferSyntax.length()) )
+   {
+      gdcmErrorMacro( "Transfer Syntax not loaded. " << std::endl
+               << "Better you increase MAX_SIZE_LOAD_ELEMENT_VALUE" );
+      return "Uncompressed ACR-NEMA";
+   }
+   if ( transferSyntax == GDCM_UNFOUND )
+   {
+      gdcmWarningMacro( "Unfound Transfer Syntax (0002,0010)");
+      return "Uncompressed ACR-NEMA";
+   }
+
+   // we do it only when we need it
+   const TSKey &tsName = Global::GetTS()->GetValue( transferSyntax );
 
+   // Global::GetTS() is a global static you shall never try to delete it!
+   return tsName;
+}
+//
+// --------------- Swap Code ------------------
 /**
- * \brief  returns the File Type 
- *         (ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown)
- * @return the FileType code
+ * \brief   Swaps the bytes so they agree with the processor order
+ * @return  The properly swaped 16 bits integer.
  */
-FileType Document::GetFileType()
+uint16_t Document::SwapShort(uint16_t a)
 {
-   return Filetype;
+   if ( SwapCode == 4321 || SwapCode == 2143 )
+   {
+      a = ((( a << 8 ) & 0xff00 ) | (( a >> 8 ) & 0x00ff ) );
+   }
+   return a;
 }
 
+/**
+ * \brief   Swaps back the bytes of 4-byte long integer accordingly to
+ *          processor order.
+ * @return  The properly swaped 32 bits integer.
+ */
+uint32_t Document::SwapLong(uint32_t a)
+{
+   switch (SwapCode)
+   {
+      case 1234 :
+         break;
+      case 4321 :
+         a=( ((a<<24) & 0xff000000) | ((a<<8)  & 0x00ff0000) | 
+             ((a>>8)  & 0x0000ff00) | ((a>>24) & 0x000000ff) );
+         break;   
+      case 3412 :
+         a=( ((a<<16) & 0xffff0000) | ((a>>16) & 0x0000ffff) );
+         break;  
+      case 2143 :
+         a=( ((a<< 8) & 0xff00ff00) | ((a>>8) & 0x00ff00ff)  );
+      break;
+      default :
+         gdcmErrorMacro( "Unset swap code:" << SwapCode );
+         a = 0;
+   }
+   return a;
+} 
+
+//
+// -----------------File I/O ---------------
 /**
  * \brief  Tries to open the file \ref Document::Filename and
  *         checks the preamble when existing.
@@ -331,7 +395,6 @@ FileType Document::GetFileType()
  */
 std::ifstream *Document::OpenFile()
 {
-
    HasDCMPreamble = false;
    if (Filename.length() == 0) 
    {
@@ -340,7 +403,8 @@ std::ifstream *Document::OpenFile()
 
    if(Fp)
    {
-      gdcmVerboseMacro( "File already open: " << Filename.c_str());
+      gdcmWarningMacro( "File already open: " << Filename.c_str());
+      CloseFile();
    }
 
    Fp = new std::ifstream(Filename.c_str(), std::ios::in | std::ios::binary);
@@ -352,7 +416,7 @@ std::ifstream *Document::OpenFile()
       return 0;
    }
  
-   uint16_t zero;
+   uint16_t zero = 0;
    Fp->read((char*)&zero, (size_t)2);
    if( Fp->eof() )
    {
@@ -369,13 +433,13 @@ std::ifstream *Document::OpenFile()
    {
       std::string msg 
          = Util::Format("ACR/DICOM with no preamble: (%04x)\n", zero);
-      gdcmVerboseMacro( msg.c_str() );
+      gdcmWarningMacro( msg.c_str() );
       return Fp;
    }
  
    //DICOM
    Fp->seekg(126L, std::ios::cur);
-   char dicm[4];
+   char dicm[4] = {' ',' ',' ',' '};
    Fp->read(dicm,  (size_t)4);
    if( Fp->eof() )
    {
@@ -389,7 +453,7 @@ std::ifstream *Document::OpenFile()
    }
  
    CloseFile();
-   gdcmVerboseMacro( "Not DICOM/ACR (missing preamble)" << Filename.c_str());
+   gdcmWarningMacro( "Not DICOM/ACR (missing preamble)" << Filename.c_str());
  
    return 0;
 }
@@ -406,23 +470,23 @@ bool Document::CloseFile()
       delete Fp;
       Fp = 0;
    }
-
-   return true; //FIXME how do we detect a non-close ifstream ?
+   return true; //FIXME how do we detect a non-closed ifstream ?
 }
 
 /**
  * \brief Writes in a file all the Header Entries (Dicom Elements) 
- * @param fp file pointer on an already open file
+ * @param fp file pointer on an already open file (actually: Output File Stream)
  * @param filetype Type of the File to be written 
  *          (ACR-NEMA, ExplicitVR, ImplicitVR)
- * \return Always true.
+ * @return Always true.
  */
 void Document::WriteContent(std::ofstream *fp, FileType filetype)
 {
-   /// \todo move the following lines (and a lot of others, to be written)
-   /// to a future function CheckAndCorrectHeader  
-   /// (necessary if user wants to write a DICOM V3 file
-   /// starting from an  ACR-NEMA (V2)  Header
+   // \TODO move the following lines (and a lot of others, to be written)
+   // to a future function CheckAndCorrectHeader  
+
+   // (necessary if user wants to write a DICOM V3 file
+   // starting from an ACR-NEMA (V2) Header
 
    if ( filetype == ImplicitVR || filetype == ExplicitVR )
    {
@@ -433,638 +497,278 @@ void Document::WriteContent(std::ofstream *fp, FileType filetype)
       fp->write("DICM", 4);
    }
 
-/**
- * \todo rewrite later, if really usefull
- *       - 'Group Length' element is optional in DICOM
- *       - but un-updated odd groups lengthes can causes pb
- *         (xmedcon breaker)
- *
- * if ( (filetype == ImplicitVR) || (filetype == ExplicitVR) )
- *    UpdateGroupLength(false,filetype);
- * if ( filetype == ACR)
- *    UpdateGroupLength(true,ACR);
- */
+   /*
   * \todo rewrite later, if really usefull
   *       - 'Group Length' element is optional in DICOM
   *       - but un-updated odd groups lengthes can causes pb
   *         (xmedcon breaker)
   *
   * if ( (filetype == ImplicitVR) || (filetype == ExplicitVR) )
   *    UpdateGroupLength(false,filetype);
   * if ( filetype == ACR)
   *    UpdateGroupLength(true,ACR);
   */
+
    ElementSet::WriteContent(fp, filetype); // This one is recursive
 }
 
+// -----------------------------------------
+// Content entries 
 /**
- * \brief   Modifies the value of a given Doc Entry (Dicom Element)
- *          when it exists. Create it with the given value when unexistant.
- * @param   value (string) Value to be set
- * @param   group   Group number of the Entry 
- * @param   elem  Element number of the Entry
- * @param   vr  V(alue) R(epresentation) of the Entry -if private Entry-
- * \return  pointer to the modified/created Header Entry (NULL when creation
- *          failed).
- */ 
-ValEntry *Document::ReplaceOrCreate(std::string const &value, 
-                                    uint16_t group, 
-                                    uint16_t elem,
-                                    TagName const &vr )
-{
-   ValEntry *valEntry = 0;
-   DocEntry *currentEntry = GetDocEntry( group, elem);
-   
-   if (currentEntry)
-   {
-      valEntry = dynamic_cast< ValEntry* >(currentEntry);
-
-      // Verify the VR
-      if( valEntry )
-         if( valEntry->GetVR()!=vr )
-            valEntry=NULL;
-
-      // if currentEntry doesn't correspond to the requested valEntry
-      if( !valEntry)
-      {
-         if (!RemoveEntry(currentEntry))
-         {
-            gdcmVerboseMacro( "Removal of previous DocEntry failed.");
-
-            return NULL;
-         }
-      }
-   }
-
-   // Create a new valEntry if necessary
-   if (!valEntry)
-   {
-      valEntry = NewValEntry(group, elem, vr);
-
-      if ( !AddEntry(valEntry))
-      {
-         gdcmVerboseMacro("AddEntry failed although this is a creation.");
-
-         delete valEntry;
-         return NULL;
-      }
-   }
-
-   // Set the binEntry value
-   SetEntry(value, valEntry);
-   return valEntry;
-}   
-
-/*
- * \brief   Modifies the value of a given Header Entry (Dicom Element)
- *          when it exists. Create it with the given value when unexistant.
- *          A copy of the binArea is made to be kept in the Document.
- * @param   binArea (binary) value to be set
- * @param   Group   Group number of the Entry 
- * @param   Elem  Element number of the Entry
- * @param   vr  V(alue) R(epresentation) of the Entry -if private Entry-
- * \return  pointer to the modified/created Header Entry (NULL when creation
- *          failed).
+ * \brief Loads (from disk) the element content 
+ *        when a string is not suitable
+ * @param group   group number of the Entry 
+ * @param elem  element number of the Entry
  */
-BinEntry *Document::ReplaceOrCreate(uint8_t *binArea,
-                                    int lgth, 
-                                    uint16_t group, 
-                                    uint16_t elem,
-                                    TagName const &vr )
+void Document::LoadEntryBinArea(uint16_t group, uint16_t elem)
 {
-   BinEntry *binEntry = 0;
-   DocEntry *currentEntry = GetDocEntry( group, elem);
-
-   // Verify the currentEntry
-   if (currentEntry)
-   {
-      binEntry = dynamic_cast< BinEntry* >(currentEntry);
-
-      // Verify the VR
-      if( binEntry )
-         if( binEntry->GetVR()!=vr )
-            binEntry=NULL;
-
-      // if currentEntry doesn't correspond to the requested valEntry
-      if( !binEntry)
-      {
-         if (!RemoveEntry(currentEntry))
-         {
-            gdcmVerboseMacro( "Removal of previous DocEntry failed.");
-
-            return NULL;
-         }
-      }
-   }
-
-   // Create a new binEntry if necessary
-   if (!binEntry)
-   {
-      binEntry = NewBinEntry(group, elem, vr);
-
-      if ( !AddEntry(binEntry))
-      {
-         gdcmVerboseMacro( "AddEntry failed allthough this is a creation.");
-
-         delete binEntry;
-         return NULL;
-      }
-   }
+   // Search the corresponding DocEntry
+   DocEntry *docElement = GetDocEntry(group, elem);
+   if ( !docElement )
+      return;
 
-   // Set the binEntry value
-   uint8_t *tmpArea;
-   if (lgth>0 && binArea)
-   {
-      tmpArea = new uint8_t[lgth];
-      memcpy(tmpArea,binArea,lgth);
-   }
-   else
-   {
-      tmpArea = 0;
-   }
-   if (!SetEntry(tmpArea,lgth,binEntry))
-   {
-      if (tmpArea)
-      {
-         delete[] tmpArea;
-      }
-   }
+   BinEntry *binElement = dynamic_cast<BinEntry *>(docElement);
+   if( !binElement )
+      return;
 
-   return binEntry;
-}  
+   LoadEntryBinArea(binElement);
+}
 
-/*
- * \brief   Modifies the value of a given Header Entry (Dicom Element)
- *          when it exists. Create it when unexistant.
- * @param   Group   Group number of the Entry 
- * @param   Elem  Element number of the Entry
- * \return  pointer to the modified/created SeqEntry (NULL when creation
- *          failed).
+/**
+ * \brief Loads (from disk) the element content 
+ *        when a string is not suitable
+ * @param elem  Entry whose binArea is going to be loaded
  */
-SeqEntry *Document::ReplaceOrCreate( uint16_t group, uint16_t elem)
+void Document::LoadEntryBinArea(BinEntry *elem) 
 {
-   SeqEntry *seqEntry = 0;
-   DocEntry *currentEntry = GetDocEntry( group, elem);
-
-   // Verify the currentEntry
-   if (currentEntry)
-   {
-      seqEntry = dynamic_cast< SeqEntry* >(currentEntry);
-
-      // Verify the VR
-      if( seqEntry )
-         if( seqEntry->GetVR()!="SQ" )
-            seqEntry=NULL;
+   if(elem->GetBinArea())
+      return;
 
-      // if currentEntry doesn't correspond to the requested valEntry
-      if( !seqEntry)
-      {
-         if (!RemoveEntry(currentEntry))
-         {
-            gdcmVerboseMacro( "Removal of previous DocEntry failed.");
+   bool openFile = !Fp;
+   if(openFile)
+      OpenFile();
 
-            return NULL;
-         }
-      }
-   }
+   size_t o =(size_t)elem->GetOffset();
+   Fp->seekg(o, std::ios::beg);
 
-   // Create a new seqEntry if necessary
-   if (!seqEntry)
+   size_t l = elem->GetLength();
+   uint8_t *a = new uint8_t[l];
+   if( !a )
    {
-      seqEntry = NewSeqEntry(group, elem);
-
-      if ( !AddEntry(seqEntry))
-      {
-         gdcmVerboseMacro( "AddEntry failed allthough this is a creation.");
-
-         delete seqEntry;
-         return NULL;
-      }
+      gdcmWarningMacro( "Cannot allocate BinEntry content");
+      return;
    }
 
-   return seqEntry;
-} 
-/**
- * \brief Set a new value if the invoked element exists
- *        Seems to be useless !!!
- * @param value new element value
- * @param group  group number of the Entry 
- * @param elem element number of the Entry
- * \return  boolean 
- */
-bool Document::ReplaceIfExist(std::string const &value, 
-                              uint16_t group, uint16_t elem ) 
-{
-   SetEntry(value, group, elem);
-
-   return true;
-} 
-
-//-----------------------------------------------------------------------------
-// Protected
-
-/**
- * \brief   Checks if a given Dicom Element exists within the H table
- * @param   group      Group number of the searched Dicom Element 
- * @param   element  Element number of the searched Dicom Element 
- * @return true is found
- */
-bool Document::CheckIfEntryExist(uint16_t group, uint16_t element )
-{
-   const std::string &key = DictEntry::TranslateToKey(group, element );
-   return TagHT.count(key) != 0;
-}
-
-
-/**
- * \brief   Searches within Header Entries (Dicom Elements) parsed with 
- *          the public and private dictionaries 
- *          for the element value representation of a given tag.
- * @param   group Group number of the searched tag.
- * @param   element Element number of the searched tag.
- * @return  Corresponding element value representation when it exists,
- *          and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
- */
-std::string Document::GetEntry(uint16_t group, uint16_t element)
-{
-   TagKey key = DictEntry::TranslateToKey(group, element);
-   if ( !TagHT.count(key))
+   /// \todo check the result 
+   Fp->read((char*)a, l);
+   if( Fp->fail() || Fp->eof())
    {
-      return GDCM_UNFOUND;
+      delete[] a;
+      return;
    }
 
-   return ((ValEntry *)TagHT.find(key)->second)->GetValue();
+   elem->SetBinArea(a);
+
+   if(openFile)
+      CloseFile();
 }
 
 /**
- * \brief   Searches within Header Entries (Dicom Elements) parsed with 
- *          the public and private dictionaries 
- *          for the element value representation of a given tag..
- *
- *          Obtaining the VR (Value Representation) might be needed by caller
- *          to convert the string typed content to caller's native type 
- *          (think of C++ vs Python). The VR is actually of a higher level
- *          of semantics than just the native C++ type.
- * @param   group     Group number of the searched tag.
- * @param   element Element number of the searched tag.
- * @return  Corresponding element value representation when it exists,
- *          and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
+ * \brief  Loads the element while preserving the current
+ *         underlying file position indicator as opposed to
+ *        LoadDocEntry that modifies it.
+ * @param entry   DocEntry whose value will be loaded. 
  */
-std::string Document::GetEntryVR(uint16_t group, uint16_t element)
+void Document::LoadDocEntrySafe(DocEntry *entry)
 {
-   DocEntry *elem = GetDocEntry(group, element);
-   if ( !elem )
+   if(Fp)
    {
-      return GDCM_UNFOUND;
+      long PositionOnEntry = Fp->tellg();
+      LoadDocEntry(entry);
+      Fp->seekg(PositionOnEntry, std::ios::beg);
    }
-   return elem->GetVR();
 }
 
 /**
- * \brief   Searches within Header Entries (Dicom Elements) parsed with 
- *          the public and private dictionaries 
- *          for the value length of a given tag..
- * @param   group     Group number of the searched tag.
- * @param   element Element number of the searched tag.
- * @return  Corresponding element length; -2 if not found
+ * \brief   Compares two documents, according to \ref DicomDir rules
+ * \warning Does NOT work with ACR-NEMA files
+ * \todo    Find a trick to solve the pb (use RET fields ?)
+ * @param   document to compare with current one
+ * @return  true if 'smaller'
  */
-int Document::GetEntryLength(uint16_t group, uint16_t element)
+bool Document::operator<(Document &document)
 {
-   DocEntry *elem =  GetDocEntry(group, element);
-   if ( !elem )
+   // Patient Name
+   std::string s1 = GetEntryValue(0x0010,0x0010);
+   std::string s2 = document.GetEntryValue(0x0010,0x0010);
+   if(s1 < s2)
    {
-      return -2;  //magic number
+      return true;
    }
-   return elem->GetLength();
-}
-
-/**
- * \brief   Accesses an existing DocEntry (i.e. a Dicom Element)
- *          through it's (group, element) and modifies it's content with
- *          the given value.
- * @param   content new value (string) to substitute with
- * @param   group     group number of the Dicom Element to modify
- * @param   element element number of the Dicom Element to modify
- */
-bool Document::SetEntry(std::string const& content, 
-                        uint16_t group, uint16_t element) 
-{
-   ValEntry *entry = GetValEntry(group, element);
-   if (!entry )
+   else if( s1 > s2 )
    {
-      gdcmVerboseMacro( "No corresponding ValEntry (try promotion first).");
       return false;
    }
-   return SetEntry(content,entry);
-} 
-
-/**
- * \brief   Accesses an existing DocEntry (i.e. a Dicom Element)
- *          through it's (group, element) and modifies it's content with
- *          the given value.
- * @param   content new value (void*  -> uint8_t*) to substitute with
- * @param   lgth new value length
- * @param   group     group number of the Dicom Element to modify
- * @param   element element number of the Dicom Element to modify
- */
-bool Document::SetEntry(uint8_t*content, int lgth, 
-                        uint16_t group, uint16_t element) 
-{
-   BinEntry *entry = GetBinEntry(group, element);
-   if (!entry )
-   {
-      gdcmVerboseMacro( "No corresponding ValEntry (try promotion first).");
-      return false;
-   }
-
-   return SetEntry(content,lgth,entry);
-} 
-
-/**
- * \brief   Accesses an existing DocEntry (i.e. a Dicom Element)
- *          and modifies it's content with the given value.
- * @param  content new value (string) to substitute with
- * @param  entry Entry to be modified
- */
-bool Document::SetEntry(std::string const &content,ValEntry *entry)
-{
-   if(entry)
-   {
-      entry->SetValue(content);
-      return true;
-   }
-   return false;
-}
-
-/**
- * \brief   Accesses an existing BinEntry (i.e. a Dicom Element)
- *          and modifies it's content with the given value.
- * @param   content new value (void*  -> uint8_t*) to substitute with
- * @param  entry Entry to be modified 
- * @param   lgth new value length
- */
-bool Document::SetEntry(uint8_t *content, int lgth, BinEntry *entry)
-{
-   if(entry)
+   else
    {
-      // Hope Binary field length is *never* wrong    
-      /*if(lgth%2) // Non even length are padded with a space (020H).
-      {  
-         lgth++;
-         //content = content + '\0'; // fing a trick to enlarge a binary field?
-      }*/
-      
-      entry->SetBinArea(content);  
-      entry->SetLength(lgth);
-      entry->SetValue(GDCM_BINLOADED);
-      return true;
+      // Patient ID
+      s1 = GetEntryValue(0x0010,0x0020);
+      s2 = document.GetEntryValue(0x0010,0x0020);
+      if ( s1 < s2 )
+      {
+         return true;
+      }
+      else if ( s1 > s2 )
+      {
+         return false;
+      }
+      else
+      {
+         // Study Instance UID
+         s1 = GetEntryValue(0x0020,0x000d);
+         s2 = document.GetEntryValue(0x0020,0x000d);
+         if ( s1 < s2 )
+         {
+            return true;
+         }
+         else if( s1 > s2 )
+         {
+            return false;
+         }
+         else
+         {
+            // Serie Instance UID
+            s1 = GetEntryValue(0x0020,0x000e);
+            s2 = document.GetEntryValue(0x0020,0x000e);    
+            if ( s1 < s2 )
+            {
+               return true;
+            }
+            else if( s1 > s2 )
+            {
+               return false;
+            }
+         }
+      }
    }
    return false;
 }
 
+//-----------------------------------------------------------------------------
+// Protected
 /**
- * \brief   Gets (from Header) a 'non string' element value 
- *          (LoadElementValues has already be executed)  
- * @param group   group number of the Entry 
- * @param elem  element number of the Entry
- * @return Pointer to the 'non string' area
- */
-void *Document::GetEntryBinArea(uint16_t group, uint16_t elem) 
-{
-   DocEntry *entry = GetDocEntry(group, elem);
-   if (!entry) 
-   {
-      gdcmVerboseMacro( "No entry");
-      return 0;
-   }
-   if ( BinEntry *binEntry = dynamic_cast<BinEntry*>(entry) )
-   {
-      return binEntry->GetBinArea();
-   }
-
-   return 0;
-}
-
-/**
- * \brief         Loads (from disk) the element content 
- *                when a string is not suitable
- * @param group   group number of the Entry 
- * @param elem  element number of the Entry
- */
-void Document::LoadEntryBinArea(uint16_t group, uint16_t elem)
-{
-   // Search the corresponding DocEntry
-   DocEntry *docElement = GetDocEntry(group, elem);
-   if ( !docElement )
-      return;
-
-   BinEntry *binElement = dynamic_cast<BinEntry *>(docElement);
-   if( !binElement )
-      return;
-
-   LoadEntryBinArea(binElement);
-}
-
-/**
- * \brief         Loads (from disk) the element content 
- *                when a string is not suitable
- * @param element  Entry whose binArea is going to be loaded
+ * \brief Reads a supposed to be 16 Bits integer
+ *       (swaps it depending on processor endianness) 
+ * @return read value
  */
-void Document::LoadEntryBinArea(BinEntry *element) 
+uint16_t Document::ReadInt16()
+   throw( FormatError )
 {
-   if(element->GetBinArea())
-      return;
-
-   bool openFile = !Fp;
-   if(openFile)
-      OpenFile();
-
-   size_t o =(size_t)element->GetOffset();
-   Fp->seekg(o, std::ios::beg);
-
-   size_t l = element->GetLength();
-   uint8_t *a = new uint8_t[l];
-   if( !a )
+   uint16_t g;
+   Fp->read ((char*)&g, (size_t)2);
+   if ( Fp->fail() )
    {
-      gdcmVerboseMacro( "Cannot allocate a");
-      return;
+      throw FormatError( "Document::ReadInt16()", " file error." );
    }
-
-   /// \todo check the result 
-   Fp->read((char*)a, l);
-   if( Fp->fail() || Fp->eof())
+   if( Fp->eof() )
    {
-      delete[] a;
-      return;
+      throw FormatError( "Document::ReadInt16()", "EOF." );
    }
-
-   element->SetBinArea(a);
-
-   if(openFile)
-      CloseFile();
+   g = SwapShort(g); 
+   return g;
 }
 
 /**
- * \brief   Sets a 'non string' value to a given Dicom Element
- * @param   area area containing the 'non string' value
- * @param   group     Group number of the searched Dicom Element 
- * @param   element Element number of the searched Dicom Element 
- * @return  
+ * \brief  Reads a supposed to be 32 Bits integer
+ *        (swaps it depending on processor endianness)  
+ * @return read value
  */
-/*bool Document::SetEntryBinArea(uint8_t *area,
-                                 uint16_t group, uint16_t element) 
+uint32_t Document::ReadInt32()
+   throw( FormatError )
 {
-   DocEntry *currentEntry = GetDocEntry(group, element);
-   if ( !currentEntry )
-   {
-      return false;
-   }
-
-   if ( BinEntry *binEntry = dynamic_cast<BinEntry*>(currentEntry) )
+   uint32_t g;
+   Fp->read ((char*)&g, (size_t)4);
+   if ( Fp->fail() )
    {
-      binEntry->SetBinArea( area );
-      return true;
+      throw FormatError( "Document::ReadInt32()", " file error." );
    }
-
-   return false;
-}*/
-
-/**
- * \brief  retrieves a Dicom Element (the first one) using (group, element)
- * \warning (group, element) IS NOT an identifier inside the Dicom Header
- *           if you think it's NOT UNIQUE, check the count number
- *           and use iterators to retrieve ALL the Dicoms Elements within
- *           a given couple (group, element)
- * @param   group Group number of the searched Dicom Element 
- * @param   element Element number of the searched Dicom Element 
- * @return  
- */
-DocEntry *Document::GetDocEntry(uint16_t group, uint16_t element) 
-{
-   TagKey key = DictEntry::TranslateToKey(group, element);
-   if ( !TagHT.count(key))
+   if( Fp->eof() )
    {
-      return NULL;
+      throw FormatError( "Document::ReadInt32()", "EOF." );
    }
-   return TagHT.find(key)->second;
+   g = SwapLong(g);
+   return g;
 }
 
 /**
- * \brief  Same as \ref Document::GetDocEntry except it only
- *         returns a result when the corresponding entry is of type
- *         ValEntry.
- * @return When present, the corresponding ValEntry. 
+ * \brief skips bytes inside the source file 
+ * \warning NOT end user intended method !
+ * @return 
  */
-ValEntry *Document::GetValEntry(uint16_t group, uint16_t element)
+void Document::SkipBytes(uint32_t nBytes)
 {
-   DocEntry *currentEntry = GetDocEntry(group, element);
-   if ( !currentEntry )
-   {
-      return 0;
-   }
-   if ( ValEntry *entry = dynamic_cast<ValEntry*>(currentEntry) )
-   {
-      return entry;
-   }
-   gdcmVerboseMacro( "Unfound ValEntry.");
-
-   return 0;
+   //FIXME don't dump the returned value
+   Fp->seekg((long)nBytes, std::ios::cur);
 }
 
 /**
- * \brief  Same as \ref Document::GetDocEntry except it only
- *         returns a result when the corresponding entry is of type
- *         BinEntry.
- * @return When present, the corresponding BinEntry. 
+ * \brief   Re-computes the length of a ACR-NEMA/Dicom group from a DcmHeader
+ * @param filetype Type of the File to be written 
  */
-BinEntry *Document::GetBinEntry(uint16_t group, uint16_t element)
+int Document::ComputeGroup0002Length( FileType filetype ) 
 {
-   DocEntry *currentEntry = GetDocEntry(group, element);
-   if ( !currentEntry )
-   {
-      return 0;
-   }
-   if ( BinEntry *entry = dynamic_cast<BinEntry*>(currentEntry) )
+   uint16_t gr;
+   std::string vr;
+   
+   int groupLength = 0;
+   bool found0002 = false;   
+  
+   // for each zero-level Tag in the DCM Header
+   DocEntry *entry = GetFirstEntry();
+   while( entry )
    {
-      return entry;
-   }
-   gdcmVerboseMacro( "Unfound BinEntry.");
-
-   return 0;
-}
+      gr = entry->GetGroup();
 
-/**
- * \brief         Loads the element while preserving the current
- *               underlying file position indicator as opposed to
- *                to LoadDocEntry that modifies it.
- * @param entry   Header Entry whose value will be loaded. 
- * @return  
- */
-void Document::LoadDocEntrySafe(DocEntry *entry)
-{
-   if(Fp)
-   {
-      long PositionOnEntry = Fp->tellg();
-      LoadDocEntry(entry);
-      Fp->seekg(PositionOnEntry, std::ios::beg);
-   }
-}
+      if( gr == 0x0002 )
+      {
+         found0002 = true;
 
-/**
- * \brief   Swaps back the bytes of 4-byte long integer accordingly to
- *          processor order.
- * @return  The properly swaped 32 bits integer.
- */
-uint32_t Document::SwapLong(uint32_t a)
-{
-   switch (SwapCode)
-   {
-      case 1234 :
+         if( entry->GetElement() != 0x0000 )
+         {
+            vr = entry->GetVR();
+            if( filetype == ExplicitVR )
+            {
+               if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") ) 
+               {
+                  // explicit VR AND OB, OW, SQ : 4 more bytes
+                  groupLength +=  4;
+               }
+            }
+            groupLength += 2 + 2 + 4 + entry->GetLength();   
+         }
+      }
+      else if (found0002 )
          break;
-      case 4321 :
-         a=( ((a<<24) & 0xff000000) | ((a<<8)  & 0x00ff0000) | 
-             ((a>>8)  & 0x0000ff00) | ((a>>24) & 0x000000ff) );
-         break;   
-      case 3412 :
-         a=( ((a<<16) & 0xffff0000) | ((a>>16) & 0x0000ffff) );
-         break;  
-      case 2143 :
-         a=( ((a<< 8) & 0xff00ff00) | ((a>>8) & 0x00ff00ff)  );
-      break;
-      default :
-         gdcmErrorMacro( "Unset swap code:" << SwapCode );
-         a = 0;
-   }
-   return a;
-} 
-
-/**
- * \brief   Unswaps back the bytes of 4-byte long integer accordingly to
- *          processor order.
- * @return  The properly unswaped 32 bits integer.
- */
-uint32_t Document::UnswapLong(uint32_t a)
-{
-   return SwapLong(a);
-}
 
-/**
- * \brief   Swaps the bytes so they agree with the processor order
- * @return  The properly swaped 16 bits integer.
- */
-uint16_t Document::SwapShort(uint16_t a)
-{
-   if ( SwapCode == 4321 || SwapCode == 2143 )
-   {
-      a = ((( a << 8 ) & 0x0ff00 ) | (( a >> 8 ) & 0x00ff ) );
+      entry = GetNextEntry();
    }
-   return a;
+   return groupLength; 
 }
 
+//-----------------------------------------------------------------------------
+// Private
 /**
- * \brief   Unswaps the bytes so they agree with the processor order
- * @return  The properly unswaped 16 bits integer.
+ * \brief Loads all the needed Dictionaries
+ * \warning NOT end user intended method !   
  */
-uint16_t Document::UnswapShort(uint16_t a)
+void Document::Initialize() 
 {
-   return SwapShort(a);
+   RefPubDict = Global::GetDicts()->GetDefaultPubDict();
+   RefShaDict = NULL;
+   Filetype   = Unknown;
 }
 
-//-----------------------------------------------------------------------------
-// Private
-
 /**
  * \brief   Parses a DocEntrySet (Zero-level DocEntries or SQ Item DocEntries)
  * @return  length of the parsed set. 
@@ -1077,7 +781,7 @@ void Document::ParseDES(DocEntrySet *set, long offset,
    BinEntry *newBinEntry;
    SeqEntry *newSeqEntry;
    VRKey vr;
-   bool used=false;
+   bool used = false;
 
    while (true)
    {
@@ -1086,8 +790,9 @@ void Document::ParseDES(DocEntrySet *set, long offset,
          break;
       }
 
-      used=true;
+      used = true;
       newDocEntry = ReadNextDocEntry( );
+
       if ( !newDocEntry )
       {
          break;
@@ -1102,10 +807,11 @@ void Document::ParseDES(DocEntrySet *set, long offset,
       {
          if ( newBinEntry )
          {
-            if ( ! Global::GetVR()->IsVROfBinaryRepresentable(vr) )
+            if ( Filetype == ExplicitVR && 
+                 !Global::GetVR()->IsVROfBinaryRepresentable(vr) )
             { 
                 ////// Neither ValEntry NOR BinEntry: should mean UNKOWN VR
-                gdcmVerboseMacro( std::hex << newDocEntry->GetGroup() 
+                gdcmWarningMacro( std::hex << newDocEntry->GetGroup() 
                                   << "|" << newDocEntry->GetElement()
                                   << " : Neither Valentry, nor BinEntry." 
                                   "Probably unknown VR.");
@@ -1114,13 +820,12 @@ void Document::ParseDES(DocEntrySet *set, long offset,
          //////////////////// BinEntry or UNKOWN VR:
             // When "this" is a Document the Key is simply of the
             // form ( group, elem )...
-            if (Document *dummy = dynamic_cast< Document* > ( set ) )
+            if ( dynamic_cast< Document* > ( set ) )
             {
-               (void)dummy;
                newBinEntry->SetKey( newBinEntry->GetKey() );
             }
             // but when "this" is a SQItem, we are inserting this new
-            // valEntry in a sequence item, and the kay has the
+            // valEntry in a sequence item, and the key has the
             // generalized form (refer to \ref BaseTagKey):
             if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) )
             {
@@ -1141,9 +846,8 @@ void Document::ParseDES(DocEntrySet *set, long offset,
          /////////////////////// ValEntry
             // When "set" is a Document, then we are at the top of the
             // hierarchy and the Key is simply of the form ( group, elem )...
-            if (Document *dummy = dynamic_cast< Document* > ( set ) )
+            if ( dynamic_cast< Document* > ( set ) )
             {
-               (void)dummy;
                newValEntry->SetKey( newValEntry->GetKey() );
             }
             // ...but when "set" is a SQItem, we are inserting this new
@@ -1178,26 +882,6 @@ void Document::ParseDES(DocEntrySet *set, long offset,
             }
          }
 
-         if (    ( newDocEntry->GetGroup()   == 0x7fe0 )
-              && ( newDocEntry->GetElement() == 0x0010 ) )
-         {
-             std::string ts = GetTransferSyntax();
-             if ( Global::GetTS()->IsRLELossless(ts) ) 
-             {
-                long positionOnEntry = Fp->tellg();
-                Fp->seekg( newDocEntry->GetOffset(), std::ios::beg );
-                ComputeRLEInfo();
-                Fp->seekg( positionOnEntry, std::ios::beg );
-             }
-             else if ( Global::GetTS()->IsJPEG(ts) )
-             {
-                long positionOnEntry = Fp->tellg();
-                Fp->seekg( newDocEntry->GetOffset(), std::ios::beg );
-                ComputeJPEGFragmentInfo();
-                Fp->seekg( positionOnEntry, std::ios::beg );
-             }
-         }
-
          // Just to make sure we are at the beginning of next entry.
          SkipToNextDocEntry(newDocEntry);
       }
@@ -1223,9 +907,9 @@ void Document::ParseDES(DocEntrySet *set, long offset,
          // is a Document, then we are building the first depth level.
          // Hence the SeqEntry we are building simply has a depth
          // level of one:
-         if (Document *dummy = dynamic_cast< Document* > ( set ) )
+         if (/*Document *dummy =*/ dynamic_cast< Document* > ( set ) )
          {
-            (void)dummy;
+            //(void)dummy;
             newSeqEntry->SetDepthLevel( 1 );
             newSeqEntry->SetKey( newSeqEntry->GetKey() );
          }
@@ -1245,14 +929,19 @@ void Document::ParseDES(DocEntrySet *set, long offset,
                      newDocEntry->GetOffset(),
                      l, delim_mode);
          }
-         set->AddEntry( newSeqEntry );
-         if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max)
+         if( !set->AddEntry( newSeqEntry ) )
          {
+            used = false;
+         }
+         if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max)
+         {
+            if( !used )
+               delete newDocEntry;
             break;
          }
       }
 
-      if(!used)
+      if( !used )
          delete newDocEntry;
    }
 }
@@ -1266,10 +955,13 @@ void Document::ParseSQ( SeqEntry *seqEntry,
 {
    int SQItemNumber = 0;
    bool dlm_mod;
+   long offsetStartCurrentSQItem = offset;
 
    while (true)
    {
+      // the first time, we read the fff0,e000 of the first SQItem
       DocEntry *newDocEntry = ReadNextDocEntry();
+
       if ( !newDocEntry )
       {
          // FIXME Should warn user
@@ -1279,7 +971,7 @@ void Document::ParseSQ( SeqEntry *seqEntry,
       {
          if ( newDocEntry->IsSequenceDelimitor() )
          {
-            seqEntry->SetSequenceDelimitationItem( newDocEntry ); 
+            seqEntry->SetDelimitationItem( newDocEntry ); 
             break;
          }
       }
@@ -1288,7 +980,7 @@ void Document::ParseSQ( SeqEntry *seqEntry,
          delete newDocEntry;
          break;
       }
-
+      // create the current SQItem
       SQItem *itemSQ = new SQItem( seqEntry->GetDepthLevel() );
       std::ostringstream newBase;
       newBase << seqEntry->GetKey()
@@ -1306,11 +998,23 @@ void Document::ParseSQ( SeqEntry *seqEntry,
       {
          dlm_mod = false;
       }
-   
-      ParseDES(itemSQ, newDocEntry->GetOffset(), l, dlm_mod);
-      delete newDocEntry; // FIXME Why deleting fffe 000e ?!?
+      // FIXME, TODO
+      // when we're here, element fffe,e000 is already passed.
+      // it's lost for the SQItem we're going to process !!
+
+      //ParseDES(itemSQ, newDocEntry->GetOffset(), l, dlm_mod);
+      //delete newDocEntry; // FIXME well ... it's too late to use it !
+
+      // Let's try :------------
+      // remove fff0,e000, created out of the SQItem
+      delete newDocEntry;
+      Fp->seekg(offsetStartCurrentSQItem, std::ios::beg);
+      // fill up the current SQItem, starting at the beginning of fff0,e000
+      ParseDES(itemSQ, offsetStartCurrentSQItem, l+8, dlm_mod);
+      offsetStartCurrentSQItem = Fp->tellg();
+      // end try -----------------
  
-      seqEntry->AddEntry( itemSQ, SQItemNumber ); 
+      seqEntry->AddSQItem( itemSQ, SQItemNumber ); 
       SQItemNumber++;
       if ( !delim_mode && ((long)(Fp->tellg())-offset ) >= l_max )
       {
@@ -1320,9 +1024,9 @@ void Document::ParseSQ( SeqEntry *seqEntry,
 }
 
 /**
- * \brief         Loads the element content if its length doesn't exceed
- *                the value specified with Document::SetMaxSizeLoadEntry()
- * @param         entry Header Entry (Dicom Element) to be dealt with
+ * \brief   Loads the element content if its length doesn't exceed
+ *          the value specified with Document::SetMaxSizeLoadEntry()
+ * @param   entry Header Entry (Dicom Element) to be dealt with
  */
 void Document::LoadDocEntry(DocEntry *entry)
 {
@@ -1455,7 +1159,7 @@ void Document::LoadDocEntry(DocEntry *entry)
    if( length % 2 )
    {
       newValue = Util::DicomString(str, length+1);
-      gdcmVerboseMacro("Warning: bad length: " << length <<
+      gdcmWarningMacro("Warning: bad length: " << length <<
                        ",For string :" <<  newValue.c_str()); 
       // Since we change the length of string update it length
       //entry->SetReadLength(length+1);
@@ -1470,7 +1174,7 @@ void Document::LoadDocEntry(DocEntry *entry)
    {
       if ( Fp->fail() || Fp->eof())
       {
-         gdcmVerboseMacro("Unread element value");
+         gdcmWarningMacro("Unread element value");
          valEntry->SetValue(GDCM_UNREAD);
          return;
       }
@@ -1491,7 +1195,6 @@ void Document::LoadDocEntry(DocEntry *entry)
    }
 }
 
-
 /**
  * \brief  Find the value Length of the passed Header Entry
  * @param  entry Header Entry whose length of the value shall be loaded. 
@@ -1585,34 +1288,33 @@ void Document::FindDocEntryLength( DocEntry *entry )
       // hands on a big endian encoded file: we switch the swap code to
       // big endian and proceed...
 
- //
- //     if ( element  == 0x0000 && length16 == 0x0400 ) 
- //     {
- //        std::string ts = GetTransferSyntax();
- //        if ( Global::GetTS()->GetSpecialTransferSyntax(ts) 
- //               != TS::ExplicitVRBigEndian ) 
- //        {
- //           throw FormatError( "Document::FindDocEntryLength()",
- //                              " not explicit VR." );
- //          return;
- //       }
- //       length16 = 4;
- //       SwitchByteSwapCode();
-
-         // Restore the unproperly loaded values i.e. the group, the element
-         // and the dictionary entry depending on them.
-//        uint16_t correctGroup = SwapShort( entry->GetGroup() );
+//      if ( element  == 0x0000 && length16 == 0x0400 ) 
+//      {
+//         std::string ts = GetTransferSyntax();
+//         if ( Global::GetTS()->GetSpecialTransferSyntax(ts) 
+//                != TS::ExplicitVRBigEndian ) 
+//         {
+//            throw FormatError( "Document::FindDocEntryLength()",
+//                               " not explicit VR." );
+//           return;
+//        }
+//        length16 = 4;
+//        SwitchByteSwapCode();
+//
+//         // Restore the unproperly loaded values i.e. the group, the element
+//         // and the dictionary entry depending on them.
+//         uint16_t correctGroup = SwapShort( entry->GetGroup() );
 //         uint16_t correctElem  = SwapShort( entry->GetElement() );
-//         DictEntry *newTag = GetDictEntry( correctGroup, correctElem );         if ( !newTag )
+//         DictEntry *newTag = GetDictEntry( correctGroup, correctElem );
+//         if ( !newTag )
 //         {
-            // This correct tag is not in the dictionary. Create a new one.
+//            // This correct tag is not in the dictionary. Create a new one.
 //            newTag = NewVirtualDictEntry(correctGroup, correctElem);
 //         }
-         // FIXME this can create a memory leaks on the old entry that be
-         // left unreferenced.
+//         // FIXME this can create a memory leaks on the old entry that be
+//         // left unreferenced.
 //         entry->SetDictEntry( newTag );
 //      }
-
   
       // 0xffff means that we deal with 'No Length' Sequence 
       //        or 'No Length' SQItem
@@ -1631,12 +1333,72 @@ void Document::FindDocEntryLength( DocEntry *entry )
       // on Data elements "Implicit and Explicit VR Data Elements shall
       // not coexist in a Data Set and Data Sets nested within it".]
       // Length is on 4 bytes.
+
+     // Well ... group 0002 is always coded in 'Explicit VR Litle Endian'
+     // even if Transfer Syntax is 'Implicit VR ...' 
       
       FixDocEntryFoundLength( entry, ReadInt32() );
       return;
    }
 }
 
+/**
+ * \brief  Find the Length till the next sequence delimiter
+ * \warning NOT end user intended method !
+ * @return 
+ */
+uint32_t Document::FindDocEntryLengthOBOrOW()
+   throw( FormatUnexpected )
+{
+   // See PS 3.5-2001, section A.4 p. 49 on encapsulation of encoded pixel data.
+   long positionOnEntry = Fp->tellg();
+   bool foundSequenceDelimiter = false;
+   uint32_t totalLength = 0;
+
+   while ( !foundSequenceDelimiter )
+   {
+      uint16_t group;
+      uint16_t elem;
+      try
+      {
+         group = ReadInt16();
+         elem  = ReadInt16();   
+      }
+      catch ( FormatError )
+      {
+         throw FormatError("Unexpected end of file encountered during ",
+                           "Document::FindDocEntryLengthOBOrOW()");
+      }
+      // We have to decount the group and element we just read
+      totalLength += 4;     
+      if ( group != 0xfffe || ( ( elem != 0xe0dd ) && ( elem != 0xe000 ) ) )
+      {
+         long filePosition = Fp->tellg();
+         gdcmWarningMacro( "Neither an Item tag nor a Sequence delimiter tag on :" 
+           << std::hex << group << " , " << elem 
+           << ") -before- position x(" << filePosition << ")" );
+  
+         Fp->seekg(positionOnEntry, std::ios::beg);
+         throw FormatUnexpected( "Neither an Item tag nor a Sequence delimiter tag.");
+      }
+      if ( elem == 0xe0dd )
+      {
+         foundSequenceDelimiter = true;
+      }
+      uint32_t itemLength = ReadInt32();
+      // We add 4 bytes since we just read the ItemLength with ReadInt32
+      totalLength += itemLength + 4;
+      SkipBytes(itemLength);
+      
+      if ( foundSequenceDelimiter )
+      {
+         break;
+      }
+   }
+   Fp->seekg( positionOnEntry, std::ios::beg);
+   return totalLength;
+}
+
 /**
  * \brief     Find the Value Representation of the current Dicom Element.
  * @return    Value Representation of the current Entry
@@ -1677,9 +1439,6 @@ std::string Document::FindDocEntryVR()
 */
 bool Document::CheckDocEntryVR(VRKey vr)
 {
-   // CLEANME searching the dicom_vr at each occurence is expensive.
-   // PostPone this test in an optional integrity check at the end
-   // of parsing or only in debug mode.
    if ( !Global::GetVR()->IsValidVR(vr) )
       return false;
 
@@ -1757,7 +1516,6 @@ std::string Document::GetDocEntryValue(DocEntry *entry)
 #endif //GDCM_NO_ANSI_STRING_STREAM
       return s.str();
    }
-
    return ((ValEntry *)entry)->GetValue();
 }
 
@@ -1828,14 +1586,15 @@ void Document::SkipDocEntry(DocEntry *entry)
 }
 
 /**
- * \brief   Skips to the begining of the next Header Entry 
+ * \brief   Skips to the beginning of the next Header Entry 
  * \warning NOT end user intended method !
  * @param   currentDocEntry entry to skip
  */
 void Document::SkipToNextDocEntry(DocEntry *currentDocEntry) 
 {
    Fp->seekg((long)(currentDocEntry->GetOffset()),     std::ios::beg);
-   Fp->seekg( (long)(currentDocEntry->GetReadLength()),std::ios::cur);
+   if (currentDocEntry->GetGroup() != 0xfffe)  // for fffe pb
+      Fp->seekg( (long)(currentDocEntry->GetReadLength()),std::ios::cur);
 }
 
 /**
@@ -1859,7 +1618,7 @@ void Document::FixDocEntryFoundLength(DocEntry *entry,
      
    if ( foundLength % 2)
    {
-      gdcmVerboseMacro( "Warning : Tag with uneven length " << foundLength 
+      gdcmWarningMacro( "Warning : Tag with uneven length " << foundLength 
         <<  " in x(" << std::hex << gr << "," << elem <<")");
    }
       
@@ -1906,8 +1665,7 @@ void Document::FixDocEntryFoundLength(DocEntry *entry,
      {
         foundLength = 0;
      }
-   } 
-           
+   }            
    entry->SetLength(foundLength);
 }
 
@@ -1919,10 +1677,10 @@ void Document::FixDocEntryFoundLength(DocEntry *entry,
  */
 bool Document::IsDocEntryAnInteger(DocEntry *entry)
 {
-   uint16_t elem    = entry->GetElement();
-   uint16_t group   = entry->GetGroup();
+   uint16_t elem          = entry->GetElement();
+   uint16_t group         = entry->GetGroup();
    const std::string &vr  = entry->GetVR();
-   uint32_t length  = entry->GetLength();
+   uint32_t length        = entry->GetLength();
 
    // When we have some semantics on the element we just read, and if we
    // a priori know we are dealing with an integer, then we shall be
@@ -1943,7 +1701,7 @@ bool Document::IsDocEntryAnInteger(DocEntry *entry)
          // encounter such an ill-formed image, we simply display a warning
          // message and proceed on parsing (while crossing fingers).
          long filePosition = Fp->tellg();
-         gdcmVerboseMacro( "Erroneous Group Length element length  on : (" 
+         gdcmWarningMacro( "Erroneous Group Length element length  on : (" 
            << std::hex << group << " , " << elem
            << ") -before- position x(" << filePosition << ")"
            << "lgt : " << length );
@@ -1957,136 +1715,6 @@ bool Document::IsDocEntryAnInteger(DocEntry *entry)
    return false;
 }
 
-/**
- * \brief  Find the Length till the next sequence delimiter
- * \warning NOT end user intended method !
- * @return 
- */
-
-uint32_t Document::FindDocEntryLengthOBOrOW()
-   throw( FormatUnexpected )
-{
-   // See PS 3.5-2001, section A.4 p. 49 on encapsulation of encoded pixel data.
-   long positionOnEntry = Fp->tellg();
-   bool foundSequenceDelimiter = false;
-   uint32_t totalLength = 0;
-
-   while ( !foundSequenceDelimiter )
-   {
-      uint16_t group;
-      uint16_t elem;
-      try
-      {
-         group = ReadInt16();
-         elem  = ReadInt16();   
-      }
-      catch ( FormatError )
-      {
-         throw FormatError("Unexpected end of file encountered during ",
-                           "Document::FindDocEntryLengthOBOrOW()");
-      }
-
-      // We have to decount the group and element we just read
-      totalLength += 4;
-     
-      if ( group != 0xfffe || ( ( elem != 0xe0dd ) && ( elem != 0xe000 ) ) )
-      {
-         long filePosition = Fp->tellg();
-         gdcmVerboseMacro( "Neither an Item tag nor a Sequence delimiter tag on :" 
-           << std::hex << group << " , " << elem 
-           << ") -before- position x(" << filePosition << ")" );
-  
-         Fp->seekg(positionOnEntry, std::ios::beg);
-         throw FormatUnexpected( "Neither an Item tag nor a Sequence delimiter tag.");
-      }
-
-      if ( elem == 0xe0dd )
-      {
-         foundSequenceDelimiter = true;
-      }
-
-      uint32_t itemLength = ReadInt32();
-      // We add 4 bytes since we just read the ItemLength with ReadInt32
-      totalLength += itemLength + 4;
-      SkipBytes(itemLength);
-      
-      if ( foundSequenceDelimiter )
-      {
-         break;
-      }
-   }
-   Fp->seekg( positionOnEntry, std::ios::beg);
-   return totalLength;
-}
-
-/**
- * \brief Reads a supposed to be 16 Bits integer
- *       (swaps it depending on processor endianity) 
- * @return read value
- */
-uint16_t Document::ReadInt16()
-   throw( FormatError )
-{
-   uint16_t g;
-   Fp->read ((char*)&g, (size_t)2);
-   if ( Fp->fail() )
-   {
-      throw FormatError( "Document::ReadInt16()", " file error." );
-   }
-   if( Fp->eof() )
-   {
-      throw FormatError( "Document::ReadInt16()", "EOF." );
-   }
-   g = SwapShort(g); 
-   return g;
-}
-
-/**
- * \brief  Reads a supposed to be 32 Bits integer
- *         (swaps it depending on processor endianity)  
- * @return read value
- */
-uint32_t Document::ReadInt32()
-   throw( FormatError )
-{
-   uint32_t g;
-   Fp->read ((char*)&g, (size_t)4);
-   if ( Fp->fail() )
-   {
-      throw FormatError( "Document::ReadInt32()", " file error." );
-   }
-   if( Fp->eof() )
-   {
-      throw FormatError( "Document::ReadInt32()", "EOF." );
-   }
-   g = SwapLong(g);
-   return g;
-}
-
-/**
- * \brief skips bytes inside the source file 
- * \warning NOT end user intended method !
- * @return 
- */
-void Document::SkipBytes(uint32_t nBytes)
-{
-   //FIXME don't dump the returned value
-   Fp->seekg((long)nBytes, std::ios::cur);
-}
-
-/**
- * \brief Loads all the needed Dictionaries
- * \warning NOT end user intended method !   
- */
-void Document::Initialise() 
-{
-   RefPubDict = Global::GetDicts()->GetDefaultPubDict();
-   RefShaDict = NULL;
-   RLEInfo  = new RLEFramesInfo;
-   JPEGInfo = new JPEGFragmentsInfo;
-   Filetype = Unknown;
-}
-
 /**
  * \brief   Discover what the swap code is (among little endian, big endian,
  *          bad little endian, bad big endian).
@@ -2127,7 +1755,7 @@ bool Document::CheckSwap()
    char *entCur = deb + 128;
    if( memcmp(entCur, "DICM", (size_t)4) == 0 )
    {
-      gdcmVerboseMacro( "Looks like DICOM Version3 (preamble + DCM)" );
+      gdcmWarningMacro( "Looks like DICOM Version3 (preamble + DCM)" );
       
       // Group 0002 should always be VR, and the first element 0000
       // Let's be carefull (so many wrong headers ...)
@@ -2159,24 +1787,24 @@ bool Document::CheckSwap()
       // instead of just checking for UL, OB and UI !? group 0000 
       {
          Filetype = ExplicitVR;
-         gdcmVerboseMacro( "Group 0002 : Explicit Value Representation");
+         gdcmWarningMacro( "Group 0002 : Explicit Value Representation");
       } 
       else 
       {
          Filetype = ImplicitVR;
-         gdcmVerboseMacro( "Group 0002 :Not an explicit Value Representation;"
+         gdcmWarningMacro( "Group 0002 :Not an explicit Value Representation;"
                         << "Looks like a bugged Header!");
       }
       
       if ( net2host )
       {
          SwapCode = 4321;
-         gdcmVerboseMacro( "HostByteOrder != NetworkByteOrder");
+         gdcmWarningMacro( "HostByteOrder != NetworkByteOrder");
       }
       else 
       {
          SwapCode = 1234;
-         gdcmVerboseMacro( "HostByteOrder = NetworkByteOrder");
+         gdcmWarningMacro( "HostByteOrder = NetworkByteOrder");
       }
       
       // Position the file position indicator at first tag 
@@ -2189,7 +1817,7 @@ bool Document::CheckSwap()
    // Alas, this is not a DicomV3 file and whatever happens there is no file
    // preamble. We can reset the file position indicator to where the data
    // is (i.e. the beginning of the file).
-   gdcmVerboseMacro( "Not a DICOM Version3 file");
+   gdcmWarningMacro( "Not a DICOM Version3 file");
    Fp->seekg(0, std::ios::beg);
 
    // Our next best chance would be to be considering a 'clean' ACR/NEMA file.
@@ -2264,21 +1892,19 @@ bool Document::CheckSwap()
                Filetype = ACR;
                return true;
             default :
-               gdcmVerboseMacro( "ACR/NEMA unfound swap info (Really hopeless !)");
+               gdcmWarningMacro( "ACR/NEMA unfound swap info (Really hopeless !)");
                Filetype = Unknown;
                return false;
          }
    }
 }
 
-
-
 /**
  * \brief Change the Byte Swap code. 
  */
 void Document::SwitchByteSwapCode() 
 {
-   gdcmVerboseMacro( "Switching Byte Swap code from "<< SwapCode);
+   gdcmWarningMacro( "Switching Byte Swap code from "<< SwapCode);
    if ( SwapCode == 1234 ) 
    {
       SwapCode = 4321;
@@ -2315,7 +1941,6 @@ void Document::SetMaxSizeLoadEntry(long newSize)
    MaxSizeLoadEntry = newSize;
 }
 
-
 /**
  * \brief Header Elements too long will not be printed
  * \todo  See comments of \ref Document::MAX_SIZE_PRINT_ELEMENT_VALUE 
@@ -2323,7 +1948,6 @@ void Document::SetMaxSizeLoadEntry(long newSize)
  */
 void Document::SetMaxSizePrintEntry(long newSize) 
 {
-   //DOH !! This is exactly SetMaxSizeLoadEntry FIXME FIXME
    if ( newSize < 0 )
    {
       return;
@@ -2337,98 +1961,6 @@ void Document::SetMaxSizePrintEntry(long newSize)
 }
 
 
-
-/**
- * \brief   Handle broken private tag from Philips NTSCAN
- *          where the endianess is being switch to BigEndian for no
- *          apparent reason
- * @return  no return
- */
-void Document::HandleBrokenEndian(uint16_t &group, uint16_t &elem)
-{
-   // Endian reversion. Some files contain groups of tags with reversed endianess.
-   static int reversedEndian = 0;
-   // try to fix endian switching in the middle of headers
-   if ((group == 0xfeff) && (elem == 0x00e0))
-   {
-     // start endian swap mark for group found
-     reversedEndian++;
-     SwitchByteSwapCode();
-     // fix the tag
-     group = 0xfffe;
-     elem = 0xe000;
-   } 
-   else if (group == 0xfffe && elem == 0xe00d && reversedEndian) 
-   {
-     // end of reversed endian group
-     reversedEndian--;
-     SwitchByteSwapCode();
-   }
-}
-
-/**
- * \brief Accesses the info from 0002,0010 : Transfer Syntax and TS
- *        else 1.
- * @return The full Transfer Syntax Name (as opposed to Transfer Syntax UID)
- */
-std::string Document::GetTransferSyntaxName()
-{
-   // use the TS (TS : Transfer Syntax)
-   std::string transferSyntax = GetEntry(0x0002,0x0010);
-
-   if ( (transferSyntax.find(GDCM_NOTLOADED) < transferSyntax.length()) )
-   {
-      gdcmErrorMacro( "Transfer Syntax not loaded. " << std::endl
-               << "Better you increase MAX_SIZE_LOAD_ELEMENT_VALUE" );
-      return "Uncompressed ACR-NEMA";
-   }
-   if ( transferSyntax == GDCM_UNFOUND )
-   {
-      gdcmVerboseMacro( "Unfound Transfer Syntax (0002,0010)");
-      return "Uncompressed ACR-NEMA";
-   }
-
-   // we do it only when we need it
-   const TSKey &tsName = Global::GetTS()->GetValue( transferSyntax );
-
-   // Global::GetTS() is a global static you shall never try to delete it!
-   return tsName;
-}
-
-/**
- * \brief   Group 0002 is always coded Little Endian
- *          whatever Transfer Syntax is
- * @return  no return
- */
-void Document::HandleOutOfGroup0002(uint16_t &group, uint16_t &elem)
-{
-   // Endian reversion. Some files contain groups of tags with reversed endianess.
-   if ( !Group0002Parsed && group != 0x0002)
-   {
-      Group0002Parsed = true;
-      // we just came out of group 0002
-      // if Transfer syntax is Big Endian we have to change CheckSwap
-
-      std::string ts = GetTransferSyntax();
-      if ( !Global::GetTS()->IsTransferSyntax(ts) )
-      {
-         gdcmVerboseMacro("True DICOM File, with NO Tansfer Syntax: " << ts );
-         return;
-      }
-
-      // FIXME Strangely, this works with 
-      //'Implicit VR Transfer Syntax (GE Private)
-      if ( Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRBigEndian )
-      {
-         gdcmVerboseMacro("Transfer Syntax Name = [" 
-                        << GetTransferSyntaxName() << "]" );
-         SwitchByteSwapCode();
-         group = SwapShort(group);
-         elem = SwapShort(elem);
-      }
-   }
-}
-
 /**
  * \brief   Read the next tag but WITHOUT loading it's value
  *          (read the 'Group Number', the 'Element Number',
@@ -2450,14 +1982,13 @@ DocEntry *Document::ReadNextDocEntry()
    {
       // We reached the EOF (or an error occured) therefore 
       // header parsing has to be considered as finished.
-      //std::cout << e;
       return 0;
    }
 
    // Sometimes file contains groups of tags with reversed endianess.
    HandleBrokenEndian(group, elem);
 
-// In 'true DICOM' files Group 0002 is always little endian
+   // In 'true DICOM' files Group 0002 is always little endian
    if ( HasDCMPreamble )
       HandleOutOfGroup0002(group, elem);
  
@@ -2490,7 +2021,7 @@ DocEntry *Document::ReadNextDocEntry()
             std::string msg;
             msg = Util::Format("Entry (%04x,%04x) should be Explicit VR\n", 
                           newEntry->GetGroup(), newEntry->GetElement());
-            gdcmVerboseMacro( msg.c_str() );
+            gdcmWarningMacro( msg.c_str() );
           }
       }
       newEntry->SetImplicitVR();
@@ -2513,484 +2044,77 @@ DocEntry *Document::ReadNextDocEntry()
    return newEntry;
 }
 
-
-/**
- * \brief   Generate a free TagKey i.e. a TagKey that is not present
- *          in the TagHt dictionary.
- * @param   group The generated tag must belong to this group.  
- * @return  The element of tag with given group which is fee.
- */
-uint32_t Document::GenerateFreeTagKeyInGroup(uint16_t group) 
-{
-   for (uint32_t elem = 0; elem < UINT32_MAX; elem++) 
-   {
-      TagKey key = DictEntry::TranslateToKey(group, elem);
-      if (TagHT.count(key) == 0)
-      {
-         return elem;
-      }
-   }
-   return UINT32_MAX;
-}
-
-/**
- * \brief   Assuming the internal file pointer \ref Document::Fp 
- *          is placed at the beginning of a tag check whether this
- *          tag is (TestGroup, TestElement).
- * \warning On success the internal file pointer \ref Document::Fp
- *          is modified to point after the tag.
- *          On failure (i.e. when the tag wasn't the expected tag
- *          (TestGroup, TestElement) the internal file pointer
- *          \ref Document::Fp is restored to it's original position.
- * @param   testGroup   The expected group of the tag.
- * @param   testElement The expected Element of the tag.
- * @return  True on success, false otherwise.
- */
-bool Document::ReadTag(uint16_t testGroup, uint16_t testElement)
-{
-   long positionOnEntry = Fp->tellg();
-   long currentPosition = Fp->tellg();          // On debugging purposes
-
-   //// Read the Item Tag group and element, and make
-   // sure they are what we expected:
-   uint16_t itemTagGroup;
-   uint16_t itemTagElement;
-   try
-   {
-      itemTagGroup   = ReadInt16();
-      itemTagElement = ReadInt16();
-   }
-   catch ( FormatError e )
-   {
-      //std::cerr << e << std::endl;
-      return false;
-   }
-   if ( itemTagGroup != testGroup || itemTagElement != testElement )
-   {
-      gdcmVerboseMacro( "Wrong Item Tag found:"
-       << "   We should have found tag ("
-       << std::hex << testGroup << "," << testElement << ")" << std::endl
-       << "   but instead we encountered tag ("
-       << std::hex << itemTagGroup << "," << itemTagElement << ")"
-       << "  at address: " << "  0x(" << (unsigned int)currentPosition  << ")" 
-       ) ;
-      Fp->seekg(positionOnEntry, std::ios::beg);
-
-      return false;
-   }
-   return true;
-}
-
-/**
- * \brief   Assuming the internal file pointer \ref Document::Fp 
- *          is placed at the beginning of a tag (TestGroup, TestElement),
- *          read the length associated to the Tag.
- * \warning On success the internal file pointer \ref Document::Fp
- *          is modified to point after the tag and it's length.
- *          On failure (i.e. when the tag wasn't the expected tag
- *          (TestGroup, TestElement) the internal file pointer
- *          \ref Document::Fp is restored to it's original position.
- * @param   testGroup   The expected group of the tag.
- * @param   testElement The expected Element of the tag.
- * @return  On success returns the length associated to the tag. On failure
- *          returns 0.
- */
-uint32_t Document::ReadTagLength(uint16_t testGroup, uint16_t testElement)
-{
-   long positionOnEntry = Fp->tellg();
-   (void)positionOnEntry;
-
-   if ( !ReadTag(testGroup, testElement) )
-   {
-      return 0;
-   }
-                                                                                
-   //// Then read the associated Item Length
-   long currentPosition = Fp->tellg();
-   uint32_t itemLength  = ReadInt32();
-   {
-      gdcmVerboseMacro( "Basic Item Length is: "
-        << itemLength << std::endl
-        << "  at address: " << std::hex << (unsigned int)currentPosition);
-   }
-   return itemLength;
-}
-
-/**
- * \brief When parsing the Pixel Data of an encapsulated file, read
- *        the basic offset table (when present, and BTW dump it).
- */
-void Document::ReadAndSkipEncapsulatedBasicOffsetTable()
-{
-   //// Read the Basic Offset Table Item Tag length...
-   uint32_t itemLength = ReadTagLength(0xfffe, 0xe000);
-
-   // When present, read the basic offset table itself.
-   // Notes: - since the presence of this basic offset table is optional
-   //          we can't rely on it for the implementation, and we will simply
-   //          trash it's content (when present).
-   //        - still, when present, we could add some further checks on the
-   //          lengths, but we won't bother with such fuses for the time being.
-   if ( itemLength != 0 )
-   {
-      char *basicOffsetTableItemValue = new char[itemLength + 1];
-      Fp->read(basicOffsetTableItemValue, itemLength);
-
-#ifdef GDCM_DEBUG
-      for (unsigned int i=0; i < itemLength; i += 4 )
-      {
-         uint32_t individualLength = str2num( &basicOffsetTableItemValue[i],
-                                              uint32_t);
-         gdcmVerboseMacro( "Read one length: " << 
-                          std::hex << individualLength );
-      }
-#endif //GDCM_DEBUG
-
-      delete[] basicOffsetTableItemValue;
-   }
-}
-
 /**
- * \brief Parse pixel data from disk of [multi-]fragment RLE encoding.
- *        Compute the RLE extra information and store it in \ref RLEInfo
- *        for later pixel retrieval usage.
+ * \brief   Handle broken private tag from Philips NTSCAN
+ *          where the endianess is being switch to BigEndian for no
+ *          apparent reason
+ * @return  no return
  */
-void Document::ComputeRLEInfo()
+void Document::HandleBrokenEndian(uint16_t &group, uint16_t &elem)
 {
-   std::string ts = GetTransferSyntax();
-   if ( !Global::GetTS()->IsRLELossless(ts) ) 
+   // Endian reversion. Some files contain groups of tags with reversed endianess.
+   static int reversedEndian = 0;
+   // try to fix endian switching in the middle of headers
+   if ((group == 0xfeff) && (elem == 0x00e0))
    {
-      return;
-   }
-
-   // Encoded pixel data: for the time being we are only concerned with
-   // Jpeg or RLE Pixel data encodings.
-   // As stated in PS 3.5-2003, section 8.2 p44:
-   // "If sent in Encapsulated Format (i.e. other than the Native Format) the
-   //  value representation OB is used".
-   // Hence we expect an OB value representation. Concerning OB VR,
-   // the section PS 3.5-2003, section A.4.c p 58-59, states:
-   // "For the Value Representations OB and OW, the encoding shall meet the
-   //   following specifications depending on the Data element tag:"
-   //   [...snip...]
-   //    - the first item in the sequence of items before the encoded pixel
-   //      data stream shall be basic offset table item. The basic offset table
-   //      item value, however, is not required to be present"
-
-   ReadAndSkipEncapsulatedBasicOffsetTable();
-
-   // Encapsulated RLE Compressed Images (see PS 3.5-2003, Annex G)
-   // Loop on the individual frame[s] and store the information
-   // on the RLE fragments in a RLEFramesInfo.
-   // Note: - when only a single frame is present, this is a
-   //         classical image.
-   //       - when more than one frame are present, then we are in 
-   //         the case of a multi-frame image.
-   long frameLength;
-   while ( (frameLength = ReadTagLength(0xfffe, 0xe000)) )
-   { 
-      // Parse the RLE Header and store the corresponding RLE Segment
-      // Offset Table information on fragments of this current Frame.
-      // Note that the fragment pixels themselves are not loaded
-      // (but just skipped).
-      long frameOffset = Fp->tellg();
-
-      uint32_t nbRleSegments = ReadInt32();
-      if ( nbRleSegments > 16 )
-      {
-         // There should be at most 15 segments (refer to RLEFrame class)
-         gdcmVerboseMacro( "Too many segments.");
-      }
-      uint32_t rleSegmentOffsetTable[16];
-      for( int k = 1; k <= 15; k++ )
-      {
-         rleSegmentOffsetTable[k] = ReadInt32();
-      }
-
-      // Deduce from both the RLE Header and the frameLength the
-      // fragment length, and again store this info in a
-      // RLEFramesInfo.
-      long rleSegmentLength[15];
-      // skipping (not reading) RLE Segments
-      if ( nbRleSegments > 1)
-      {
-         for(unsigned int k = 1; k <= nbRleSegments-1; k++)
-         {
-             rleSegmentLength[k] =  rleSegmentOffsetTable[k+1]
-                                  - rleSegmentOffsetTable[k];
-             SkipBytes(rleSegmentLength[k]);
-          }
-       }
-
-       rleSegmentLength[nbRleSegments] = frameLength 
-                                      - rleSegmentOffsetTable[nbRleSegments];
-       SkipBytes(rleSegmentLength[nbRleSegments]);
-
-       // Store the collected info
-       RLEFrame *newFrameInfo = new RLEFrame;
-       newFrameInfo->NumberFragments = nbRleSegments;
-       for( unsigned int uk = 1; uk <= nbRleSegments; uk++ )
-       {
-          newFrameInfo->Offset[uk] = frameOffset + rleSegmentOffsetTable[uk];
-          newFrameInfo->Length[uk] = rleSegmentLength[uk];
-       }
-       RLEInfo->Frames.push_back( newFrameInfo );
-   }
-
-   // Make sure that at the end of the item we encounter a 'Sequence
-   // Delimiter Item':
-   if ( !ReadTag(0xfffe, 0xe0dd) )
+     // start endian swap mark for group found
+     reversedEndian++;
+     SwitchByteSwapCode();
+     // fix the tag
+     group = 0xfffe;
+     elem  = 0xe000;
+   } 
+   else if (group == 0xfffe && elem == 0xe00d && reversedEndian) 
    {
-      gdcmVerboseMacro( "No sequence delimiter item at end of RLE item sequence");
+     // end of reversed endian group
+     reversedEndian--;
+     SwitchByteSwapCode();
    }
 }
 
 /**
- * \brief Parse pixel data from disk of [multi-]fragment Jpeg encoding.
- *        Compute the jpeg extra information (fragment[s] offset[s] and
- *        length) and store it[them] in \ref JPEGInfo for later pixel
- *        retrieval usage.
+ * \brief   Group 0002 is always coded Little Endian
+ *          whatever Transfer Syntax is
+ * @return  no return
  */
-void Document::ComputeJPEGFragmentInfo()
+void Document::HandleOutOfGroup0002(uint16_t &group, uint16_t &elem)
 {
-   // If you need to, look for comments of ComputeRLEInfo().
-   std::string ts = GetTransferSyntax();
-   if ( ! Global::GetTS()->IsJPEG(ts) )
-   {
-      return;
-   }
-
-   ReadAndSkipEncapsulatedBasicOffsetTable();
-
-   // Loop on the fragments[s] and store the parsed information in a
-   // JPEGInfo.
-   long fragmentLength;
-   while ( (fragmentLength = ReadTagLength(0xfffe, 0xe000)) )
-   { 
-      long fragmentOffset = Fp->tellg();
-
-       // Store the collected info
-       JPEGFragment *newFragment = new JPEGFragment;
-       newFragment->Offset = fragmentOffset;
-       newFragment->Length = fragmentLength;
-       JPEGInfo->Fragments.push_back( newFragment );
-
-       SkipBytes( fragmentLength );
-   }
-
-   // Make sure that at the end of the item we encounter a 'Sequence
-   // Delimiter Item':
-   if ( !ReadTag(0xfffe, 0xe0dd) )
+   // Endian reversion. Some files contain groups of tags with reversed endianess.
+   if ( !Group0002Parsed && group != 0x0002)
    {
-      gdcmVerboseMacro( "No sequence delimiter item at end of JPEG item sequence");
-   }
-}
-
-/**
- * \brief Walk recursively the given \ref DocEntrySet, and feed
- *        the given hash table (\ref TagDocEntryHT) with all the
- *        \ref DocEntry (Dicom entries) encountered.
- *        This method does the job for \ref BuildFlatHashTable.
- * @param builtHT Where to collect all the \ref DocEntry encountered
- *        when recursively walking the given set.
- * @param set The structure to be traversed (recursively).
- */
-void Document::BuildFlatHashTableRecurse( TagDocEntryHT &builtHT,
-                                          DocEntrySet *set )
-{ 
-   if (ElementSet *elementSet = dynamic_cast< ElementSet* > ( set ) )
-   {
-      TagDocEntryHT const &currentHT = elementSet->GetTagHT();
-      for( TagDocEntryHT::const_iterator i  = currentHT.begin();
-                                         i != currentHT.end();
-                                       ++i)
-      {
-         DocEntry *entry = i->second;
-         if ( SeqEntry *seqEntry = dynamic_cast<SeqEntry*>(entry) )
-         {
-            const ListSQItem& items = seqEntry->GetSQItems();
-            for( ListSQItem::const_iterator item  = items.begin();
-                                            item != items.end();
-                                          ++item)
-            {
-               BuildFlatHashTableRecurse( builtHT, *item );
-            }
-            continue;
-         }
-         builtHT[entry->GetKey()] = entry;
-      }
-      return;
-    }
+      Group0002Parsed = true;
+      // we just came out of group 0002
+      // if Transfer syntax is Big Endian we have to change CheckSwap
 
-   if (SQItem *SQItemSet = dynamic_cast< SQItem* > ( set ) )
-   {
-      const ListDocEntry& currentList = SQItemSet->GetDocEntries();
-      for (ListDocEntry::const_iterator i  = currentList.begin();
-                                        i != currentList.end();
-                                      ++i)
+      std::string ts = GetTransferSyntax();
+      if ( !Global::GetTS()->IsTransferSyntax(ts) )
       {
-         DocEntry *entry = *i;
-         if ( SeqEntry *seqEntry = dynamic_cast<SeqEntry*>(entry) )
-         {
-            const ListSQItem& items = seqEntry->GetSQItems();
-            for( ListSQItem::const_iterator item  = items.begin();
-                                            item != items.end();
-                                          ++item)
-            {
-               BuildFlatHashTableRecurse( builtHT, *item );
-            }
-            continue;
-         }
-         builtHT[entry->GetKey()] = entry;
+         gdcmWarningMacro("True DICOM File, with NO Tansfer Syntax: " << ts );
+         return;
       }
 
-   }
-}
-
-/**
- * \brief Build a \ref TagDocEntryHT (i.e. a std::map<>) from the current
- *        Document.
- *
- *        The structure used by a Document (through \ref ElementSet),
- *        in order to hold the parsed entries of a Dicom header, is a recursive
- *        one. This is due to the fact that the sequences (when present)
- *        can be nested. Additionaly, the sequence items (represented in
- *        gdcm as \ref SQItem) add an extra complexity to the data
- *        structure. Hence, a gdcm user whishing to visit all the entries of
- *        a Dicom header will need to dig in the gdcm internals (which
- *        implies exposing all the internal data structures to the API).
- *        In order to avoid this burden to the user, \ref BuildFlatHashTable
- *        recursively builds a temporary hash table, which holds all the
- *        Dicom entries in a flat structure (a \ref TagDocEntryHT i.e. a
- *        std::map<>).
- * \warning Of course there is NO integrity constrain between the 
- *        returned \ref TagDocEntryHT and the \ref ElementSet used
- *        to build it. Hence if the underlying \ref ElementSet is
- *        altered, then it is the caller responsability to invoke 
- *        \ref BuildFlatHashTable again...
- * @return The flat std::map<> we juste build.
- */
-TagDocEntryHT *Document::BuildFlatHashTable()
-{
-   TagDocEntryHT *FlatHT = new TagDocEntryHT;
-   BuildFlatHashTableRecurse( *FlatHT, this );
-   return FlatHT;
-}
-
-
+      // Group 0002 is always 'Explicit ...' enven when Transfer Syntax says 'Implicit ..." 
 
-/**
- * \brief   Compares two documents, according to \ref DicomDir rules
- * \warning Does NOT work with ACR-NEMA files
- * \todo    Find a trick to solve the pb (use RET fields ?)
- * @param   document
- * @return  true if 'smaller'
- */
-bool Document::operator<(Document &document)
-{
-   // Patient Name
-   std::string s1 = GetEntry(0x0010,0x0010);
-   std::string s2 = document.GetEntry(0x0010,0x0010);
-   if(s1 < s2)
-   {
-      return true;
-   }
-   else if( s1 > s2 )
-   {
-      return false;
-   }
-   else
-   {
-      // Patient ID
-      s1 = GetEntry(0x0010,0x0020);
-      s2 = document.GetEntry(0x0010,0x0020);
-      if ( s1 < s2 )
-      {
-         return true;
-      }
-      else if ( s1 > s2 )
-      {
-         return false;
-      }
-      else
-      {
-         // Study Instance UID
-         s1 = GetEntry(0x0020,0x000d);
-         s2 = document.GetEntry(0x0020,0x000d);
-         if ( s1 < s2 )
+      if ( Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRLittleEndian )
          {
-            return true;
-         }
-         else if( s1 > s2 )
-         {
-            return false;
-         }
-         else
-         {
-            // Serie Instance UID
-            s1 = GetEntry(0x0020,0x000e);
-            s2 = document.GetEntry(0x0020,0x000e);    
-            if ( s1 < s2 )
-            {
-               return true;
-            }
-            else if( s1 > s2 )
-            {
-               return false;
-            }
+            Filetype = ImplicitVR;
          }
-      }
-   }
-   return false;
-}
-
-
-/**
- * \brief   Re-computes the length of a ACR-NEMA/Dicom group from a DcmHeader
- * @param filetype Type of the File to be written 
- */
-int Document::ComputeGroup0002Length( FileType filetype ) 
-{
-   uint16_t gr, el;
-   std::string vr;
-   
-   int groupLength = 0;
-   bool found0002 = false;   
-  
-   // for each zero-level Tag in the DCM Header
-   DocEntry *entry;
-
-   Initialize();
-   entry = GetNextEntry();
-   while(entry)
-   {
-      gr = entry->GetGroup();
-
-      if (gr == 0x0002)
+       
+      // FIXME Strangely, this works with 
+      //'Implicit VR Transfer Syntax (GE Private)
+      if ( Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRBigEndian )
       {
-         found0002 = true;
-
-         el = entry->GetElement();
-         vr = entry->GetVR();            
-         if (filetype == ExplicitVR) 
-         {
-            if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") ) 
-            {
-               groupLength +=  4; // explicit VR AND OB, OW, SQ : 4 more bytes
-            }
-         }
-         groupLength += 2 + 2 + 4 + entry->GetLength();   
+         gdcmWarningMacro("Transfer Syntax Name = [" 
+                        << GetTransferSyntaxName() << "]" );
+         SwitchByteSwapCode();
+         group = SwapShort(group);
+         elem  = SwapShort(elem);
       }
-      else if (found0002 )
-         break;
-
-      entry = GetNextEntry();
    }
-   return groupLength; 
 }
 
-} // end namespace gdcm
+//-----------------------------------------------------------------------------
+// Print
 
 //-----------------------------------------------------------------------------
+} // end namespace gdcm