X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmParser.cxx;h=332b415adc257c92d47d68a429b73744bb9bf236;hb=645dacff6426c762be09138f66b4cfb2d8d47b18;hp=ec1dcb9f06b7d4dcc2085e97aa9fdc7a2689f7e8;hpb=65467b71ee500909b0ef7c31d442ca0c160d6a15;p=gdcm.git

diff --git a/src/gdcmParser.cxx b/src/gdcmParser.cxx
index ec1dcb9f..332b415a 100644
--- a/src/gdcmParser.cxx
+++ b/src/gdcmParser.cxx
@@ -1,8 +1,15 @@
-// gdcmHeader.cxx
+// gdcmParser.cxx
 //-----------------------------------------------------------------------------
+//#define UINT32_MAX    (4294967295U)
+
+
 #include "gdcmParser.h"
+#include "gdcmGlobal.h"
 #include "gdcmUtil.h"
+#include "gdcmDebug.h"
+
 #include <errno.h>
+#include <vector>
 
 // For nthos:
 #ifdef _MSC_VER
@@ -11,76 +18,84 @@
    #include <netinet/in.h>
 #endif
 
-#ifdef GDCM_NO_ANSI_STRING_STREAM
-#  include <strstream>
-#  define  ostringstream ostrstream
-# else
-#  include <sstream>
-#endif
+#  include <iomanip>
+
+#define UI1_2_840_10008_1_2      "1.2.840.10008.1.2"
+#define UI1_2_840_10008_1_2_1    "1.2.840.10008.1.2.1"
+#define UI1_2_840_10008_1_2_2    "1.2.840.10008.1.2.2"
+#define UI1_2_840_10008_1_2_1_99 "1.2.840.10008.1.2.1.99"
+
+typedef struct {
+   guint32 totalSQlength;
+   guint32 alreadyParsedlength;
+} pileElem;
 
 //-----------------------------------------------------------------------------
 // Refer to gdcmParser::CheckSwap()
 const unsigned int gdcmParser::HEADER_LENGTH_TO_READ = 256;
 
-// Refer to gdcmParser::SetMaxSizeLoadElementValue()
+// Refer to gdcmParser::SetMaxSizeLoadEntry()
 const unsigned int gdcmParser::MAX_SIZE_LOAD_ELEMENT_VALUE = 4096;
 
+const unsigned int gdcmParser::MAX_SIZE_PRINT_ELEMENT_VALUE = 64;
+
 //-----------------------------------------------------------------------------
 // Constructor / Destructor
+
 /**
- * \ingroup gdcmParser
- * \brief   
- * @param   InFilename
- * @param   exception_on_error
+ * \brief   constructor  
+ * @param   inFilename file to be opened for parsing
+ * @param   exception_on_error whether we throw an exception or not
  * @param   enable_sequences = true to allow the header 
- *          to be parsed *inside* the SeQuences, 
+ *          to be parsed *inside* the SeQuences,
  *          when they have an actual length 
- *\TODO    may be we need one more bool, 
- *         to allow skipping the private elements while parsing the header
- *         in order to save space	  
- */
-gdcmParser::gdcmParser(const char *InFilename, 
+ * \warning enable_sequences *has to be* true for reading PAPYRUS 3.0 files 
+ * @param   ignore_shadow to allow skipping the shadow elements, 
+ *          to save memory space.
+ * \warning The TRUE value for this param has to be used 
+ *          with a FALSE value for the 'enable_sequence' param.
+ *          ('public elements' may be embedded in 'shadow Sequences')
+ */
+gdcmParser::gdcmParser(const char *inFilename, 
                        bool exception_on_error,
-                       bool enable_sequences ) 
-{
+                       bool enable_sequences,
+                       bool ignore_shadow) {
    enableSequences=enable_sequences;
+   ignoreShadow   =ignore_shadow;
    
-   SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
-   filename = InFilename;
+   SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE); 
+   filename = inFilename;
    Initialise();
 
    if ( !OpenFile(exception_on_error))
       return;
-   Parse();
-   LoadHeaderEntries();
+
+   LoadHeaderEntries();   
    CloseFile();
 
    wasUpdated = 0;  // will be set to 1 if user adds an entry
-   printLevel = 1;  // 'Heavy' header print by default
+   printLevel = 1;  // 'Medium' print level by default
 }
 
 /**
- * \ingroup gdcmParser
- * \brief   
+ * \brief  constructor 
  * @param   exception_on_error
  */
-gdcmParser::gdcmParser(bool exception_on_error) 
-{
+gdcmParser::gdcmParser(bool exception_on_error) {
+	(void)exception_on_error;
    enableSequences=0;
 
    SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
    Initialise();
 
    wasUpdated = 0;  // will be set to 1 if user adds an entry
-   printLevel = 1;  // 'Heavy' header print by default
+   printLevel = 1;  // 'Medium' print level by default
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Canonical destructor.
  */
-gdcmParser::~gdcmParser (void) 
-{
+gdcmParser::~gdcmParser (void) {
    RefPubDict = NULL;
    RefShaDict = NULL;
 }
@@ -88,90 +103,73 @@ gdcmParser::~gdcmParser (void)
 //-----------------------------------------------------------------------------
 // Print
 /**
-  * \ingroup gdcmParser
   * \brief   Prints the Header Entries (Dicom Elements)
-  *          both from the H Table and the chained list
+  *          from the chained list
   * @return
   */ 
-void gdcmParser::PrintPubEntry(std::ostream & os) 
-{
-   std::ostringstream s;   
-	   
-   s << "------------ using listEntries ----------------" << std::endl; 
+void gdcmParser::PrintEntry(std::ostream & os) {
+
    for (ListTag::iterator i = listEntries.begin();  
-	   i != listEntries.end();
-	   ++i)
+        i != listEntries.end();
+        ++i)
    {
-	   (*i)->SetPrintLevel(printLevel);
-	   (*i)->Print(os);   
+      (*i)->SetPrintLevel(printLevel);
+      (*i)->Print(os);   
    } 
-   os<<s.str();
 }
 
+
 /**
-  * \ingroup gdcmParser
-  * \brief   Prints The Dict Entries of THE public Dicom Dictionnry
+  * \brief   Prints The Dict Entries of THE public Dicom Dictionary
   * @return
   */  
-void gdcmParser::PrintPubDict(std::ostream & os) 
-{
+void gdcmParser::PrintPubDict(std::ostream & os) {
    RefPubDict->Print(os);
 }
 
 /**
-  * \ingroup gdcmParser
-  * \brief   Prints The Dict Entries of THE shadow Dicom Dictionnry
+  * \brief   Prints The Dict Entries of THE shadow Dicom Dictionary
   * @return
   */
-void gdcmParser::PrintShaDict(std::ostream & os) 
-{
+void gdcmParser::PrintShaDict(std::ostream & os) {
    RefShaDict->Print(os);
 }
 
 //-----------------------------------------------------------------------------
 // Public
 /**
- * \ingroup gdcmParser
  * \brief   Get the public dictionary used
  */
-gdcmDict *gdcmParser::GetPubDict(void)
-{
+gdcmDict *gdcmParser::GetPubDict(void) {
    return(RefPubDict);
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Get the shadow dictionary used
  */
-gdcmDict *gdcmParser::GetShaDict(void)
-{
+gdcmDict *gdcmParser::GetShaDict(void) {
    return(RefShaDict);
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Set the shadow dictionary used
  * \param   dict dictionary to use in shadow
  */
-bool gdcmParser::SetShaDict(gdcmDict *dict)
-{
+bool gdcmParser::SetShaDict(gdcmDict *dict){
    RefShaDict=dict;
    return(!RefShaDict);
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Set the shadow dictionary used
  * \param   dictName name of the dictionary to use in shadow
  */
-bool gdcmParser::SetShaDict(DictKey dictName)
-{
+bool gdcmParser::SetShaDict(DictKey dictName){
    RefShaDict=gdcmGlobal::GetDicts()->GetDict(dictName);
    return(!RefShaDict);
 }
 
 /**
- * \ingroup gdcmParser
  * \brief  This predicate, based on hopefully reasonable heuristics,
  *         decides whether or not the current gdcmParser was properly parsed
  *         and contains the mandatory information for being considered as
@@ -179,117 +177,95 @@ bool gdcmParser::SetShaDict(DictKey dictName)
  * @return true when gdcmParser is the one of a reasonable Dicom/Acr file,
  *         false otherwise. 
  */
-bool gdcmParser::IsReadable(void) 
-{
-   std::string res = GetEntryByNumber(0x0028, 0x0005);
-   if ( res != GDCM_UNFOUND && atoi(res.c_str()) > 4 ) 
-   {
-      return false; // Image Dimensions
+bool gdcmParser::IsReadable(void) { 
+	if(filetype==gdcmUnknown) {
+      return(false);
+   }
+   if(listEntries.size()<=0) {    
+      return(false);
    }
 
-   if ( !GetHeaderEntryByNumber(0x0028, 0x0100) )
-      return false; // "Bits Allocated"
-   if ( !GetHeaderEntryByNumber(0x0028, 0x0101) )
-      return false; // "Bits Stored"
-   if ( !GetHeaderEntryByNumber(0x0028, 0x0102) )
-      return false; // "High Bit"
-   if ( !GetHeaderEntryByNumber(0x0028, 0x0103) )
-      return false; // "Pixel Representation"
-   return true;
+   return(true);
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Determines if the Transfer Syntax was already encountered
  *          and if it corresponds to a ImplicitVRLittleEndian one.
- *
  * @return  True when ImplicitVRLittleEndian found. False in all other cases.
  */
-bool gdcmParser::IsImplicitVRLittleEndianTransferSyntax(void) 
-{
+bool gdcmParser::IsImplicitVRLittleEndianTransferSyntax(void) {
    gdcmHeaderEntry *Element = GetHeaderEntryByNumber(0x0002, 0x0010);
    if ( !Element )
       return false;
    LoadHeaderEntrySafe(Element);
 
    std::string Transfer = Element->GetValue();
-   if ( Transfer == "1.2.840.10008.1.2" )
+   if ( Transfer == UI1_2_840_10008_1_2 )
       return true;
    return false;
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Determines if the Transfer Syntax was already encountered
  *          and if it corresponds to a ExplicitVRLittleEndian one.
- *
  * @return  True when ExplicitVRLittleEndian found. False in all other cases.
  */
-bool gdcmParser::IsExplicitVRLittleEndianTransferSyntax(void) 
-{
+bool gdcmParser::IsExplicitVRLittleEndianTransferSyntax(void) {
    gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010);
    if ( !Element )
       return false;
    LoadHeaderEntrySafe(Element);
 
    std::string Transfer = Element->GetValue();
-   if ( Transfer == "1.2.840.10008.1.2.1" )
+   if ( Transfer == UI1_2_840_10008_1_2_1 )
       return true;
    return false;
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Determines if the Transfer Syntax was already encountered
  *          and if it corresponds to a DeflatedExplicitVRLittleEndian one.
- *
  * @return  True when DeflatedExplicitVRLittleEndian found. False in all other cases.
  */
-bool gdcmParser::IsDeflatedExplicitVRLittleEndianTransferSyntax(void) 
-{
+bool gdcmParser::IsDeflatedExplicitVRLittleEndianTransferSyntax(void) {
    gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010);
    if ( !Element )
       return false;
    LoadHeaderEntrySafe(Element);
 
    std::string Transfer = Element->GetValue();
-   if ( Transfer == "1.2.840.10008.1.2.1.99" )
+   if ( Transfer == UI1_2_840_10008_1_2_1_99 )
       return true;
    return false;
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Determines if the Transfer Syntax was already encountered
  *          and if it corresponds to a Explicit VR Big Endian one.
- *
  * @return  True when big endian found. False in all other cases.
  */
-bool gdcmParser::IsExplicitVRBigEndianTransferSyntax(void) 
-{
+bool gdcmParser::IsExplicitVRBigEndianTransferSyntax(void) {
    gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010);
    if ( !Element )
       return false;
    LoadHeaderEntrySafe(Element);
 
    std::string Transfer = Element->GetValue();
-   if ( Transfer == "1.2.840.10008.1.2.2" )  //1.2.2 ??? A verifier !
+   if ( Transfer == UI1_2_840_10008_1_2_2 )  //1.2.2 ??? A verifier !
       return true;
    return false;
 }
 
 /**
- * \ingroup gdcmParser
  * \brief  returns the File Type 
- *         (ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown)
- * @return 
+ *         (ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unfound)
+ * @return the FileType code
  */
 FileType gdcmParser::GetFileType(void) {
    return(filetype);
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   opens the file
  * @param   exception_on_error
  * @return  
@@ -321,22 +297,19 @@ FILE *gdcmParser::OpenFile(bool exception_on_error)
        return(fp);
 
     fclose(fp);
-    dbg.Verbose(0, "gdcmParser::gdcmParser not DICOM/ACR", filename.c_str());
+    dbg.Verbose(0, "gdcmParser::OpenFile not DICOM/ACR", filename.c_str());
   }
   else {
-    std::cerr<<filename.c_str()<<std::endl;
-    dbg.Verbose(0, "gdcmParser::gdcmParser cannot open file", filename.c_str());
+    dbg.Verbose(0, "gdcmParser::OpenFile cannot open file", filename.c_str());
   }
   return(NULL);
 }
 
 /**
- * \ingroup gdcmParser
  * \brief closes the file  
  * @return  TRUE if the close was successfull 
  */
-bool gdcmParser::CloseFile(void) 
-{
+bool gdcmParser::CloseFile(void) {
   int closed = fclose(fp);
   fp = (FILE *)0;
   if (! closed)
@@ -345,148 +318,135 @@ bool gdcmParser::CloseFile(void)
 }
 
 /**
- * \ingroup gdcmParser
- * \brief 
+ * \brief Writes in a file all the Header Entries (Dicom Elements) 
+ *        of the Chained List
  * @param fp file pointer on an already open file
- * @param   type type of the File to be written 
+ * @param type Type of the File to be written 
  *          (ACR-NEMA, ExplicitVR, ImplicitVR)
- * @return  always "True" ?!
- */
-bool gdcmParser::Write(FILE *fp, FileType type) 
-{
-// ==============
-// TODO The stuff has been rewritten using the chained list instead 
-//      of the H table
-//      so we could remove the GroupHT from the gdcmParser
-// To be checked
-// =============
-
-   // TODO : move the following lines (and a lot of others, to be written)
-   // to a future function CheckAndCorrectHeader
+ * \return Always true.
+ */
+bool gdcmParser::Write(FILE *fp, FileType type) {
+/// \todo
+///  ==============
+///      The stuff will have to be rewritten using the SeQuence based 
+///       tree-like stucture instead  of the chained list .
+///      (so we shall remove the GroupHT from the gdcmParser)
+///      To be checked
+/// =============
+
+   /// \todo move the following lines (and a lot of others, to be written)
+   /// to a future function CheckAndCorrectHeader
    
-   	// Question :
-	// Comment pourrait-on savoir si le DcmHeader vient d'un fichier DicomV3 ou non
-	// (FileType est un champ de gdcmParser ...)
-	// WARNING : Si on veut ecrire du DICOM V3 a partir d'un DcmHeader ACR-NEMA
-	// no way 
-        // a moins de se livrer a un tres complique ajout des champs manquants.
-        // faire un CheckAndCorrectHeader (?)  
-	 
-
-   if (type == ImplicitVR) 
+   /// \todo
+   /// Question :
+   /// Comment pourrait-on savoir si le DcmHeader vient d'un fichier
+   /// DicomV3 ou non (FileType est un champ de gdcmParser ...)
+   /// WARNING : Si on veut ecrire du DICOM V3 a partir d'un DcmHeader ACR-NEMA
+   /// no way 
+   /// a moins de se livrer a un tres complique ajout des champs manquants.
+   /// faire un CheckAndCorrectHeader (?)  
+
+   if (type == gdcmImplicitVR) 
    {
-      std::string implicitVRTransfertSyntax = "1.2.840.10008.1.2";
+      std::string implicitVRTransfertSyntax = UI1_2_840_10008_1_2;
       ReplaceOrCreateByNumber(implicitVRTransfertSyntax,0x0002, 0x0010);
       
-      //FIXME Refer to standards on page 21, chapter 6.2 "Value representation":
-      //      values with a VR of UI shall be padded with a single trailing null
-      //      Dans le cas suivant on doit pader manuellement avec un 0
+      /// \todo Refer to standards on page 21, chapter 6.2
+      ///       "Value representation": values with a VR of UI shall be
+      ///       padded with a single trailing null
+      ///       Dans le cas suivant on doit pader manuellement avec un 0
       
       SetEntryLengthByNumber(18, 0x0002, 0x0010);
    } 
 
-   if (type == ExplicitVR) 
+   if (type == gdcmExplicitVR) 
    {
-      std::string explicitVRTransfertSyntax = "1.2.840.10008.1.2.1";
+      std::string explicitVRTransfertSyntax = UI1_2_840_10008_1_2_1;
       ReplaceOrCreateByNumber(explicitVRTransfertSyntax,0x0002, 0x0010);
       
-      //FIXME Refer to standards on page 21, chapter 6.2 "Value representation":
-      //      values with a VR of UI shall be padded with a single trailing null
-      //      Dans le cas suivant on doit pader manuellement avec un 0
+      /// \todo Refer to standards on page 21, chapter 6.2
+      ///       "Value representation": values with a VR of UI shall be
+      ///       padded with a single trailing null
+      ///       Dans le cas suivant on doit pader manuellement avec un 0
       
       SetEntryLengthByNumber(20, 0x0002, 0x0010);
    }
 
+/**
+ * \todo rewrite later, if really usefull
+ *
+ *       --> Warning : un-updated odd groups lengths can causes pb 
+ *       -->           (xmedcon breaks)
+ *       --> to be re- written with future org.
+ *
+ * if ( (type == ImplicitVR) || (type == ExplicitVR) )
+ *    UpdateGroupLength(false,type);
+ * if ( type == ACR)
+ *    UpdateGroupLength(true,ACR);
+ */
 
-   if ( (type == ImplicitVR) || (type == ExplicitVR) )
-      UpdateGroupLength(false,type);
-   if ( type == ACR)
-      UpdateGroupLength(true,ACR);
-
-   WriteEntries(type, fp);
+   WriteEntries(fp,type);
    return(true);
- }
+}
 
 /**
- * \ingroup gdcmParser
  * \brief   Modifies the value of a given Header Entry (Dicom Element)
- *          if it exists; Creates it with the given value if it doesn't
- * @param   Value passed as a std::string
- * @param   Group
- * @param   Elem
- * \return  boolean
- */
-bool gdcmParser::ReplaceOrCreateByNumber(std::string Value, 
-                                        guint16 Group, guint16 Elem ) 
-{
-   if (CheckIfEntryExistByNumber(Group, Elem) == 0) {
-      gdcmHeaderEntry *a =NewHeaderEntryByNumber(Group, Elem);
+ *          when it exists. Create it with the given value when unexistant.
+ * \warning Adds the Header Entry to the HTable, NOT to the chained List
+ * @param   Value Value to be set
+ * @param   Group Group of the Entry 
+ * @param   Elem  Element of the Entry
+ * \return  pointer to the modified/created Header Entry (NULL when creation
+ *          failed).
+ */
+gdcmHeaderEntry * gdcmParser::ReplaceOrCreateByNumber(
+                                         std::string Value, 
+                                         guint16 Group, 
+                                         guint16 Elem ){
+   gdcmHeaderEntry* a;
+   a = GetHeaderEntryByNumber( Group, Elem);
+   if (a == NULL) {
+      a =NewHeaderEntryByNumber(Group, Elem);
       if (a == NULL) 
-         return false;
+         return NULL;
       AddHeaderEntry(a);
    }   
-   SetEntryByNumber(Value, Group, Elem);
-   return(true);
+   //CLEANME SetEntryByNumber(Value, Group, Elem);
+   a->SetValue(Value);
+   return(a);
 }   
 
 /**
- * \ingroup gdcmParser
- * \brief   Modifies the value of a given Header Entry (Dicom Element)
- *          if it exists; Creates it with the given value if it doesn't
- * @param   Value passed as a char*
- * @param   Group
- * @param   Elem
- * \return  boolean 
- * 
- */
-bool gdcmParser::ReplaceOrCreateByNumber(char* Value, guint16 Group, guint16 Elem ) 
-{
-   gdcmHeaderEntry* nvHeaderEntry=NewHeaderEntryByNumber(Group, Elem);
-
-   if(!nvHeaderEntry)
-      return(false);
-
-   AddHeaderEntry(nvHeaderEntry);
-
-   std::string v = Value;	
-   SetEntryByNumber(v, Group, Elem);
-   return(true);
-}  
-
-/**
- * \ingroup gdcmParser
- * \brief   Set a new value if the invoked element exists
- *          Seems to be useless !!!
- * @param   Value
- * @param   Group
- * @param   Elem
+ * \brief Set a new value if the invoked element exists
+ *        Seems to be useless !!!
+ * @param Value new element value
+ * @param Group   group of the Entry 
+ * @param Elem element of the Entry
  * \return  boolean 
  */
 bool gdcmParser::ReplaceIfExistByNumber(char* Value, guint16 Group, guint16 Elem ) 
 {
-   std::string v = Value;	
+   std::string v = Value;
    SetEntryByNumber(v, Group, Elem);
    return true;
 } 
 
 //-----------------------------------------------------------------------------
 // Protected
+
 /**
- * \ingroup gdcmParser
  * \brief   Checks if a given Dicom Element exists
- * \        within the H table
+ *          within the H table
  * @param   group Group   number of the searched Dicom Element 
  * @param   element  Element number of the searched Dicom Element 
  * @return  number of occurences
  */
-int gdcmParser::CheckIfEntryExistByNumber(guint16 group, guint16 element ) 
-{
-	std::string key = gdcmDictEntry::TranslateToKey(group, element );
-	return (tagHT.count(key));
+int gdcmParser::CheckIfEntryExistByNumber(guint16 group, guint16 element ) {
+   std::string key = gdcmDictEntry::TranslateToKey(group, element );
+   return (tagHT.count(key));
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Searches within Header Entries (Dicom Elements) parsed with 
  *          the public and private dictionaries 
  *          for the element value of a given tag.
@@ -495,8 +455,7 @@ int gdcmParser::CheckIfEntryExistByNumber(guint16 group, guint16 element )
  * @return  Corresponding element value when it exists,
  *          and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
  */
-std::string gdcmParser::GetEntryByName(std::string tagName) 
-{
+std::string gdcmParser::GetEntryByName(std::string tagName) {
    gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName); 
    if( dictEntry == NULL)
       return GDCM_UNFOUND;
@@ -505,7 +464,6 @@ std::string gdcmParser::GetEntryByName(std::string tagName)
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Searches within Header Entries (Dicom Elements) parsed with 
  *          the public and private dictionaries 
  *          for the element value representation of a given tag.
@@ -518,19 +476,18 @@ std::string gdcmParser::GetEntryByName(std::string tagName)
  * @return  Corresponding element value representation when it exists,
  *          and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
  */
-std::string gdcmParser::GetEntryVRByName(std::string tagName) 
-{
+std::string gdcmParser::GetEntryVRByName(std::string tagName) {
    gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName); 
    if( dictEntry == NULL)
       return GDCM_UNFOUND;
 
    gdcmHeaderEntry* elem =  GetHeaderEntryByNumber(dictEntry->GetGroup(),
-                                                   dictEntry->GetElement());					
+                                                   dictEntry->GetElement());
    return elem->GetVR();
 }
 
+
 /**
- * \ingroup gdcmParser
  * \brief   Searches within Header Entries (Dicom Elements) parsed with 
  *          the public and private dictionaries 
  *          for the element value representation of a given tag.
@@ -539,8 +496,7 @@ std::string gdcmParser::GetEntryVRByName(std::string tagName)
  * @return  Corresponding element value representation when it exists,
  *          and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
  */
-std::string gdcmParser::GetEntryByNumber(guint16 group, guint16 element) 
-{
+std::string gdcmParser::GetEntryByNumber(guint16 group, guint16 element){
    TagKey key = gdcmDictEntry::TranslateToKey(group, element);
    if ( ! tagHT.count(key))
       return GDCM_UNFOUND;
@@ -548,7 +504,6 @@ std::string gdcmParser::GetEntryByNumber(guint16 group, guint16 element)
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Searches within Header Entries (Dicom Elements) parsed with 
  *          the public and private dictionaries 
  *          for the element value representation of a given tag..
@@ -562,8 +517,7 @@ std::string gdcmParser::GetEntryByNumber(guint16 group, guint16 element)
  * @return  Corresponding element value representation when it exists,
  *          and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
  */
-std::string gdcmParser::GetEntryVRByNumber(guint16 group, guint16 element) 
-{
+std::string gdcmParser::GetEntryVRByNumber(guint16 group, guint16 element) {
    gdcmHeaderEntry* elem =  GetHeaderEntryByNumber(group, element);
    if ( !elem )
       return GDCM_UNFOUND;
@@ -571,24 +525,35 @@ std::string gdcmParser::GetEntryVRByNumber(guint16 group, guint16 element)
 }
 
 /**
- * \ingroup gdcmParser
+ * \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 of the searched tag.
+ * @param   element Element of the searched tag.
+ * @return  Corresponding element length; -2 if not found
+ */
+int gdcmParser::GetEntryLengthByNumber(guint16 group, guint16 element) {
+   gdcmHeaderEntry* elem =  GetHeaderEntryByNumber(group, element);
+   if ( !elem )
+      return -2;
+   return elem->GetLength();
+}
+/**
  * \brief   Sets the value (string) of the Header Entry (Dicom Element)
  * @param   content string value of the Dicom Element
  * @param   tagName name of the searched Dicom Element.
  * @return  true when found
  */
-bool gdcmParser::SetEntryByName(std::string content,std::string tagName) 
-{
+bool gdcmParser::SetEntryByName(std::string content,std::string tagName) {
    gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName); 
    if( dictEntry == NULL)
-      return false;				    
+      return false;    
 
    return(SetEntryByNumber(content,dictEntry->GetGroup(),
                                    dictEntry->GetElement()));
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Accesses an existing gdcmHeaderEntry (i.e. a Dicom Element)
  *          through it's (group, element) and modifies it's content with
  *          the given value.
@@ -605,13 +570,12 @@ bool gdcmParser::SetEntryByNumber(std::string content,
    if ( ! tagHT.count(key))
       return false;
    int l = content.length();
-   if(l%2) // Odd length are padded with a space (020H).
+   if(l%2) // Non even length are padded with a space (020H).
    {  
       l++;
       content = content + '\0';
    }
       
-   //tagHT[key]->SetValue(content);   
    gdcmHeaderEntry * a;
    IterHT p;
    TagHeaderEntryHT::iterator p2;
@@ -625,7 +589,6 @@ bool gdcmParser::SetEntryByNumber(std::string content,
        
    a-> SetValue(content); 
    
-   //std::string vr = tagHT[key]->GetVR();
    std::string vr = a->GetVR();
    
    guint32 lgr;
@@ -634,50 +597,46 @@ bool gdcmParser::SetEntryByNumber(std::string content,
    else if( (vr == "UL") || (vr == "SL") )
       lgr = 4;
    else
-      lgr = l;	   
+      lgr = l;   
 
-   //tagHT[key]->SetLength(lgr);
    a->SetLength(lgr);   
    return true;
-}					  
+}  
 
 /**
- * \ingroup gdcmParser
  * \brief   Accesses an existing gdcmHeaderEntry (i.e. a Dicom Element)
  *          in the PubHeaderEntrySet of this instance
  *          through it's (group, element) and modifies it's length with
  *          the given value.
  * \warning Use with extreme caution.
- * @param   length new length to substitute with
- * @param   group   group of the entry to modify
- * @param   element element of the Entry to modify
- * @return  1 on success, 0 otherwise.
+ * @param l new length to substitute with
+ * @param group   group of the Entry to modify
+ * @param element element of the Entry to modify
+ * @return  true on success, false otherwise.
  */
-
-bool gdcmParser::SetEntryLengthByNumber(guint32 length, 
-                                        guint16 group, guint16 element) 
+bool gdcmParser::SetEntryLengthByNumber(guint32 l, 
+                                        guint16 group, 
+                                        guint16 element) 
 {
    TagKey key = gdcmDictEntry::TranslateToKey(group, element);
    if ( ! tagHT.count(key))
       return false;
-   if (length%2) length++; // length must be even
-   //tagHT[key]->SetLength(length);
-   ( ((tagHT.equal_range(key)).first)->second )->SetLength(length);	 
-	 
-   return true ;		
+   if (l%2) l++; // length must be even
+   ( ((tagHT.equal_range(key)).first)->second )->SetLength(l); 
+
+   return true ;
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Gets (from Header) the offset  of a 'non string' element value 
- * \        (LoadElementValues has already be executed)
- * @param   Group
- * @param   Elem
+ *          (LoadElementValues has already be executed)
+ * @param Group   group of the Entry 
+ * @param Elem  element of the Entry
  * @return File Offset of the Element Value 
  */
 size_t gdcmParser::GetEntryOffsetByNumber(guint16 Group, guint16 Elem) 
 {
-   gdcmHeaderEntry* Entry = GetHeaderEntryByNumber(Group, Elem);	 
+   gdcmHeaderEntry* Entry = GetHeaderEntryByNumber(Group, Elem);
    if (!Entry) 
    {
       dbg.Verbose(1, "gdcmParser::GetHeaderEntryByNumber",
@@ -688,16 +647,15 @@ size_t gdcmParser::GetEntryOffsetByNumber(guint16 Group, guint16 Elem)
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Gets (from Header) a 'non string' element value 
- * \        (LoadElementValues has already be executed)  
- * @param   Group
- * @param   Elem
+ *          (LoadElementValues has already be executed)  
+ * @param Group   group of the Entry 
+ * @param Elem element of the Entry
  * @return Pointer to the 'non string' area
  */
 void * gdcmParser::GetEntryVoidAreaByNumber(guint16 Group, guint16 Elem) 
 {
-   gdcmHeaderEntry* Entry = GetHeaderEntryByNumber(Group, Elem);	 
+   gdcmHeaderEntry* Entry = GetHeaderEntryByNumber(Group, Elem);
    if (!Entry) 
    {
       dbg.Verbose(1, "gdcmParser::GetHeaderEntryByNumber",
@@ -708,9 +666,10 @@ void * gdcmParser::GetEntryVoidAreaByNumber(guint16 Group, guint16 Elem)
 }
 
 /**
- * \ingroup       gdcmParser
  * \brief         Loads (from disk) the element content 
  *                when a string is not suitable
+ * @param Group   group of the Entry 
+ * @param Elem element of the Entry
  */
 void *gdcmParser::LoadEntryVoidArea(guint16 Group, guint16 Elem) 
 {
@@ -719,50 +678,46 @@ void *gdcmParser::LoadEntryVoidArea(guint16 Group, guint16 Elem)
       return NULL;
    size_t o =(size_t)Element->GetOffset();
    fseek(fp, o, SEEK_SET);
-   int l=Element->GetLength();
-   void * a = malloc(l);
+   size_t l=Element->GetLength();
+   char* a = new char[l];
    if(!a) 
-   	return NULL;
+      return NULL;
 
    SetEntryVoidAreaByNumber(a, Group, Elem);
-   // TODO check the result 
+   /// \todo check the result 
    size_t l2 = fread(a, 1, l ,fp);
    if(l != l2) 
    {
-   	free(a);
-   	return NULL;
+      delete[] a;
+      return NULL;
    }
+
    return a;  
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Sets a 'non string' value to a given Dicom Element
  * @param   area
  * @param   group Group number of the searched Dicom Element 
  * @param   element Element number of the searched Dicom Element 
  * @return  
  */
-bool gdcmParser::SetEntryVoidAreaByNumber(void * area,guint16 group, guint16 element) 
+bool gdcmParser::SetEntryVoidAreaByNumber(void * area,
+                                          guint16 group, 
+                                          guint16 element) 
 {
    TagKey key = gdcmDictEntry::TranslateToKey(group, element);
    if ( ! tagHT.count(key))
       return false;
-   //tagHT[key]->SetVoidArea(area);
-   ( ((tagHT.equal_range(key)).first)->second )->SetVoidArea(area);	 
+   ( ((tagHT.equal_range(key)).first)->second )->SetVoidArea(area); 
    return true;
 }
 
 /**
- * \ingroup gdcmParser
- * \brief   Update the entries with the shadow dictionary. Only odd entries are
- *          analized
+ * \brief   Update the entries with the shadow dictionary. 
+ *          Only non even entries are analyzed       
  */
-void gdcmParser::UpdateShaEntries(void)
-{
-   if(!RefShaDict)
-      return;
-
+void gdcmParser::UpdateShaEntries(void) {
    gdcmDictEntry *entry;
    std::string vr;
 
@@ -771,30 +726,44 @@ void gdcmParser::UpdateShaEntries(void)
        ++it)
    {
       // Odd group => from public dictionary
-      if((*it)->GetGroup()%1==0)
+      if((*it)->GetGroup()%2==0)
          continue;
 
       // Peer group => search the corresponding dict entry
-      entry=RefShaDict->GetDictEntryByNumber((*it)->GetGroup(),(*it)->GetElement());
-      if(entry)
-      {
-         (*it)->SetDictEntry(entry);
+      if(RefShaDict)
+         entry=RefShaDict->GetDictEntryByNumber((*it)->GetGroup(),(*it)->GetElement());
+      else
+         entry=NULL;
+
+      if((*it)->IsImplicitVR())
+         vr="Implicit";
+      else
          vr=(*it)->GetVR();
+
+      (*it)->SetValue(GetHeaderEntryUnvalue(*it));
+      if(entry){
+         // Set the new entry and the new value
+         (*it)->SetDictEntry(entry);
          CheckHeaderEntryVR(*it,vr);
+
+         (*it)->SetValue(GetHeaderEntryValue(*it));
+      }
+      else
+      {
+         // Remove precedent value transformation
+         (*it)->SetDictEntry(NewVirtualDictEntry((*it)->GetGroup(),(*it)->GetElement(),vr));
       }
    }
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Searches within the Header Entries for a Dicom Element of
  *          a given tag.
  * @param   tagName name of the searched Dicom Element.
  * @return  Corresponding Dicom Element when it exists, and NULL
  *          otherwise.
  */
- gdcmHeaderEntry *gdcmParser::GetHeaderEntryByName(std::string tagName) 
- {
+ gdcmHeaderEntry *gdcmParser::GetHeaderEntryByName(std::string tagName) {
    gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName); 
    if( dictEntry == NULL)
       return NULL;
@@ -803,9 +772,8 @@ void gdcmParser::UpdateShaEntries(void)
 }
 
 /**
- * \ingroup gdcmParser
  * \brief  retrieves a Dicom Element (the first one) using (group, element)
- * \ warning (group, element) IS NOT an identifier inside the Dicom Header
+ * \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)
@@ -815,29 +783,38 @@ void gdcmParser::UpdateShaEntries(void)
  */
 gdcmHeaderEntry* gdcmParser::GetHeaderEntryByNumber(guint16 group, guint16 element) 
 {
-   TagKey key = gdcmDictEntry::TranslateToKey(group, element);
+   TagKey key = gdcmDictEntry::TranslateToKey(group, element);   
    if ( ! tagHT.count(key))
       return NULL;
    return tagHT.find(key)->second;
 }
 
 /**
- * \ingroup       gdcmParser
+ * \brief   retrieves the Dicom Elements (all of them) using (group, element) 
+ * @param   group Group number of the searched Dicom Element.
+ * @param   element Element number of the searched Dicom Element.
+ * @return  a range (i.e.pair<,>) containing all elements whose key is group|element) 
+ */
+ 
+IterHT gdcmParser::GetHeaderEntrySameNumber(guint16 group, guint16 element){
+   TagKey key = gdcmDictEntry::TranslateToKey(group, element);
+   return (tagHT.equal_range(key));
+}
+
+/**
  * \brief         Loads the element while preserving the current
  *                underlying file position indicator as opposed to
  *                to LoadHeaderEntry that modifies it.
  * @param entry   Header Entry whose value shall be loaded. 
  * @return  
  */
-void gdcmParser::LoadHeaderEntrySafe(gdcmHeaderEntry * entry) 
-{
+void gdcmParser::LoadHeaderEntrySafe(gdcmHeaderEntry * entry) {
    long PositionOnEntry = ftell(fp);
    LoadHeaderEntry(entry);
    fseek(fp, PositionOnEntry, SEEK_SET);
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Re-computes the length of a ACR-NEMA/Dicom group from a DcmHeader
  * \warning : to be re-written using the chained list instead of the H table.
  * \warning : DO NOT use (doesn't work any longer because of the multimap)
@@ -845,8 +822,7 @@ void gdcmParser::LoadHeaderEntrySafe(gdcmHeaderEntry * entry)
  * @param   SkipSequence TRUE if we don't want to write Sequences (ACR-NEMA Files)
  * @param   type Type of the File (ExplicitVR,ImplicitVR, ACR, ...) 
  */
-void gdcmParser::UpdateGroupLength(bool SkipSequence, FileType type) 
-{
+void gdcmParser::UpdateGroupLength(bool SkipSequence, FileType type) {
    guint16 gr, el;
    std::string vr;
    
@@ -874,7 +850,7 @@ void gdcmParser::UpdateGroupLength(bool SkipSequence, FileType type)
       vr = elem->GetVR(); 
                  
       sprintf(trash, "%04x", gr);
-      key = trash;		// generate 'group tag'
+      key = trash;   // generate 'group tag'
       
       // if the caller decided not to take SEQUENCEs into account 
       // e.g : he wants to write an ACR-NEMA File 
@@ -887,7 +863,7 @@ void gdcmParser::UpdateGroupLength(bool SkipSequence, FileType type)
       // since it's at the end of the Hash Table
       // (fffe,e0dd) 
        
-      // pas SEQUENCE en ACR-NEMA
+      // there is SEQUENCE in ACR-NEMA
       // WARNING : 
       // --> la descente a l'interieur' des SQ 
       // devrait etre faite avec une liste chainee, pas avec une HTable...
@@ -895,8 +871,8 @@ void gdcmParser::UpdateGroupLength(bool SkipSequence, FileType type)
       if ( groupHt.count(key) == 0) // we just read the first elem of a given group
       { 
          if (el == 0x0000) // the first elem is 0x0000
-         {	      
-            groupHt[key] = 0;	      // initialize group length 
+         {
+            groupHt[key] = 0;      // initialize group length 
          } 
          else 
          {
@@ -905,7 +881,7 @@ void gdcmParser::UpdateGroupLength(bool SkipSequence, FileType type)
       } 
       else // any elem but the first
       {   
-         if (type == ExplicitVR) 
+         if (type == gdcmExplicitVR) 
          {
             if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") ) 
             {
@@ -924,15 +900,15 @@ void gdcmParser::UpdateGroupLength(bool SkipSequence, FileType type)
    { 
       // FIXME: g++ -Wall -Wstrict-prototypes reports on following line:
       //        warning: unsigned int format, different type arg
-      sscanf(g->first.c_str(),"%x",&gr_bid);
-      tk = g->first + "|0000";			// generate the element full tag
+      sscanf(g->first.c_str(),"%x",&gr_bid); //FIXME
+      tk = g->first + "|0000";   // generate the element full tag
                      
       if ( tagHT.count(tk) == 0) // if element 0x0000 not found
-      { 		
+      {
          gdcmDictEntry * tagZ = new gdcmDictEntry(gr_bid, 0x0000, "UL");       
          elemZ = new gdcmHeaderEntry(tagZ);
          elemZ->SetLength(4);
-         AddHeaderEntry(elemZ);				// create it
+         AddHeaderEntry(elemZ);   // create it
       } 
       else 
       {
@@ -945,126 +921,241 @@ void gdcmParser::UpdateGroupLength(bool SkipSequence, FileType type)
 }
 
 /**
- * \ingroup gdcmParser
- * \brief   writes on disc according to the requested format
- * \        (ACR-NEMA, ExplicitVR, ImplicitVR) the image
- * \ warning does NOT add the missing elements in the header :
- * \         it's up to the user doing it !
- * \         (function CheckHeaderCoherence to be written)
- * @param   type type of the File to be written 
- *          (ACR-NEMA, ExplicitVR, ImplicitVR)
- * @param   _fp already open file pointer
+ * \brief Writes in a file (according to the requested format)
+ *        the group, the element, the value representation and the length
+ *        of a single gdcmHeaderEntry passed as argument.
+ * @param tag  pointer on the gdcmHeaderEntry to be written
+ * @param _fp  already open file pointer
+ * @param type type of the File to be written 
  */
-void gdcmParser::WriteEntries(FileType type, FILE * _fp) 
+void gdcmParser::WriteEntryTagVRLength(gdcmHeaderEntry *tag,
+                                       FILE *_fp,
+                                       FileType type)
 {
-   guint16 gr, el;
-   guint32 lgr;
-   const char * val;
-   std::string vr;
-   guint32 val_uint32;
-   guint16 val_uint16;
-   
-   std::vector<std::string> tokens;
-   
-   //  uses now listEntries to iterate, not TagHt!
-   //
-   //        pb : gdcmParser.Add does NOT update listEntries
-   //       TODO : find a trick (in STL?) to do it, at low cost !
-
-   void *ptr;
+   guint16 group  = tag->GetGroup();
+   std::string vr = tag->GetVR();
+   guint16 el     = tag->GetElement();
+   guint32 lgr    = tag->GetReadLength();
 
-   // TODO (?) tester les echecs en ecriture (apres chaque fwrite)
+   if ( (group == 0xfffe) && (el == 0x0000) ) 
+     // Fix in order to make some MR PHILIPS images e-film readable
+     // see gdcmData/gdcm-MR-PHILIPS-16-Multi-Seq.dcm:
+     // we just *always* ignore spurious fffe|0000 tag !   
+      return; 
 
-   for (ListTag::iterator tag2=listEntries.begin();
-        tag2 != listEntries.end();
-        ++tag2)
-   {
-      gr =  (*tag2)->GetGroup();
-      el =  (*tag2)->GetElement();
-      lgr = (*tag2)->GetLength();
-      val = (*tag2)->GetValue().c_str();
-      vr =  (*tag2)->GetVR();
+   fwrite ( &group,(size_t)2 ,(size_t)1 ,_fp);  //group
+   fwrite ( &el,(size_t)2 ,(size_t)1 ,_fp);     //element
       
-      if ( type == ACR ) 
-      { 
-         if (gr < 0x0008)   continue; // ignore pure DICOM V3 groups
-         if (gr %2)         continue; // ignore shadow groups
-         if (vr == "SQ" )   continue; // ignore Sequences
-	           // TODO : find a trick to *skip* the SeQuences !
-		   // Not only ignore the SQ element
-         if (gr == 0xfffe ) continue; // ignore delimiters
-      } 
+   if ( type == gdcmExplicitVR ) {
 
-      fwrite ( &gr,(size_t)2 ,(size_t)1 ,_fp);  //group
-      fwrite ( &el,(size_t)2 ,(size_t)1 ,_fp);  //element
+      // Special case of delimiters:
+      if (group == 0xfffe) {
+         // Delimiters have NO Value Representation and have NO length.
+         // Hence we skip writing the VR and length and we pad by writing
+         // 0xffffffff
 
-      if ( (type == ExplicitVR) && (gr <= 0x0002) ) 
-      {
-         // EXPLICIT VR
-         guint16 z=0, shortLgr;
-         fwrite (vr.c_str(),(size_t)2 ,(size_t)1 ,_fp);
+         int ff=0xffffffff;
+         fwrite (&ff,(size_t)4 ,(size_t)1 ,_fp);
+         return;
+      }
 
-         if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") ) 
+      guint16 z=0;
+      guint16 shortLgr = lgr;
+      if (vr == "unkn") {     // Unfound was 'written'
+         // deal with Little Endian            
+         fwrite ( &shortLgr,(size_t)2 ,(size_t)1 ,_fp);
+         fwrite ( &z,  (size_t)2 ,(size_t)1 ,_fp);
+      } else {
+         fwrite (vr.c_str(),(size_t)2 ,(size_t)1 ,_fp);                     
+         if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") )
          {
             fwrite ( &z,  (size_t)2 ,(size_t)1 ,_fp);
             fwrite ( &lgr,(size_t)4 ,(size_t)1 ,_fp);
-
-         } 
-         else 
-         {
-            shortLgr=lgr;
+         } else {
             fwrite ( &shortLgr,(size_t)2 ,(size_t)1 ,_fp);
          }
-      } 
-      else // IMPLICIT VR
-      { 
-         fwrite ( &lgr,(size_t)4 ,(size_t)1 ,_fp);
       }
+   } 
+   else // IMPLICIT VR 
+   { 
+      fwrite ( &lgr,(size_t)4 ,(size_t)1 ,_fp);
+   }
+}
+      
+/**
+ * \brief Writes in a file (according to the requested format)
+ *        the value of a single gdcmHeaderEntry passed as argument.
+ * @param tag  Pointer on the gdcmHeaderEntry to be written
+ * @param _fp  Already open file pointer
+ * @param type type of the File to be written
+ */
+void gdcmParser::WriteEntryValue(gdcmHeaderEntry *tag, FILE *_fp,FileType type)
+{
+   (void)type;
+   guint16 group  = tag->GetGroup();
+   std::string vr = tag->GetVR();
+   guint32 lgr    = tag->GetReadLength();
 
-      if (vr == "US" || vr == "SS") 
+   if (vr == "SQ")
+      // SeQuences have no value:
+      return;
+   if (group == 0xfffe)
+      // Delimiters have no associated value:
+      return;
+      
+   void *voidArea;
+   voidArea = tag->GetVoidArea();
+   if (voidArea != NULL) 
+   { // there is a 'non string' LUT, overlay, etc
+      fwrite ( voidArea,(size_t)lgr ,(size_t)1 ,_fp); // Elem value
+      return;            
+   }
+      
+   if (vr == "US" || vr == "SS") 
+   {
+      // some 'Short integer' fields may be mulivaluated
+      // each single value is separated from the next one by '\'
+      // we split the string and write each value as a short int
+      std::vector<std::string> tokens;
+      tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
+      Tokenize (tag->GetValue(), tokens, "\\");
+      for (unsigned int i=0; i<tokens.size();i++) 
       {
-         tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
-         Tokenize ((*tag2)->GetValue(), tokens, "\\");
-         for (unsigned int i=0; i<tokens.size();i++) 
-         {
-            val_uint16 = atoi(tokens[i].c_str());
-            ptr = &val_uint16;
-            fwrite ( ptr,(size_t)2 ,(size_t)1 ,_fp);
-         }
-         tokens.clear();
-         continue;
+         guint16 val_uint16 = atoi(tokens[i].c_str());
+         void *ptr = &val_uint16;
+         fwrite ( ptr,(size_t)2 ,(size_t)1 ,_fp);
       }
-      if (vr == "UL" || vr == "SL") 
+      tokens.clear();
+      return;
+   }
+      // some 'Integer' fields may be mulivaluated
+      // each single value is separated from the next one by '\'
+      // we split the string and write each value as an int
+   if (vr == "UL" || vr == "SL") 
+   {
+      std::vector<std::string> tokens;
+      tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
+      Tokenize (tag->GetValue(), tokens, "\\");
+      for (unsigned int i=0; i<tokens.size();i++) 
       {
-         tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
-         Tokenize ((*tag2)->GetValue(), tokens, "\\");
-         for (unsigned int i=0; i<tokens.size();i++) 
-         {
-            val_uint32 = atoi(tokens[i].c_str());
-            ptr = &val_uint32;
-            fwrite ( ptr,(size_t)4 ,(size_t)1 ,_fp);
-         }
-         tokens.clear();
-         continue;
-      }     
-      // Pixels are never loaded in the element !
-      if ((gr == 0x7fe0) && (el == 0x0010) ) 
-         break;
+         guint32 val_uint32 = atoi(tokens[i].c_str());
+         void *ptr = &val_uint32;
+         fwrite ( ptr,(size_t)4 ,(size_t)1 ,_fp);
+      }
+      tokens.clear();
+      return;
+   }           
+   fwrite (tag->GetValue().c_str(), (size_t)lgr ,(size_t)1, _fp); // Elem value
+}
+
+/**
+ * \brief Writes in a file (according to the requested format)
+ *        a single gdcmHeaderEntry passed as argument.
+ * \sa    WriteEntryValue, WriteEntryTagVRLength.
+ * @param tag  Pointer on the gdcmHeaderEntry to be written
+ * @param _fp  Already open file pointer
+ * @param type type of the File to be written
+ */
+
+bool gdcmParser::WriteEntry(gdcmHeaderEntry *tag, FILE *_fp,FileType type)
+{
+   guint32 length = tag->GetLength();
+
+   // The value of a tag MUST (see the DICOM norm) be an odd number of
+   // bytes. When this is not the case, pad with an additional byte:
+   if(length%2==1)
+   { 
+      tag->SetValue(tag->GetValue()+"\0");
+      tag->SetLength(tag->GetReadLength()+1);
+   }
+
+   WriteEntryTagVRLength(tag, _fp, type);
+   WriteEntryValue(tag, _fp, type);
+   return true;
+}
+
+/**
+ * \brief   writes on disc according to the requested format
+ *          (ACR-NEMA, ExplicitVR, ImplicitVR) the image
+ *          using the Chained List
+ * \warning does NOT add the missing elements in the header :
+ *           it's up to the user doing it !
+ *           (function CheckHeaderCoherence to be written)
+ * \warning DON'T try, right now, to write a DICOM image
+ *           from an ACR Header (meta elements will be missing!)
+ * \sa WriteEntriesDeprecated (Special temporary method for Theralys)
+ * @param   type type of the File to be written 
+ *          (ACR-NEMA, ExplicitVR, ImplicitVR)
+ * @param   _fp already open file pointer
+ */
+
+bool gdcmParser::WriteEntries(FILE *_fp,FileType type)
+{   
+   /// \todo (?) check write failures (after *each* fwrite)
+     
+   for (ListTag::iterator tag2=listEntries.begin();
+                          tag2 != listEntries.end();
+                          ++tag2)
+   {
+      if ( type == gdcmACR ){ 
+         if ((*tag2)->GetGroup() < 0x0008)
+            // Ignore pure DICOM V3 groups
+            continue;
+         if ((*tag2)->GetElement() %2)
+            // Ignore the "shadow" groups
+            continue;
+         if ((*tag2)->GetVR() == "SQ" ) // ignore Sequences
+            continue;
+         if ((*tag2)->GetSQDepthLevel() != 0) // Not only ignore the SQ element
+            continue;	    
+      } 
+      if (! WriteEntry(*tag2,_fp,type) )
+         return false;
+   }
+   return true;
+}   
 
-      fwrite ( val,(size_t)lgr ,(size_t)1 ,_fp); // Elem value
+/**
+ * \brief   writes on disc according to the requested format
+ *          (ACR-NEMA, ExplicitVR, ImplicitVR) the image,
+ *          using only the last synonym of each mutimap H Table post.
+ * \warning Uses the H Table, instead of the Chained List
+ *          in order to be compliant with the old way to proceed
+ *         (added elements taken in to account)
+ *         Only THERALYS, during a transitory phase is supposed
+ *         to use this method !!!
+ * \warning DON'T try, right now, to write a DICOM image
+ *           from an ACR Header (meta elements will be missing!)
+ * \sa WriteEntries
+ * @param   _fp already open file pointer
+ * @param   type type of the File to be written 
+ *          (ACR-NEMA, ExplicitVR, ImplicitVR)
+ */
+void gdcmParser::WriteEntriesDeprecated(FILE *_fp,FileType type) {
+
+   // restent a tester les echecs en ecriture (apres chaque fwrite)
+
+   for (TagHeaderEntryHT::iterator tag2=tagHT.begin();
+        tag2 != tagHT.end();
+        ++tag2){
+      if ( type == gdcmACR ){ 
+         if ((*tag2->second).GetGroup() < 0x0008)    continue; // ignore pure DICOM V3 groups
+         if ((*tag2->second).GetElement() %2)        continue; // ignore shadow groups
+         if ((*tag2->second).GetVR() == "SQ" )       continue; // ignore Sequences
+         if ((*tag2->second).GetSQDepthLevel() != 0) continue; // Not only ignore the SQ element          
+      }
+      if ( ! WriteEntry(tag2->second,_fp,type))
+         break;
    }
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Swaps back the bytes of 4-byte long integer accordingly to
  *          processor order.
  * @return  The properly swaped 32 bits integer.
  */
-guint32 gdcmParser::SwapLong(guint32 a) 
-{
-   switch (sw) 
-   {
+guint32 gdcmParser::SwapLong(guint32 a) {
+   switch (sw) {
       case    0 :
          break;
       case 4321 :
@@ -1087,57 +1178,65 @@ guint32 gdcmParser::SwapLong(guint32 a)
 }
 
 /**
- * \ingroup gdcmParser
+ * \brief   Unswaps back the bytes of 4-byte long integer accordingly to
+ *          processor order.
+ * @return  The properly unswaped 32 bits integer.
+ */
+guint32 gdcmParser::UnswapLong(guint32 a) {
+   return (SwapLong(a));
+}
+
+/**
  * \brief   Swaps the bytes so they agree with the processor order
  * @return  The properly swaped 16 bits integer.
  */
-guint16 gdcmParser::SwapShort(guint16 a) 
-{
+guint16 gdcmParser::SwapShort(guint16 a) {
    if ( (sw==4321)  || (sw==2143) )
       a =(((a<<8) & 0x0ff00) | ((a>>8)&0x00ff));
    return (a);
 }
 
-//-----------------------------------------------------------------------------
-// Private
 /**
- * \ingroup gdcmParser
- * \brief   Parses the header of the file but WITHOUT loading element values.
+ * \brief   Unswaps the bytes so they agree with the processor order
+ * @return  The properly unswaped 16 bits integer.
  */
-void gdcmParser::Parse(bool exception_on_error) throw(gdcmFormatError) 
-{
-   gdcmHeaderEntry *newHeaderEntry = (gdcmHeaderEntry *)0;
-   
-   rewind(fp);
-   CheckSwap();
-   while ( (newHeaderEntry = ReadNextHeaderEntry()) ) 
-   {
-      SkipHeaderEntry(newHeaderEntry);
-      AddHeaderEntry(newHeaderEntry);
-   }
+guint16 gdcmParser::UnswapShort(guint16 a) {
+   return (SwapShort(a));
 }
 
+//-----------------------------------------------------------------------------
+// Private
 /**
- * \ingroup gdcmParser
- * \brief   Loads the element values of all the Header Entries pointed in the
- *          public Chained List.
+ * \brief   Parses the header of the file and load element values.
+ * @return  false if file is not ACR-NEMA / PAPYRUS / DICOM 
  */
-void gdcmParser::LoadHeaderEntries(void) 
-{
+bool gdcmParser::LoadHeaderEntries(bool exception_on_error) throw(gdcmFormatError) {
+   (void)exception_on_error;
    rewind(fp);
-   for (ListTag::iterator i = GetListEntry().begin();
-      i != GetListEntry().end();
-      ++i)
-   {
-         LoadHeaderEntry(*i);
+   if (!CheckSwap())
+      return false;
+      
+   gdcmHeaderEntry *newHeaderEntry = (gdcmHeaderEntry *)0;   
+   while ( (newHeaderEntry = ReadNextHeaderEntry()) ) {
+     SkipHeaderEntry(newHeaderEntry);
+     if ( (ignoreShadow==0) || (newHeaderEntry->GetGroup()%2) == 0) { 
+        AddHeaderEntry(newHeaderEntry); 
+     }     
    }   
-            
    rewind(fp);
-
-   // Load 'non string' values   
+   // Be carefull : merging this two loops may cause troubles ...
+   for (ListTag::iterator i = GetListEntry().begin();                           
+        i != GetListEntry().end();                                                
+        ++i)                                                                      
+   {                                                                            
+      LoadHeaderEntry(*i);                                                      
+   }                                                                            
+   rewind(fp);                                                                     
+   
+   // Load 'non string' values
+      
    std::string PhotometricInterpretation = GetEntryByNumber(0x0028,0x0004);   
-   if( PhotometricInterpretation == "PALETTE COLOR " )
-   {
+   if( PhotometricInterpretation == "PALETTE COLOR " ) {
       LoadEntryVoidArea(0x0028,0x1200);  // gray LUT   
       LoadEntryVoidArea(0x0028,0x1201);  // R    LUT
       LoadEntryVoidArea(0x0028,0x1202);  // G    LUT
@@ -1146,68 +1245,56 @@ void gdcmParser::LoadHeaderEntries(void)
       LoadEntryVoidArea(0x0028,0x1221);  // Segmented Red   Palette Color LUT Data
       LoadEntryVoidArea(0x0028,0x1222);  // Segmented Green Palette Color LUT Data
       LoadEntryVoidArea(0x0028,0x1223);  // Segmented Blue  Palette Color LUT Data
-   }
-
+   } 
+   //FIXME later : how to use it?
+   LoadEntryVoidArea(0x0028,0x3006);  //LUT Data (CTX dependent)     
+   
    // --------------------------------------------------------------
    // Special Patch to allow gdcm to read ACR-LibIDO formated images
    //
    // if recognition code tells us we deal with a LibIDO image
    // we switch lineNumber and columnNumber
    //
-   std::string RecCode;	
+   std::string RecCode;
    RecCode = GetEntryByNumber(0x0008, 0x0010); // recognition code
    if (RecCode == "ACRNEMA_LIBIDO_1.1" ||
-       RecCode == "CANRME_AILIBOD1_1." ) 
+       RecCode == "CANRME_AILIBOD1_1." )  // for brain-damaged softwares
+                                          // with "little-endian strings"
    {
-         filetype = ACR_LIBIDO; 
+         filetype = gdcmACR_LIBIDO; 
          std::string rows    = GetEntryByNumber(0x0028, 0x0010);
          std::string columns = GetEntryByNumber(0x0028, 0x0011);
          SetEntryByNumber(columns, 0x0028, 0x0010);
          SetEntryByNumber(rows   , 0x0028, 0x0011);
    }
-   // ----------------- End of Special Patch ----------------
+   // ----------------- End of Special Patch ----------------   
+   return true;
 }
 
 /**
- * \ingroup       gdcmParser
- * \brief         Loads the element content if it's length is not bigger
- *                than the value specified with
- *                gdcmParser::SetMaxSizeLoadEntry()
+ * \brief         Loads the element content if its length doesn't exceed
+ *                the value specified with gdcmParser::SetMaxSizeLoadEntry()
  * @param         Entry Header Entry (Dicom Element) to be dealt with
  */
-void gdcmParser::LoadHeaderEntry(gdcmHeaderEntry *Entry) 
-{
+void gdcmParser::LoadHeaderEntry(gdcmHeaderEntry *Entry)  {
    size_t item_read;
    guint16 group  = Entry->GetGroup();
    std::string  vr= Entry->GetVR();
    guint32 length = Entry->GetLength();
-   bool SkipLoad  = false;
 
    fseek(fp, (long)Entry->GetOffset(), SEEK_SET);
-   
-   // the test was commented out to 'go inside' the SeQuences
-   // we don't any longer skip them !
-    
-   // if( vr == "SQ" )  //  (DO NOT remove this comment)
-   //    SkipLoad = true;
 
    // A SeQuence "contains" a set of Elements.  
    //          (fffe e000) tells us an Element is beginning
    //          (fffe e00d) tells us an Element just ended
    //          (fffe e0dd) tells us the current SeQuence just ended
-   if( group == 0xfffe )
-      SkipLoad = true;
-
-   if ( SkipLoad ) 
-   {
-      Entry->SetLength(0);
+   if( group == 0xfffe ) {
       Entry->SetValue("gdcm::Skipped");
       return;
    }
 
    // When the length is zero things are easy:
-   if ( length == 0 ) 
-   {
+   if ( length == 0 ) {
       Entry->SetValue("");
       return;
    }
@@ -1215,8 +1302,7 @@ void gdcmParser::LoadHeaderEntry(gdcmHeaderEntry *Entry)
    // The elements whose length is bigger than the specified upper bound
    // are not loaded. Instead we leave a short notice of the offset of
    // the element content and it's length.
-   if (length > MaxSizeLoadEntry) 
-   {
+   if (length > MaxSizeLoadEntry) {
       std::ostringstream s;
       s << "gdcm::NotLoaded.";
       s << " Address:" << (long)Entry->GetOffset();
@@ -1225,115 +1311,94 @@ void gdcmParser::LoadHeaderEntry(gdcmHeaderEntry *Entry)
       Entry->SetValue(s.str());
       return;
    }
-   
-   // When integer(s) are expected, read and convert the following 
-   // n *(two or four bytes)
-   // properly i.e. as integers as opposed to a strings.	
-   // Elements with Value Multiplicity > 1
-   // contain a set of integers (not a single one) 
-    	
+    
    // Any compacter code suggested (?)
-   if ( IsHeaderEntryAnInteger(Entry) ) 
-   {
+   if ( IsHeaderEntryAnInteger(Entry) ) {   
       guint32 NewInt;
       std::ostringstream s;
       int nbInt;
-      if (vr == "US" || vr == "SS") 
-      {
+   // When short integer(s) are expected, read and convert the following 
+   // n *two characters properly i.e. as short integers as opposed to strings.
+   // Elements with Value Multiplicity > 1
+   // contain a set of integers (not a single one)       
+      if (vr == "US" || vr == "SS") {
          nbInt = length / 2;
          NewInt = ReadInt16();
          s << NewInt;
-         if (nbInt > 1) 
-         {
-            for (int i=1; i < nbInt; i++) 
-            {
+         if (nbInt > 1){
+            for (int i=1; i < nbInt; i++) {
                s << '\\';
                NewInt = ReadInt16();
                s << NewInt;
             }
          }
-			
-      } 
-      else if (vr == "UL" || vr == "SL") 
-      {
+      }
+   // When integer(s) are expected, read and convert the following 
+   // n * four characters properly i.e. as integers as opposed to strings.
+   // Elements with Value Multiplicity > 1
+   // contain a set of integers (not a single one)           
+      else if (vr == "UL" || vr == "SL") {
          nbInt = length / 4;
          NewInt = ReadInt32();
          s << NewInt;
-         if (nbInt > 1) 
-         {
-            for (int i=1; i < nbInt; i++) 
-            {
+         if (nbInt > 1) {
+            for (int i=1; i < nbInt; i++) {
                s << '\\';
                NewInt = ReadInt32();
                s << NewInt;
             }
          }
-      }					
+      }
 #ifdef GDCM_NO_ANSI_STRING_STREAM
       s << std::ends; // to avoid oddities on Solaris
 #endif //GDCM_NO_ANSI_STRING_STREAM
+
       Entry->SetValue(s.str());
-      return;	
-   }
-   
-   // We need an additional byte for storing \0 that is not on disk
-   char* NewValue = (char*)malloc(length+1);
-   if( !NewValue) 
-   {
-      dbg.Verbose(1, "LoadElementValue: Failed to allocate NewValue");
       return;
    }
-   NewValue[length]= 0;
    
-   item_read = fread(NewValue, (size_t)length, (size_t)1, fp);
-   if ( item_read != 1 ) 
-   {
-      free(NewValue);
+   // We need an additional byte for storing \0 that is not on disk
+   std::string NewValue(length,0);
+   item_read = fread(&(NewValue[0]), (size_t)length, (size_t)1, fp);
+   if ( item_read != 1 ) {
       dbg.Verbose(1, "gdcmParser::LoadElementValue","unread element value");
       Entry->SetValue("gdcm::UnRead");
       return;
    }
-   Entry->SetValue(NewValue);
-   free(NewValue);
+
+   if( (vr == "UI") ) // Because of correspondance with the VR dic
+      Entry->SetValue(NewValue.c_str());
+   else
+      Entry->SetValue(NewValue);
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   add a new Dicom Element pointer to 
- *          the H Table and to the chained List
+ *          the H Table and at the end of the chained List
  * \warning push_bash in listEntries ONLY during ParseHeader
  * \todo    something to allow further Elements addition,
- * \        when position to be taken care of     
+ *          (at their right place in the chained list)
+ *          when position to be taken care of     
  * @param   newHeaderEntry
  */
-void gdcmParser::AddHeaderEntry(gdcmHeaderEntry * newHeaderEntry) 
-{
+void gdcmParser::AddHeaderEntry(gdcmHeaderEntry *newHeaderEntry) {
    tagHT.insert( PairHT( newHeaderEntry->GetKey(),newHeaderEntry) );
    listEntries.push_back(newHeaderEntry); 
    wasUpdated = 1;
 }
 
 /**
- * \ingroup gdcmParser
- * \brief   
- * @param   Entry Header Entry whose length of the value shall be loaded. 
-
- * @return 
+ * \brief  Find the value Length of the passed Header Entry
+ * @param  Entry Header Entry whose length of the value shall be loaded. 
  */
- void gdcmParser::FindHeaderEntryLength (gdcmHeaderEntry * Entry) 
- {
+ void gdcmParser::FindHeaderEntryLength (gdcmHeaderEntry *Entry) {
    guint16 element = Entry->GetElement();
-   guint16 group   = Entry->GetGroup();
+   //guint16 group   = Entry->GetGroup(); //FIXME
    std::string  vr = Entry->GetVR();
    guint16 length16;
-   if( (element == 0x0010) && (group == 0x7fe0) ) 
-   {
-      dbg.SetDebug(-1);
-      dbg.Verbose(2, "gdcmParser::FindLength: ",
-                     "we reached 7fe0 0010");
-   }   
+       
    
-   if ( (filetype == ExplicitVR) && ! Entry->IsImplicitVr() ) 
+   if ( (filetype == gdcmExplicitVR) && (! Entry->IsImplicitVR()) ) 
    {
       if ( (vr=="OB") || (vr=="OW") || (vr=="SQ") || (vr=="UN") ) 
       {
@@ -1415,35 +1480,35 @@ void gdcmParser::AddHeaderEntry(gdcmHeaderEntry * newHeaderEntry)
          //dbg.Verbose(0, "gdcmParser::FindLength",
          //            "Erroneous element length fixed.");
          // Actually, length= 0xffff means that we deal with
-         // Unknown Sequence Length 
+         // Unfound Sequence Length 
       }
-
       FixHeaderEntryFoundLength(Entry, (guint32)length16);
       return;
    }
-
-   // Either implicit VR or a non DICOM conformal (see not below) explicit
-   // VR that ommited the VR of (at least) this element. Farts happen.
-   // [Note: according to the part 5, PS 3.5-2001, section 7.1 p25
-   // 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.
-   FixHeaderEntryFoundLength(Entry, ReadInt32());
-   return;
+   else
+   {
+      // Either implicit VR or a non DICOM conformal (see note below) explicit
+      // VR that ommited the VR of (at least) this element. Farts happen.
+      // [Note: according to the part 5, PS 3.5-2001, section 7.1 p25
+      // 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.
+      
+      FixHeaderEntryFoundLength(Entry, ReadInt32());
+      return;
+   }
 }
 
 /**
- * \ingroup   gdcmParser
  * \brief     Find the Value Representation of the current Dicom Element.
  * @param     Entry
  */
 void gdcmParser::FindHeaderEntryVR( gdcmHeaderEntry *Entry) 
 {
-   if (filetype != ExplicitVR)
+   if (filetype != gdcmExplicitVR)
       return;
 
    char VR[3];
-   int lgrLue;
 
    long PositionOnEntry = ftell(fp);
    // Warning: we believe this is explicit VR (Value Representation) because
@@ -1454,7 +1519,7 @@ void gdcmParser::FindHeaderEntryVR( gdcmHeaderEntry *Entry)
    // is in explicit VR and try to fix things if it happens not to be
    // the case.
    
-   lgrLue=fread (&VR, (size_t)2,(size_t)1, fp);
+   (void)fread (&VR, (size_t)2,(size_t)1, fp);
    VR[2]=0;
    if(!CheckHeaderEntryVR(Entry,VR))
    {
@@ -1466,21 +1531,20 @@ void gdcmParser::FindHeaderEntryVR( gdcmHeaderEntry *Entry)
       // avoid  .
       if ( Entry->IsVRUnknown() )
          Entry->SetVR("Implicit");
-      Entry->SetImplicitVr();
+      Entry->SetImplicitVR();
    }
 }
 
 /**
- * \ingroup   gdcmParser
  * \brief     Check the correspondance between the VR of the header entry
  *            and the taken VR. If they are different, the header entry is 
  *            updated with the new VR.
- * @param     Entry
- * @param     VR
+ * @param     Entry Header Entry to check
+ * @param     vr    Dicom Value Representation
  * @return    false if the VR is incorrect of if the VR isn't referenced
  *            otherwise, it returns true
 */
-bool gdcmParser::CheckHeaderEntryVR   (gdcmHeaderEntry *Entry, VRKey vr)
+bool gdcmParser::CheckHeaderEntryVR(gdcmHeaderEntry *Entry, VRKey vr)
 {
    char msg[100]; // for sprintf
    bool RealExplicit = true;
@@ -1509,14 +1573,23 @@ bool gdcmParser::CheckHeaderEntryVR   (gdcmHeaderEntry *Entry, VRKey vr)
       sprintf(msg,"Falsely explicit vr file (%04x,%04x)\n", 
                    Entry->GetGroup(),Entry->GetElement());
       dbg.Verbose(1, "gdcmParser::FindVR: ",msg);
-
+      if (Entry->GetGroup()%2 && Entry->GetElement() == 0x0000) { // Group length is UL !
+         gdcmDictEntry* NewEntry = NewVirtualDictEntry(
+                                   Entry->GetGroup(),Entry->GetElement(),
+                                   "UL","FIXME","Group Length");
+         Entry->SetDictEntry(NewEntry);     
+      }
       return(false);
    }
 
    if ( Entry->IsVRUnknown() ) 
    {
       // When not a dictionary entry, we can safely overwrite the VR.
-      Entry->SetVR(vr);
+      if (Entry->GetElement() == 0x0000) { // Group length is UL !
+         Entry->SetVR("UL");
+      } else {
+         Entry->SetVR(vr);
+      }
    }
    else if ( Entry->GetVR() != vr ) 
    {
@@ -1525,22 +1598,140 @@ bool gdcmParser::CheckHeaderEntryVR   (gdcmHeaderEntry *Entry, VRKey vr)
       // be unwise to overwrite the VR of a dictionary (since it would
       // compromise it's next user), we need to clone the actual DictEntry
       // and change the VR for the read one.
-      gdcmDictEntry* NewTag = NewVirtualDictEntry(Entry->GetGroup(),
-                                 Entry->GetElement(),
-                                 vr,
-                                 "FIXME",
-                                 Entry->GetName());
-      Entry->SetDictEntry(NewTag);
+      gdcmDictEntry* NewEntry = NewVirtualDictEntry(
+                                 Entry->GetGroup(),Entry->GetElement(),
+                                 vr,"FIXME",Entry->GetName());
+      Entry->SetDictEntry(NewEntry);
    }
    return(true); 
 }
 
 /**
- * \ingroup gdcmParser
- * \brief  Skip a given Header Entry 
+ * \brief   Get the transformed value of the header entry. The VR value 
+ *          is used to define the transformation to operate on the value
  * \warning NOT end user intended method !
- * @param entry 
- * @return 
+ * @param   Entry 
+ * @return  Transformed entry value
+ */
+std::string gdcmParser::GetHeaderEntryValue(gdcmHeaderEntry *Entry)
+{
+   if ( (IsHeaderEntryAnInteger(Entry)) && (Entry->IsImplicitVR()) )
+   {
+      std::string val=Entry->GetValue();
+      std::string vr=Entry->GetVR();
+      guint32 length = Entry->GetLength();
+      std::ostringstream s;
+      int nbInt;
+
+   // When short integer(s) are expected, read and convert the following 
+   // n * 2 bytes properly i.e. as a multivaluated strings
+   // (each single value is separated fromthe next one by '\'
+   // as usual for standard multivaluated filels
+   // Elements with Value Multiplicity > 1
+   // contain a set of short integers (not a single one) 
+   
+      if (vr == "US" || vr == "SS")
+      {
+         guint16 NewInt16;
+
+         nbInt = length / 2;
+         for (int i=0; i < nbInt; i++) 
+         {
+            if(i!=0)
+               s << '\\';
+            NewInt16 = (val[2*i+0]&0xFF)+((val[2*i+1]&0xFF)<<8);
+            NewInt16 = SwapShort(NewInt16);
+            s << NewInt16;
+         }
+      }
+
+   // When integer(s) are expected, read and convert the following 
+   // n * 4 bytes properly i.e. as a multivaluated strings
+   // (each single value is separated fromthe next one by '\'
+   // as usual for standard multivaluated filels
+   // Elements with Value Multiplicity > 1
+   // contain a set of integers (not a single one) 
+      else if (vr == "UL" || vr == "SL")
+      {
+         guint32 NewInt32;
+
+         nbInt = length / 4;
+         for (int i=0; i < nbInt; i++) 
+         {
+            if(i!=0)
+               s << '\\';
+            NewInt32= (val[4*i+0]&0xFF)+((val[4*i+1]&0xFF)<<8)+
+                     ((val[4*i+2]&0xFF)<<16)+((val[4*i+3]&0xFF)<<24);
+            NewInt32=SwapLong(NewInt32);
+            s << NewInt32;
+         }
+      }
+#ifdef GDCM_NO_ANSI_STRING_STREAM
+      s << std::ends; // to avoid oddities on Solaris
+#endif //GDCM_NO_ANSI_STRING_STREAM
+      return(s.str());
+   }
+
+   return(Entry->GetValue());
+}
+
+/**
+ * \brief   Get the reverse transformed value of the header entry. The VR 
+ *          value is used to define the reverse transformation to operate on
+ *          the value
+ * \warning NOT end user intended method !
+ * @param   Entry 
+ * @return  Reverse transformed entry value
+ */
+std::string gdcmParser::GetHeaderEntryUnvalue(gdcmHeaderEntry *Entry)
+{
+   if ( (IsHeaderEntryAnInteger(Entry)) && (Entry->IsImplicitVR()) )
+   {
+      std::string vr=Entry->GetVR();
+      std::ostringstream s;
+      std::vector<std::string> tokens;
+
+      if (vr == "US" || vr == "SS") 
+      {
+         guint16 NewInt16;
+
+         tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
+         Tokenize (Entry->GetValue(), tokens, "\\");
+         for (unsigned int i=0; i<tokens.size();i++) 
+         {
+            NewInt16 = atoi(tokens[i].c_str());
+            s<<(NewInt16&0xFF)<<((NewInt16>>8)&0xFF);
+         }
+         tokens.clear();
+      }
+      if (vr == "UL" || vr == "SL") 
+      {
+         guint32 NewInt32;
+
+         tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
+         Tokenize (Entry->GetValue(), tokens, "\\");
+         for (unsigned int i=0; i<tokens.size();i++) 
+         {
+            NewInt32 = atoi(tokens[i].c_str());
+            s<<(char)(NewInt32&0xFF)<<(char)((NewInt32>>8)&0xFF)
+               <<(char)((NewInt32>>16)&0xFF)<<(char)((NewInt32>>24)&0xFF);
+         }
+         tokens.clear();
+      }
+
+#ifdef GDCM_NO_ANSI_STRING_STREAM
+      s << std::ends; // to avoid oddities on Solaris
+#endif //GDCM_NO_ANSI_STRING_STREAM
+      return(s.str());
+   }
+
+   return(Entry->GetValue());
+}
+
+/**
+ * \brief   Skip a given Header Entry 
+ * \warning NOT end user intended method !
+ * @param   entry 
  */
 void gdcmParser::SkipHeaderEntry(gdcmHeaderEntry *entry) 
 {
@@ -1548,28 +1739,34 @@ void gdcmParser::SkipHeaderEntry(gdcmHeaderEntry *entry)
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   When the length of an element value is obviously wrong (because
  *          the parser went Jabberwocky) one can hope improving things by
  *          applying this heuristic.
  */
 void gdcmParser::FixHeaderEntryFoundLength(gdcmHeaderEntry *Entry, guint32 FoundLength) 
 {
-   Entry->SetReadLength(FoundLength); // will be updated only if a bug is found
-		     
-   if ( FoundLength == 0xffffffff) 
-   {
+   Entry->SetReadLength(FoundLength); // will be updated only if a bug is found        
+   if ( FoundLength == 0xffffffff) {
       FoundLength = 0;
    }
+   
+   guint16 gr =Entry->GetGroup();
+   guint16 el =Entry->GetElement(); 
+     
+   if (FoundLength%2) {
+      std::ostringstream s;
+      s << "Warning : Tag with uneven length " << FoundLength 
+         <<  " in x(" << std::hex << gr << "," << el <<")" << std::dec;
+      dbg.Verbose(0,s.str().c_str());
+   }
       
    // Sorry for the patch!  
-   // XMedCom did the trick to read some nasty GE images ...
-   else if (FoundLength == 13) 
-   {
+   // XMedCom did the trick to read some naughty GE images ...
+   if (FoundLength == 13) {
       // The following 'if' will be removed when there is no more
       // images on Creatis HDs with a 13 length for Manufacturer...
       if ( (Entry->GetGroup() != 0x0008) ||  
-           ( (Entry->GetElement() != 0x0070) && (Entry->GetElement() != 0x0080) ) ) {
+           ( (Entry->GetElement() != 0x0070) && (Entry->GetElement() != 0x0080) ) ){
       // end of remove area
          FoundLength =10;
          Entry->SetReadLength(10); // a bug is to be fixed
@@ -1579,55 +1776,43 @@ void gdcmParser::FixHeaderEntryFoundLength(gdcmHeaderEntry *Entry, guint32 Found
    // to fix some garbage 'Leonardo' Siemens images
    // May be commented out to avoid overhead
    else if ( (Entry->GetGroup() == 0x0009) &&
-       ( (Entry->GetElement() == 0x1113) || (Entry->GetElement() == 0x1114) ) )
-   {
+       ( (Entry->GetElement() == 0x1113) || (Entry->GetElement() == 0x1114) ) ){
       FoundLength =4;
       Entry->SetReadLength(4); // a bug is to be fixed 
    } 
    // end of fix
-	 
+ 
    // to try to 'go inside' SeQuences (with length), and not to skip them        
    else if ( Entry->GetVR() == "SQ") 
    { 
       if (enableSequences)    // only if the user does want to !
-         FoundLength =0; 	 
+         FoundLength =0;      // ReadLength is unchanged 
    } 
     
-   // a SeQuence Element is beginning                                          
-   // Let's forget it's length                                                 
-   // (we want to 'go inside')  
-
-   // Pb : *normaly*  fffe|e000 is just a marker, its length *should be* zero
-   // in gdcm-MR-PHILIPS-16-Multi-Seq.dcm we find lengthes as big as 28800
-   // if we set the length to zero IsHeaderEntryAnInteger() breaks...
-   // if we don't, we lost 28800 characters from the Header :-(
-                                                 
+   // we found a 'delimiter' element                                         
+   // fffe|xxxx is just a marker, we don't take its length into account                                                   
    else if(Entry->GetGroup() == 0xfffe)
-   { 
-                       // sometimes, length seems to be wrong                                      
-      FoundLength =0;  // some more clever checking to be done !
-                       // I give up!
-		       // only  gdcm-MR-PHILIPS-16-Multi-Seq.dcm
-		       // causes troubles :-(                                                     
-   }     
-    
+   {    
+                                         // *normally, fffe|0000 doesn't exist ! 
+     if( Entry->GetElement() != 0x0000 ) // gdcm-MR-PHILIPS-16-Multi-Seq.dcm
+                                         // causes extra troubles :-(                                                              	
+        FoundLength =0;
+   } 
+           
    Entry->SetUsableLength(FoundLength);
 }
 
 /**
- * \ingroup gdcmParser
- * \brief   Apply some heuristics to predict wether the considered 
+ * \brief   Apply some heuristics to predict whether the considered 
  *          element value contains/represents an integer or not.
  * @param   Entry The element value on which to apply the predicate.
  * @return  The result of the heuristical predicate.
  */
-bool gdcmParser::IsHeaderEntryAnInteger(gdcmHeaderEntry *Entry) 
-{
+bool gdcmParser::IsHeaderEntryAnInteger(gdcmHeaderEntry *Entry) {
    guint16 element = Entry->GetElement();
    guint16 group   = Entry->GetGroup();
    std::string  vr = Entry->GetVR();
    guint32 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
    // able to swap it's element value properly.
@@ -1638,10 +1823,21 @@ bool gdcmParser::IsHeaderEntryAnInteger(gdcmHeaderEntry *Entry)
       else 
       {
          std::ostringstream s;
-         s << "Erroneous Group Length element length  on :" \
-           << std::hex << group << " , " << element;
-         dbg.Error("gdcmParser::IsAnInteger",
-            s.str().c_str());     
+         int filePosition = ftell(fp);
+         s << "Erroneous Group Length element length  on : (" \
+           << std::hex << group << " , " << element 
+           << ") -before- position x(" << filePosition << ")"
+           << "lgt : " << length;
+         // These 2 lines commented out : a *very dirty* patch
+         // to go on PrintHeader'ing gdcm-MR-PHILIPS-16-Multi-Seq.dcm.
+         // have a glance at offset  x(8336) ...
+         // For *regular* headers, the test is useless..
+         // lets's print a warning message and go on, 
+         // instead of giving up with an error message
+
+         //std::cout << s.str().c_str() << std::endl;
+         // dbg.Error("gdcmParser::IsHeaderEntryAnInteger",
+         //           s.str().c_str());     
       }
    }
    if ( (vr == "UL") || (vr == "US") || (vr == "SL") || (vr == "SS") )
@@ -1649,15 +1845,13 @@ bool gdcmParser::IsHeaderEntryAnInteger(gdcmHeaderEntry *Entry)
    
    return false;
 }
-
 /**
- * \ingroup gdcmParser
- * \brief   
- *
+ * \brief  Find the Length till the next sequence delimiter
+ * \warning NOT end user intended method !
  * @return 
  */
- guint32 gdcmParser::FindHeaderEntryLengthOB(void) 
- {
+
+ guint32 gdcmParser::FindHeaderEntryLengthOB(void)  {
    // See PS 3.5-2001, section A.4 p. 49 on encapsulation of encoded pixel data.
    guint16 g;
    guint16 n; 
@@ -1674,7 +1868,7 @@ bool gdcmParser::IsHeaderEntryAnInteger(gdcmHeaderEntry *Entry)
          return 0;
       TotalLength += 4;  // We even have to decount the group and element 
      
-      if ( g != 0xfffe && g!=0xb00c ) /*for bogus header */ 
+      if ( g != 0xfffe && g!=0xb00c ) //for bogus header  
       {
          char msg[100]; // for sprintf. Sorry
          sprintf(msg,"wrong group (%04x) for an item sequence (%04x,%04x)\n",g, g,n);
@@ -1682,7 +1876,7 @@ bool gdcmParser::IsHeaderEntryAnInteger(gdcmHeaderEntry *Entry)
          errno = 1;
          return 0;
       }
-      if ( n == 0xe0dd || ( g==0xb00c && n==0x0eb6 ) ) /* for bogus header  */ 
+      if ( n == 0xe0dd || ( g==0xb00c && n==0x0eb6 ) ) // for bogus header 
          FoundSequenceDelimiter = true;
       else if ( n != 0xe000 )
       {
@@ -1703,43 +1897,35 @@ bool gdcmParser::IsHeaderEntryAnInteger(gdcmHeaderEntry *Entry)
 }
 
 /**
- * \ingroup gdcmParser
  * \brief Reads a supposed to be 16 Bits integer
- * \     (swaps it depending on processor endianity) 
- *
- * @return integer acts as a boolean
+ *       (swaps it depending on processor endianity) 
+ * @return read value
  */
-guint16 gdcmParser::ReadInt16(void) 
-{
+guint16 gdcmParser::ReadInt16(void) {
    guint16 g;
    size_t item_read;
    item_read = fread (&g, (size_t)2,(size_t)1, fp);
-   if ( item_read != 1 ) 
-   {
+   if ( item_read != 1 ) {
       if(ferror(fp)) 
          dbg.Verbose(0, "gdcmParser::ReadInt16", " File Error");
       errno = 1;
       return 0;
    }
    errno = 0;
-   g = SwapShort(g);
+   g = SwapShort(g);   
    return g;
 }
 
 /**
- * \ingroup gdcmParser
  * \brief  Reads a supposed to be 32 Bits integer
- * \       (swaps it depending on processor endianity)  
- *
- * @return 
+ *         (swaps it depending on processor endianity)  
+ * @return read value
  */
-guint32 gdcmParser::ReadInt32(void) 
-{
+guint32 gdcmParser::ReadInt32(void) {
    guint32 g;
    size_t item_read;
    item_read = fread (&g, (size_t)4,(size_t)1, fp);
-   if ( item_read != 1 ) 
-   { 
+   if ( item_read != 1 ) { 
      if(ferror(fp)) 
          dbg.Verbose(0, "gdcmParser::ReadInt32", " File Error");   
       errno = 1;
@@ -1751,20 +1937,18 @@ guint32 gdcmParser::ReadInt32(void)
 }
 
 /**
- * \ingroup gdcmParser
- * \brief   
- *
+ * \brief skips bytes inside the source file 
+ * \warning NOT end user intended method !
  * @return 
  */
-void gdcmParser::SkipBytes(guint32 NBytes) 
-{
+void gdcmParser::SkipBytes(guint32 NBytes) {
    //FIXME don't dump the returned value
    (void)fseek(fp, (long)NBytes, SEEK_CUR);
 }
 
 /**
- * \ingroup gdcmParser
- * \brief   
+ * \brief Loads all the needed Dictionaries
+ * \warning NOT end user intended method !   
  */
 void gdcmParser::Initialise(void) 
 {
@@ -1773,61 +1957,25 @@ void gdcmParser::Initialise(void)
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Discover what the swap code is (among little endian, big endian,
  *          bad little endian, bad big endian).
- *
+ *          sw is set
+ * @return false when we are absolutely sure 
+ *               it's neither ACR-NEMA nor DICOM
+ *         true  when we hope ours assuptions are OK
  */
-void gdcmParser::CheckSwap()
-{
-   // Fourth semantics:
-   //
-   // ---> Warning : This fourth field is NOT part 
-   //                of the 'official' Dicom Dictionnary
-   //                and should NOT be used.
-   //                (Not defined for all the groups
-   //                 may be removed in a future release)
-   //
-   // CMD      Command        
-   // META     Meta Information 
-   // DIR      Directory
-   // ID
-   // PAT      Patient
-   // ACQ      Acquisition
-   // REL      Related
-   // IMG      Image
-   // SDY      Study
-   // VIS      Visit 
-   // WAV      Waveform
-   // PRC
-   // DEV      Device
-   // NMI      Nuclear Medicine
-   // MED
-   // BFS      Basic Film Session
-   // BFB      Basic Film Box
-   // BIB      Basic Image Box
-   // BAB
-   // IOB
-   // PJ
-   // PRINTER
-   // RT       Radio Therapy
-   // DVH   
-   // SSET
-   // RES      Results
-   // CRV      Curve
-   // OLY      Overlays
-   // PXL      Pixels
-   // DL       Delimiters
-   //
+bool gdcmParser::CheckSwap() {
 
    // The only guaranted way of finding the swap code is to find a
    // group tag since we know it's length has to be of four bytes i.e.
    // 0x00000004. Finding the swap code in then straigthforward. Trouble
    // occurs when we can't find such group...
-   guint32  s;
+   
    guint32  x=4;  // x : for ntohs
    bool net2host; // true when HostByteOrder is the same as NetworkByteOrder
-    
+   guint32  s32;
+   guint16  s16;
+       
    int lgrLue;
    char *entCur;
    char deb[HEADER_LENGTH_TO_READ];
@@ -1838,16 +1986,15 @@ void gdcmParser::CheckSwap()
       net2host = true;
    else
       net2host = false; 
-    //cout << net2host << endl;
          
    // The easiest case is the one of a DICOM header, since it possesses a
    // file preamble where it suffice to look for the string "DICM".
    lgrLue = fread(deb, 1, HEADER_LENGTH_TO_READ, fp);
    
    entCur = deb + 128;
-   if(memcmp(entCur, "DICM", (size_t)4) == 0) 
-   {
+   if(memcmp(entCur, "DICM", (size_t)4) == 0) {
       dbg.Verbose(1, "gdcmParser::CheckSwap:", "looks like DICOM Version3");
+      
       // Next, determine the value representation (VR). Let's skip to the
       // first element (0002, 0000) and check there if we find "UL" 
       // - or "OB" if the 1st one is (0002,0001) -,
@@ -1864,23 +2011,32 @@ void gdcmParser::CheckSwap()
       // * the 4 bytes of the first tag (0002, 0000),or (0002, 0001)
       // i.e. a total of  136 bytes.
       entCur = deb + 136;
+     
+      // FIXME : FIXME:
+      // Sometimes (see : gdcmData/icone.dcm) group 0x0002 *is* Explicit VR,
+      // but elem 0002,0010 (Transfert Syntax) tells us the file is
+      // *Implicit* VR.  -and it is !- 
+      
+      if( (memcmp(entCur, "UL", (size_t)2) == 0) ||
+          (memcmp(entCur, "OB", (size_t)2) == 0) ||
+          (memcmp(entCur, "UI", (size_t)2) == 0) ||
+          (memcmp(entCur, "CS", (size_t)2) == 0) )  // CS, to remove later
+                                                    // when Write DCM *adds*
       // FIXME
       // Use gdcmParser::dicom_vr to test all the possibilities
-      // instead of just checking for UL, OB and UI !?
-      if(  (memcmp(entCur, "UL", (size_t)2) == 0) ||
-      	  (memcmp(entCur, "OB", (size_t)2) == 0) ||
-      	  (memcmp(entCur, "UI", (size_t)2) == 0) )   
+      // instead of just checking for UL, OB and UI !? group 0000 
       {
-         filetype = ExplicitVR;
+         filetype = gdcmExplicitVR;
          dbg.Verbose(1, "gdcmParser::CheckSwap:",
                      "explicit Value Representation");
       } 
       else 
       {
-         filetype = ImplicitVR;
+         filetype = gdcmImplicitVR;
          dbg.Verbose(1, "gdcmParser::CheckSwap:",
                      "not an explicit Value Representation");
       }
+      
       if (net2host) 
       {
          sw = 4321;
@@ -1898,7 +2054,7 @@ void gdcmParser::CheckSwap()
       // after the file preamble and the "DICM" string).
       rewind(fp);
       fseek (fp, 132L, SEEK_SET);
-      return;
+      return true;
    } // End of DicomV3
 
    // Alas, this is not a DicomV3 file and whatever happens there is no file
@@ -1916,46 +2072,76 @@ void gdcmParser::CheckSwap()
    // We assume the array of char we are considering contains the binary
    // representation of a 32 bits integer. Hence the following dirty
    // trick :
-   s = *((guint32 *)(entCur));
-   
-   switch (s)
-   {
+   s32 = *((guint32 *)(entCur));
+      
+   switch (s32) {
       case 0x00040000 :
          sw = 3412;
-         filetype = ACR;
-         return;
+         filetype = gdcmACR;
+         return true;
       case 0x04000000 :
          sw = 4321;
-         filetype = ACR;
-         return;
+         filetype = gdcmACR;
+         return true;
       case 0x00000400 :
          sw = 2143;
-         filetype = ACR;
-         return;
+         filetype = gdcmACR;
+         return true;
       case 0x00000004 :
          sw = 0;
-         filetype = ACR;
-         return;
+         filetype = gdcmACR;
+         return true;
       default :
-         dbg.Verbose(0, "gdcmParser::CheckSwap:",
-                        "ACR/NEMA unfound swap info (time to raise bets)");
-   }
 
-   // We are out of luck. It is not a DicomV3 nor a 'clean' ACR/NEMA file.
-   // It is time for despaired wild guesses. So, let's assume this file
-   // happens to be 'dirty' ACR/NEMA, i.e. the length of the group is
-   // not present. Then the only info we have is the net2host one.
-   filetype = Unknown;
-   if (! net2host )
-      sw = 0;
-   else
-      sw = 4321;
-   return;
+      // We are out of luck. It is not a DicomV3 nor a 'clean' ACR/NEMA file.
+      // It is time for despaired wild guesses. 
+      // So, let's check if this file wouldn't happen to be 'dirty' ACR/NEMA,
+      //  i.e. the 'group length' element is not present :     
+      
+      //  check the supposed to be 'group number'
+      //  0x0002 or 0x0004 or 0x0008
+      //  to determine ' sw' value .
+      //  Only 0 or 4321 will be possible 
+      //  (no oportunity to check for the formerly well known
+      //  ACR-NEMA 'Bad Big Endian' or 'Bad Little Endian' 
+      //  if unsuccessfull (i.e. neither 0x0002 nor 0x0200 etc -4, 8-) 
+      //  the file IS NOT ACR-NEMA nor DICOM V3
+      //  Find a trick to tell it the caller...
+      
+		s16 = *((guint16 *)(deb));
+	      
+		switch (s16) {
+			case 0x0002 :
+			case 0x0004 :
+			case 0x0008 :      
+				sw = 0;
+				filetype = gdcmACR;
+				return true;
+			case 0x0200 :
+			case 0x0400 :
+			case 0x0800 : 
+				sw = 4321;
+				filetype = gdcmACR;
+				return true;
+			default :
+				dbg.Verbose(0, "gdcmParser::CheckSwap:",
+							"ACR/NEMA unfound swap info (Really hopeless !)"); 
+				filetype = gdcmUnknown;     
+				return false;
+		}
+      
+      // Then the only info we have is the net2host one.
+      //if (! net2host )
+         //   sw = 0;
+         //else
+         //  sw = 4321;
+         //return;
+   }
 }
 
 /**
- * \ingroup gdcmParser
- * \brief   
+ * \brief Restore the unproperly loaded values i.e. the group, the element
+ *        and the dictionary entry depending on them. 
  */
 void gdcmParser::SwitchSwapToBigEndian(void) 
 {
@@ -1981,10 +2167,8 @@ void gdcmParser::SwitchSwapToBigEndian(void)
 }
 
 /**
- * \ingroup gdcmParser
- * \brief   
+ * \brief  during parsing, Header Elements too long are not loaded in memory 
  * @param NewSize
- * @return 
  */
 void gdcmParser::SetMaxSizeLoadEntry(long NewSize) 
 {
@@ -1998,8 +2182,25 @@ void gdcmParser::SetMaxSizeLoadEntry(long NewSize)
    MaxSizeLoadEntry = NewSize;
 }
 
+
+/**
+ * \brief Header Elements too long will not be printed
+ * \todo  See comments of \ref gdcmParser::MAX_SIZE_PRINT_ELEMENT_VALUE 
+ * @param NewSize
+ */
+void gdcmParser::SetMaxSizePrintEntry(long NewSize) 
+{
+   if (NewSize < 0)
+      return;
+   if ((guint32)NewSize >= (guint32)0xffffffff) 
+   {
+      MaxSizePrintEntry = 0xffffffff;
+      return;
+   }
+   MaxSizePrintEntry = NewSize;
+}
+
 /**
- * \ingroup gdcmParser
  * \brief   Searches both the public and the shadow dictionary (when they
  *          exist) for the presence of the DictEntry with given name.
  *          The public dictionary has precedence on the shadow one.
@@ -2030,7 +2231,6 @@ gdcmDictEntry *gdcmParser::GetDictEntryByName(std::string Name)
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Searches both the public and the shadow dictionary (when they
  *          exist) for the presence of the DictEntry with given
  *          group and element. The public dictionary has precedence on the
@@ -2063,39 +2263,42 @@ gdcmDictEntry *gdcmParser::GetDictEntryByNumber(guint16 group,guint16 element)
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Read the next tag but WITHOUT loading it's value
  * @return  On succes the newly created HeaderEntry, NULL on failure.      
  */
-gdcmHeaderEntry *gdcmParser::ReadNextHeaderEntry(void) 
-{
+gdcmHeaderEntry *gdcmParser::ReadNextHeaderEntry(void) {
    guint16 g,n;
    gdcmHeaderEntry *NewEntry;
-   
    g = ReadInt16();
    n = ReadInt16();
       
    if (errno == 1)
-      // We reached the EOF (or an error occured) and header parsing
-      // has to be considered as finished.
+      // We reached the EOF (or an error occured) therefore 
+      // header parsing has to be considered as finished.
       return (gdcmHeaderEntry *)0;
+
+// Pb : how to propagate the element length (used in SkipHeaderEntry)
+//       direct call to SkipBytes ?
    
+//   if (ignoreShadow == 1 && g%2 ==1)
+      // if user wants to skip shadow groups
+      // and current element *is* a shadow element
+      // we don't create anything
+//      return (gdcmHeaderEntry *)1; // to tell caller it's NOT finished
+  
    NewEntry = NewHeaderEntryByNumber(g, n);
    FindHeaderEntryVR(NewEntry);
    FindHeaderEntryLength(NewEntry);
-	
-   if (errno == 1) 
-   {
+
+   if (errno == 1) {
       // Call it quits
       return NULL;
    }
    NewEntry->SetOffset(ftell(fp));  
-   //if ( (g==0x7fe0) && (n==0x0010) ) 
    return NewEntry;
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Build a new Element Value from all the low level arguments. 
  *          Check for existence of dictionary entry, and build
  *          a default one when absent.
@@ -2105,7 +2308,7 @@ gdcmHeaderEntry *gdcmParser::NewHeaderEntryByName(std::string Name)
 {
    gdcmDictEntry *NewTag = GetDictEntryByName(Name);
    if (!NewTag)
-      NewTag = NewVirtualDictEntry(0xffff, 0xffff, "LO", "Unknown", Name);
+      NewTag = NewVirtualDictEntry(0xffff, 0xffff, "LO", "unkn", Name);
 
    gdcmHeaderEntry* NewEntry = new gdcmHeaderEntry(NewTag);
    if (!NewEntry) 
@@ -2118,10 +2321,9 @@ gdcmHeaderEntry *gdcmParser::NewHeaderEntryByName(std::string Name)
 }  
 
 /**
- * \ingroup gdcmParser
  * \brief   Request a new virtual dict entry to the dict set
  * @param   group  group   of the underlying DictEntry
- * @param   elem   element of the underlying DictEntry
+ * @param   element  element of the underlying DictEntry
  * @param   vr     VR of the underlying DictEntry
  * @param   fourth owner group
  * @param   name   english name
@@ -2135,7 +2337,6 @@ gdcmDictEntry *gdcmParser::NewVirtualDictEntry(guint16 group, guint16 element,
 }
 
 /**
- * \ingroup gdcmParser
  * \brief   Build a new Element Value from all the low level arguments. 
  *          Check for existence of dictionary entry, and build
  *          a default one when absent.
@@ -2145,11 +2346,11 @@ gdcmDictEntry *gdcmParser::NewVirtualDictEntry(guint16 group, guint16 element,
 gdcmHeaderEntry *gdcmParser::NewHeaderEntryByNumber(guint16 Group, guint16 Elem) 
 {
    // Find out if the tag we encountered is in the dictionaries:
-   gdcmDictEntry *NewTag = GetDictEntryByNumber(Group, Elem);
-   if (!NewTag)
-      NewTag = NewVirtualDictEntry(Group, Elem);
+   gdcmDictEntry *DictEntry = GetDictEntryByNumber(Group, Elem);
+   if (!DictEntry)
+      DictEntry = NewVirtualDictEntry(Group, Elem);
 
-   gdcmHeaderEntry* NewEntry = new gdcmHeaderEntry(NewTag);
+   gdcmHeaderEntry *NewEntry = new gdcmHeaderEntry(DictEntry);
    if (!NewEntry) 
    {
       dbg.Verbose(1, "gdcmParser::NewHeaderEntryByNumber",
@@ -2159,8 +2360,8 @@ gdcmHeaderEntry *gdcmParser::NewHeaderEntryByNumber(guint16 Group, guint16 Elem)
    return NewEntry;
 }
 
+/// \todo Never used; commented out, waiting for removal.
 /**
- * \ingroup gdcmParser
  * \brief   Small utility function that creates a new manually crafted
  *          (as opposed as read from the file) gdcmHeaderEntry with user
  *          specified name and adds it to the public tag hash table.
@@ -2169,31 +2370,30 @@ gdcmHeaderEntry *gdcmParser::NewHeaderEntryByNumber(guint16 Group, guint16 Elem)
  * @param   VR The Value Representation to be given to this new tag.
  * @return  The newly hand crafted Element Value.
  */
-gdcmHeaderEntry *gdcmParser::NewManualHeaderEntryToPubDict(std::string NewTagName, 
-                                                           std::string VR) 
-{
-   gdcmHeaderEntry *NewEntry = NULL;
-   guint32 StuffGroup = 0xffff;   // Group to be stuffed with additional info
-   guint32 FreeElem = 0;
-   gdcmDictEntry *DictEntry = NULL;
-
-   FreeElem = GenerateFreeTagKeyInGroup(StuffGroup);
-   if (FreeElem == UINT32_MAX) 
-   {
-      dbg.Verbose(1, "gdcmHeader::NewManualHeaderEntryToPubDict",
-                     "Group 0xffff in Public Dict is full");
-      return NULL;
-   }
-
-   DictEntry = NewVirtualDictEntry(StuffGroup, FreeElem,
-                                VR, "GDCM", NewTagName);
-   NewEntry = new gdcmHeaderEntry(DictEntry);
-   AddHeaderEntry(NewEntry);
-   return NewEntry;
-}
+//gdcmHeaderEntry *gdcmParser::NewManualHeaderEntryToPubDict(std::string NewTagName, 
+//                                                           std::string VR) 
+//{
+//   gdcmHeaderEntry *NewEntry = NULL;
+//   guint32 StuffGroup = 0xffff;   // Group to be stuffed with additional info
+//   guint32 FreeElem = 0;
+//   gdcmDictEntry *DictEntry = NULL;
+//
+//   FreeElem = GenerateFreeTagKeyInGroup(StuffGroup);
+//   if (FreeElem == UINT32_MAX) 
+//   {
+//      dbg.Verbose(1, "gdcmHeader::NewManualHeaderEntryToPubDict",
+//                     "Group 0xffff in Public Dict is full");
+//      return NULL;
+//   }
+//
+//   DictEntry = NewVirtualDictEntry(StuffGroup, FreeElem,
+//                                VR, "GDCM", NewTagName);
+//   NewEntry = new gdcmHeaderEntry(DictEntry);
+//   AddHeaderEntry(NewEntry);
+//   return NewEntry;
+//}
 
 /**
- * \ingroup gdcmParser
  * \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.