]> Creatis software - gdcm.git/blobdiff - src/gdcmHeader.cxx
ENH: Since HandleOutOfGroup0002 need access to the transfer syntax move the method...
[gdcm.git] / src / gdcmHeader.cxx
index 13e90a3e44e66a1e66c174e3dd529190f89fbb98..b5b3b07afc4f050ee386c8d8a574ed27e313d6a6 100644 (file)
@@ -3,8 +3,8 @@
   Program:   gdcm
   Module:    $RCSfile: gdcmHeader.cxx,v $
   Language:  C++
-  Date:      $Date: 2004/11/09 21:55:55 $
-  Version:   $Revision: 1.199 $
+  Date:      $Date: 2005/01/11 23:06:35 $
+  Version:   $Revision: 1.231 $
                                                                                 
   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
   l'Image). All rights reserved. See Doc/License.txt or
@@ -22,7 +22,8 @@
 #include "gdcmDebug.h"
 #include "gdcmTS.h"
 #include "gdcmValEntry.h"
-#include <stdio.h>
+#include "gdcmBinEntry.h"
+#include <stdio.h> //sscanf
 
 #include <vector>
 
@@ -34,7 +35,7 @@ namespace gdcm
  * \brief  Constructor 
  * @param  filename name of the file whose header we want to analyze
  */
-Header::Header( std::string const & filename ):
+Header::Header( std::string const &filename ):
             Document( filename )
 {    
    // for some ACR-NEMA images GrPixel, NumPixel is *not* 7fe0,0010
@@ -44,11 +45,11 @@ Header::Header( std::string const & filename ):
    // is found by indirection through the "Image Location").
    // Inside the group pointed by "Image Location" the searched element
    // is conventionally the element 0x0010 (when the norm is respected).
-   // When the "Image Location" is absent we default to group 0x7fe0.
+   // When the "Image Location" is Missing we default to group 0x7fe0.
    // Note: this IS the right place for the code
  
    // Image Location
-   std::string imgLocation = GetEntryByNumber(0x0028, 0x0200);
+   const std::string &imgLocation = GetEntry(0x0028, 0x0200);
    if ( imgLocation == GDCM_UNFOUND )
    {
       // default value
@@ -76,14 +77,38 @@ Header::Header( std::string const & filename ):
    {
       NumPixel = 0x0010;
    }
+
+   // Now, we know GrPixel and NumPixel.
+   // Let's create a VirtualDictEntry to allow a further VR modification
+   // and force VR to match with BitsAllocated.
+
+   DocEntry *entry = GetDocEntry(GrPixel, NumPixel); 
+   if ( entry != 0 )
+   {
+
+      std::string PixelVR;
+      // 8 bits allocated is a 'O Bytes' , as well as 24 (old ACR-NEMA RGB)
+      // more than 8 (i.e 12, 16) is a 'O Words'
+      if ( GetBitsAllocated() == 8 || GetBitsAllocated() == 24 ) 
+         PixelVR = "OB";
+      else
+         PixelVR = "OW";
+
+      DictEntry* newEntry = NewVirtualDictEntry(
+                             GrPixel, NumPixel,
+                             PixelVR, "PXL", "Pixel Data");
+      entry->SetDictEntry( newEntry );
+   } 
 }
 
 /**
- * \brief Constructor  
+ * \brief Constructor used when we want to generate dicom files from scratch
  */
 Header::Header()
            :Document()
 {
+   InitializeDefaultHeader();
 }
 
 /**
@@ -93,32 +118,39 @@ Header::~Header ()
 {
 }
 
-
 /**
  * \brief Performs some consistency checking on various 'File related' 
  *       (as opposed to 'DicomDir related') entries 
  *       then writes in a file all the (Dicom Elements) included the Pixels 
- * @param fp file pointer on an already open file
+ * @param fileName file name to write to
  * @param filetype Type of the File to be written 
  *          (ACR-NEMA, ExplicitVR, ImplicitVR)
  */
-void Header::Write(std::ofstream* fp,FileType filetype)
+bool Header::Write(std::string fileName, FileType filetype)
 {
+   std::ofstream *fp = new std::ofstream(fileName.c_str(), 
+                                         std::ios::out | std::ios::binary);
+   if (*fp == NULL)
+   {
+      gdcmVerboseMacro("Failed to open (write) File: " << fileName.c_str());
+      return false;
+   }
+
    // Bits Allocated
-   if ( GetEntryByNumber(0x0028,0x0100) ==  "12")
+   if ( GetEntry(0x0028,0x0100) ==  "12")
    {
-      SetEntryByNumber("16", 0x0028,0x0100);
+      SetEntry("16", 0x0028,0x0100);
    }
 
   /// \todo correct 'Pixel group' Length if necessary
 
-   int i_lgPix = GetEntryLengthByNumber(GrPixel, NumPixel);
+   int i_lgPix = GetEntryLength(GrPixel, NumPixel);
    if (i_lgPix != -2)
    {
       // no (GrPixel, NumPixel) element
       std::string s_lgPix = Util::Format("%d", i_lgPix+12);
       s_lgPix = Util::DicomString( s_lgPix.c_str() );
-      ReplaceOrCreateByNumber(s_lgPix,GrPixel, 0x0000);
+      ReplaceOrCreate(s_lgPix,GrPixel, 0x0000);
    }
 
    // FIXME : should be nice if we could move it to File
@@ -126,44 +158,78 @@ void Header::Write(std::ofstream* fp,FileType filetype)
 
    // Drop Palette Color, if necessary
    
-   if ( GetEntryByNumber(0x0028,0x0002).c_str()[0] == '3' )
+   if ( GetEntry(0x0028,0x0002).c_str()[0] == '3' )
    {
       // if SamplesPerPixel = 3, sure we don't need any LUT !   
       // Drop 0028|1101, 0028|1102, 0028|1103
       // Drop 0028|1201, 0028|1202, 0028|1203
 
-      DocEntry* e = GetDocEntryByNumber(0x0028,0x01101);
+      DocEntry *e = GetDocEntry(0x0028,0x01101);
       if (e)
       {
          RemoveEntryNoDestroy(e);
       }
-      e = GetDocEntryByNumber(0x0028,0x1102);
+      e = GetDocEntry(0x0028,0x1102);
       if (e)
       {
          RemoveEntryNoDestroy(e);
       }
-      e = GetDocEntryByNumber(0x0028,0x1103);
+      e = GetDocEntry(0x0028,0x1103);
       if (e)
       {
          RemoveEntryNoDestroy(e);
       }
-      e = GetDocEntryByNumber(0x0028,0x01201);
+      e = GetDocEntry(0x0028,0x01201);
       if (e)
       {
          RemoveEntryNoDestroy(e);
       }
-      e = GetDocEntryByNumber(0x0028,0x1202);
+      e = GetDocEntry(0x0028,0x1202);
       if (e)
       {
          RemoveEntryNoDestroy(e);
       }
-      e = GetDocEntryByNumber(0x0028,0x1203);
+      e = GetDocEntry(0x0028,0x1203);
       if (e)
       {
           RemoveEntryNoDestroy(e);
       }
    }
-   Document::Write(fp,filetype);
+
+#ifdef GDCM_WORDS_BIGENDIAN
+   // Super Duper hack that will make gdcm a BOMB ! but should
+   // Fix temporarily the dashboard
+   BinEntry *b = GetBinEntry(0x7fe0,0x0010);
+   if ( GetEntry(0x0028,0x0100) ==  "16")
+   {
+      uint16_t *im16 = (uint16_t*)b->GetBinArea();
+      int lgr = b->GetLength();
+      for( int i = 0; i < lgr / 2; i++ )
+      {
+         im16[i]= (im16[i] >> 8) | (im16[i] << 8 );
+      }
+   }
+#endif //GDCM_WORDS_BIGENDIAN
+
+   Document::WriteContent(fp,filetype);
+
+#ifdef GDCM_WORDS_BIGENDIAN
+   // Flip back the pixel ... I told you this is a hack
+   if ( GetEntry(0x0028,0x0100) ==  "16")
+   {
+      uint16_t *im16 = (uint16_t*)b->GetBinArea();
+      int lgr = b->GetLength();
+      for( int i = 0; i < lgr / 2; i++ )
+      {
+         im16[i]= (im16[i] >> 8) | (im16[i] << 8 );
+      }
+   }
+#endif //GDCM_WORDS_BIGENDIAN
+
+   fp->close();
+   delete fp;
+
+   return true;
 }
 
 //-----------------------------------------------------------------------------
@@ -188,24 +254,24 @@ bool Header::IsReadable()
       return false;
    }
 
-   std::string res = GetEntryByNumber(0x0028, 0x0005);
+   const std::string &res = GetEntry(0x0028, 0x0005);
    if ( res != GDCM_UNFOUND && atoi(res.c_str()) > 4 )
    {
       return false; // Image Dimensions
    }
-   if ( !GetDocEntryByNumber(0x0028, 0x0100) )
+   if ( !GetDocEntry(0x0028, 0x0100) )
    {
       return false; // "Bits Allocated"
    }
-   if ( !GetDocEntryByNumber(0x0028, 0x0101) )
+   if ( !GetDocEntry(0x0028, 0x0101) )
    {
       return false; // "Bits Stored"
    }
-   if ( !GetDocEntryByNumber(0x0028, 0x0102) )
+   if ( !GetDocEntry(0x0028, 0x0102) )
    {
       return false; // "High Bit"
    }
-   if ( !GetDocEntryByNumber(0x0028, 0x0103) )
+   if ( !GetDocEntry(0x0028, 0x0103) )
    {
       return false; // "Pixel Representation" i.e. 'Sign'
    }
@@ -220,8 +286,7 @@ bool Header::IsReadable()
  */
 int Header::GetXSize()
 {
-   std::string strSize;
-   strSize = GetEntryByNumber(0x0028,0x0011);
+   const std::string &strSize = GetEntry(0x0028,0x0011);
    if ( strSize == GDCM_UNFOUND )
    {
       return 0;
@@ -238,7 +303,7 @@ int Header::GetXSize()
  */
 int Header::GetYSize()
 {
-   std::string strSize = GetEntryByNumber(0x0028,0x0010);
+   const std::string &strSize = GetEntry(0x0028,0x0010);
    if ( strSize != GDCM_UNFOUND )
    {
       return atoi( strSize.c_str() );
@@ -249,7 +314,7 @@ int Header::GetYSize()
    }
 
    // The Rows (0028,0010) entry was optional for ACR/NEMA. It might
-   // hence be a signal (1d image). So we default to 1:
+   // hence be a signal (1D image). So we default to 1:
    return 1;
 }
 
@@ -257,7 +322,7 @@ int Header::GetYSize()
  * \brief   Retrieve the number of planes of volume or the number
  *          of frames of a multiframe.
  * \warning When present we consider the "Number of Frames" as the third
- *          dimension. When absent we consider the third dimension as
+ *          dimension. When Missing we consider the third dimension as
  *          being the ACR-NEMA "Planes" tag content.
  * @return  The encountered size when found, 1 by default (single image).
  */
@@ -265,17 +330,17 @@ int Header::GetZSize()
 {
    // Both  DicomV3 and ACR/Nema consider the "Number of Frames"
    // as the third dimension.
-   std::string strSize = GetEntryByNumber(0x0028,0x0008);
+   const std::string &strSize = GetEntry(0x0028,0x0008);
    if ( strSize != GDCM_UNFOUND )
    {
       return atoi( strSize.c_str() );
    }
 
    // We then consider the "Planes" entry as the third dimension 
-   strSize = GetEntryByNumber(0x0028,0x0012);
-   if ( strSize != GDCM_UNFOUND )
+   const std::string &strSize2 = GetEntry(0x0028,0x0012);
+   if ( strSize2 != GDCM_UNFOUND )
    {
-      return atoi( strSize.c_str() );
+      return atoi( strSize2.c_str() );
    }
 
    return 1;
@@ -289,11 +354,11 @@ int Header::GetZSize()
 float Header::GetXSpacing()
 {
    float xspacing, yspacing;
-   std::string strSpacing = GetEntryByNumber(0x0028,0x0030);
+   const std::string &strSpacing = GetEntry(0x0028,0x0030);
 
    if ( strSpacing == GDCM_UNFOUND )
    {
-      dbg.Verbose(0, "Header::GetXSpacing: unfound Pixel Spacing (0028,0030)");
+      gdcmVerboseMacro( "Unfound Pixel Spacing (0028,0030)" );
       return 1.;
    }
 
@@ -304,14 +369,26 @@ float Header::GetXSpacing()
       // if single value is found, xspacing is defaulted to yspacing
       if ( nbValues == 1 )
       {
-         return yspacing;
+         xspacing = yspacing;
       }
+
+      if ( xspacing == 0.0 )
+         xspacing = 1.0;
+
+      return xspacing;
+
    }
+
+   // to avoid troubles with David Clunie's-like images
+   if ( xspacing == 0. && yspacing == 0.)
+      return 1.;
+
    if ( xspacing == 0.)
    {
-      dbg.Verbose(0, "Header::GetYSpacing: gdcmData/CT-MONO2-8-abdo.dcm problem");
+      gdcmVerboseMacro("gdcmData/CT-MONO2-8-abdo.dcm problem");
       // seems to be a bug in the header ...
-      sscanf( strSpacing.c_str(), "%f\\0\\%f", &yspacing, &xspacing);
+      nbValues = sscanf( strSpacing.c_str(), "%f\\0\\%f", &yspacing, &xspacing);
+      gdcmAssertMacro( nbValues == 2 );
    }
 
    return xspacing;
@@ -324,25 +401,28 @@ float Header::GetXSpacing()
   */
 float Header::GetYSpacing()
 {
-   float yspacing = 0;
-   std::string strSpacing = GetEntryByNumber(0x0028,0x0030);
+   float yspacing = 1.;
+   std::string strSpacing = GetEntry(0x0028,0x0030);
   
    if ( strSpacing == GDCM_UNFOUND )
    {
-      dbg.Verbose(0, "Header::GetYSpacing: unfound Pixel Spacing (0028,0030)");
+      gdcmVerboseMacro("Unfound Pixel Spacing (0028,0030)");
       return 1.;
     }
 
    // if sscanf cannot read any float value, it won't affect yspacing
    sscanf( strSpacing.c_str(), "%f", &yspacing);
 
+   if ( yspacing == 0.0 )
+      yspacing = 1.0;
+
    return yspacing;
 } 
 
 /**
  * \brief gets the info from 0018,0088 : Space Between Slices
- *                else from 0018,0050 : Slice Thickness
- *                else 1.0
+ *                 else from 0018,0050 : Slice Thickness
+ *                 else 1.0
  * @return Z dimension of a voxel-to be
  */
 float Header::GetZSpacing()
@@ -354,17 +434,18 @@ float Header::GetZSpacing()
    //   disjointes    (Spacing between Slices > Slice Thickness)
    // Slice Thickness : epaisseur de tissus sur laquelle est acquis le signal
    //   ca interesse le physicien de l'IRM, pas le visualisateur de volumes ...
-   //   Si le Spacing Between Slices est absent
+   //   Si le Spacing Between Slices est Missing
    //   on suppose que les coupes sont jointives
    
-   std::string strSpacingBSlices = GetEntryByNumber(0x0018,0x0088);
+   const std::string &strSpacingBSlices = GetEntry(0x0018,0x0088);
 
    if ( strSpacingBSlices == GDCM_UNFOUND )
    {
-      dbg.Verbose(0, "Header::GetZSpacing: unfound StrSpacingBSlices");
-      std::string strSliceThickness = GetEntryByNumber(0x0018,0x0050);       
+      gdcmVerboseMacro("Unfound Spacing Between Slices (0018,0088)");
+      const std::string &strSliceThickness = GetEntry(0x0018,0x0050);       
       if ( strSliceThickness == GDCM_UNFOUND )
       {
+         gdcmVerboseMacro("Unfound Slice Thickness (0018,0050)");
          return 1.;
       }
       else
@@ -373,13 +454,11 @@ float Header::GetZSpacing()
          // we assume slices join together
          // (no overlapping, no interslice gap)
          // if they don't, we're fucked up
-         return atof( strSliceThickness.c_str() );
+         return (float)atof( strSliceThickness.c_str() );
       }
    }
-   else
-   {
-      return atof( strSpacingBSlices.c_str() );
-   }
+   //else
+   return (float)atof( strSpacingBSlices.c_str() );
 }
 
 /**
@@ -390,14 +469,13 @@ float Header::GetRescaleIntercept()
 {
    float resInter = 0.;
    /// 0028 1052 DS IMG Rescale Intercept
-   std::string strRescInter = GetEntryByNumber(0x0028,0x1052);
+   const std::string &strRescInter = GetEntry(0x0028,0x1052);
    if ( strRescInter != GDCM_UNFOUND )
    {
       if( sscanf( strRescInter.c_str(), "%f", &resInter) != 1 )
       {
          // bug in the element 0x0028,0x1052
-         dbg.Verbose(0, "Header::GetRescaleIntercept: Rescale Slope "
-                        "is empty");
+         gdcmVerboseMacro( "Rescale Intercept (0028,1052) is empty." );
       }
    }
 
@@ -412,13 +490,13 @@ float Header::GetRescaleSlope()
 {
    float resSlope = 1.;
    //0028 1053 DS IMG Rescale Slope
-   std::string strRescSlope = GetEntryByNumber(0x0028,0x1053);
+   std::string strRescSlope = GetEntry(0x0028,0x1053);
    if ( strRescSlope != GDCM_UNFOUND )
    {
       if( sscanf( strRescSlope.c_str(), "%f", &resSlope) != 1)
       {
          // bug in the element 0x0028,0x1053
-         dbg.Verbose(0, "Header::GetRescaleSlope: Rescale Slope is empty");
+         gdcmVerboseMacro( "Rescale Slope (0028,1053) is empty.");
       }
    }
 
@@ -441,12 +519,12 @@ int Header::GetNumberOfScalarComponents()
       
    // 0028 0100 US IMG Bits Allocated
    // (in order no to be messed up by old RGB images)
-   if ( GetEntryByNumber(0x0028,0x0100) == "24" )
+   if ( GetEntry(0x0028,0x0100) == "24" )
    {
       return 3;
    }
        
-   std::string strPhotometricInterpretation = GetEntryByNumber(0x0028,0x0004);
+   std::string strPhotometricInterpretation = GetEntry(0x0028,0x0004);
 
    if ( ( strPhotometricInterpretation == "PALETTE COLOR ") )
    {
@@ -463,8 +541,8 @@ int Header::GetNumberOfScalarComponents()
    // beware of trailing space at end of string      
    // DICOM tags are never of odd length
    if ( strPhotometricInterpretation == GDCM_UNFOUND   || 
-        strPhotometricInterpretation == "MONOCHROME1 " || 
-        strPhotometricInterpretation == "MONOCHROME2 " )
+        Util::DicomStringEqual(strPhotometricInterpretation, "MONOCHROME1") ||
+        Util::DicomStringEqual(strPhotometricInterpretation, "MONOCHROME2") )
    {
       return 1;
    }
@@ -486,7 +564,7 @@ int Header::GetNumberOfScalarComponentsRaw()
 {
    // 0028 0100 US IMG Bits Allocated
    // (in order no to be messed up by old RGB images)
-   if ( Header::GetEntryByNumber(0x0028,0x0100) == "24" )
+   if ( Header::GetEntry(0x0028,0x0100) == "24" )
    {
       return 3;
    }
@@ -520,17 +598,15 @@ int Header::GetNumberOfScalarComponentsRaw()
 float Header::GetXOrigin()
 {
    float xImPos, yImPos, zImPos;  
-   std::string strImPos = GetEntryByNumber(0x0020,0x0032);
+   std::string strImPos = GetEntry(0x0020,0x0032);
 
    if ( strImPos == GDCM_UNFOUND )
    {
-      dbg.Verbose(0, "Header::GetXImagePosition: unfound Image "
-                     "Position Patient (0020,0032)");
-      strImPos = GetEntryByNumber(0x0020,0x0030); // For ACR-NEMA images
+      gdcmVerboseMacro( "Unfound Image Position Patient (0020,0032)");
+      strImPos = GetEntry(0x0020,0x0030); // For ACR-NEMA images
       if ( strImPos == GDCM_UNFOUND )
       {
-         dbg.Verbose(0, "Header::GetXImagePosition: unfound Image "
-                        "Position (RET) (0020,0030)");
+         gdcmVerboseMacro( "Unfound Image Position (RET) (0020,0030)");
          /// \todo How to tell the caller nothing was found ?
          return 0.;
       }
@@ -553,17 +629,15 @@ float Header::GetXOrigin()
 float Header::GetYOrigin()
 {
    float xImPos, yImPos, zImPos;
-   std::string strImPos = GetEntryByNumber(0x0020,0x0032);
+   std::string strImPos = GetEntry(0x0020,0x0032);
 
    if ( strImPos == GDCM_UNFOUND)
    {
-      dbg.Verbose(0, "Header::GetYImagePosition: unfound Image "
-                     "Position Patient (0020,0032)");
-      strImPos = GetEntryByNumber(0x0020,0x0030); // For ACR-NEMA images
+      gdcmVerboseMacro( "Unfound Image Position Patient (0020,0032)");
+      strImPos = GetEntry(0x0020,0x0030); // For ACR-NEMA images
       if ( strImPos == GDCM_UNFOUND )
       {
-         dbg.Verbose(0, "Header::GetYImagePosition: unfound Image "
-                        "Position (RET) (0020,0030)");
+         gdcmVerboseMacro( "Unfound Image Position (RET) (0020,0030)");
          /// \todo How to tell the caller nothing was found ?
          return 0.;
       }  
@@ -588,14 +662,13 @@ float Header::GetYOrigin()
 float Header::GetZOrigin()
 {
    float xImPos, yImPos, zImPos; 
-   std::string strImPos = GetEntryByNumber(0x0020,0x0032);
+   std::string strImPos = GetEntry(0x0020,0x0032);
 
    if ( strImPos != GDCM_UNFOUND )
    {
       if( sscanf( strImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3)
       {
-         dbg.Verbose(0, "Header::GetZImagePosition: wrong Image "
-                        "Position Patient (0020,0032)");
+         gdcmVerboseMacro( "Wrong Image Position Patient (0020,0032)");
          return 0.;  // bug in the element 0x0020,0x0032
       }
       else
@@ -604,13 +677,13 @@ float Header::GetZOrigin()
       }
    }
 
-   strImPos = GetEntryByNumber(0x0020,0x0030); // For ACR-NEMA images
+   strImPos = GetEntry(0x0020,0x0030); // For ACR-NEMA images
    if ( strImPos != GDCM_UNFOUND )
    {
       if( sscanf( strImPos.c_str(), 
           "%f\\%f\\%f", &xImPos, &yImPos, &zImPos ) != 3 )
       {
-         dbg.Verbose(0, "Header::GetZImagePosition: wrong Image Position (RET) (0020,0030)");
+         gdcmVerboseMacro( "Wrong Image Position (RET) (0020,0030)");
          return 0.;  // bug in the element 0x0020,0x0032
       }
       else
@@ -619,12 +692,12 @@ float Header::GetZOrigin()
       }
    }
 
-   std::string strSliceLocation = GetEntryByNumber(0x0020,0x1041); // for *very* old ACR-NEMA images
+   std::string strSliceLocation = GetEntry(0x0020,0x1041); // for *very* old ACR-NEMA images
    if ( strSliceLocation != GDCM_UNFOUND )
    {
       if( sscanf( strSliceLocation.c_str(), "%f", &zImPos) != 1)
       {
-         dbg.Verbose(0, "Header::GetZImagePosition: wrong Slice Location (0020,1041)");
+         gdcmVerboseMacro( "Wrong Slice Location (0020,1041)");
          return 0.;  // bug in the element 0x0020,0x1041
       }
       else
@@ -632,14 +705,14 @@ float Header::GetZOrigin()
          return zImPos;
       }
    }
-   dbg.Verbose(0, "Header::GetZImagePosition: unfound Slice Location (0020,1041)");
+   gdcmVerboseMacro( "Unfound Slice Location (0020,1041)");
 
-   std::string strLocation = GetEntryByNumber(0x0020,0x0050);
+   std::string strLocation = GetEntry(0x0020,0x0050);
    if ( strLocation != GDCM_UNFOUND )
    {
       if( sscanf( strLocation.c_str(), "%f", &zImPos) != 1)
       {
-         dbg.Verbose(0, "Header::GetZImagePosition: wrong Location (0020,0050)");
+         gdcmVerboseMacro( "Wrong Location (0020,0050)");
          return 0.;  // bug in the element 0x0020,0x0050
       }
       else
@@ -647,7 +720,7 @@ float Header::GetZOrigin()
          return zImPos;
       }
    }
-   dbg.Verbose(0, "Header::GetYImagePosition: unfound Location (0020,0050)");  
+   gdcmVerboseMacro( "Unfound Location (0020,0050)");  
 
    return 0.; // Hopeless
 }
@@ -665,7 +738,7 @@ int Header::GetImageNumber()
    // faster function. sscanf() can do all possible conversions whereas
    // atoi() can only do single decimal integer conversions.
    //0020 0013 IS REL Image Number
-   std::string strImNumber = GetEntryByNumber(0x0020,0x0013);
+   std::string strImNumber = GetEntry(0x0020,0x0013);
    if ( strImNumber != GDCM_UNFOUND )
    {
       return atoi( strImNumber.c_str() );
@@ -680,7 +753,7 @@ int Header::GetImageNumber()
 ModalityType Header::GetModality()
 {
    // 0008 0060 CS ID Modality
-   std::string strModality = GetEntryByNumber(0x0008,0x0060);
+   std::string strModality = GetEntry(0x0008,0x0060);
    if ( strModality != GDCM_UNFOUND )
    {
            if ( strModality.find("AU") < strModality.length()) return AU;
@@ -743,11 +816,10 @@ ModalityType Header::GetModality()
  */
 int Header::GetBitsStored()
 {
-   std::string strSize = GetEntryByNumber( 0x0028, 0x0101 );
+   std::string strSize = GetEntry( 0x0028, 0x0101 );
    if ( strSize == GDCM_UNFOUND )
    {
-      dbg.Verbose(0, "Header::GetBitsStored: this is supposed to "
-                     "be mandatory");
+      gdcmVerboseMacro("(0028,0101) is supposed to be mandatory");
       return 0;  // It's supposed to be mandatory
                  // the caller will have to check
    }
@@ -756,17 +828,16 @@ int Header::GetBitsStored()
 
 /**
  * \brief   Retrieve the high bit position.
- * \warning The method defaults to 0 when information is absent.
+ * \warning The method defaults to 0 when information is Missing.
  *          The responsability of checking this value is left to the caller.
- * @return  The high bit positin when present. 0 when absent.
+ * @return  The high bit positin when present. 0 when Missing.
  */
 int Header::GetHighBitPosition()
 {
-   std::string strSize = GetEntryByNumber( 0x0028, 0x0102 );
+   std::string strSize = GetEntry( 0x0028, 0x0102 );
    if ( strSize == GDCM_UNFOUND )
    {
-      dbg.Verbose(0, "Header::GetHighBitPosition: this is supposed "
-                     "to be mandatory");
+      gdcmVerboseMacro( "(0028,0102) is supposed to be mandatory");
       return 0;
    }
    return atoi( strSize.c_str() );
@@ -774,17 +845,16 @@ int Header::GetHighBitPosition()
 
 /**
  * \brief   Check wether the pixels are signed or UNsigned data.
- * \warning The method defaults to false (UNsigned) when information is absent.
+ * \warning The method defaults to false (UNsigned) when information is Missing.
  *          The responsability of checking this value is left to the caller.
  * @return  True when signed, false when UNsigned
  */
 bool Header::IsSignedPixelData()
 {
-   std::string strSize = GetEntryByNumber( 0x0028, 0x0103 );
+   std::string strSize = GetEntry( 0x0028, 0x0103 );
    if ( strSize == GDCM_UNFOUND )
    {
-      dbg.Verbose(0, "Header::IsSignedPixelData: this is supposed "
-                     "to be mandatory");
+      gdcmVerboseMacro( "(0028,0103) is supposed to be mandatory");
       return false;
    }
    int sign = atoi( strSize.c_str() );
@@ -803,11 +873,10 @@ bool Header::IsSignedPixelData()
  */
 int Header::GetBitsAllocated()
 {
-   std::string strSize = GetEntryByNumber(0x0028,0x0100);
+   std::string strSize = GetEntry(0x0028,0x0100);
    if ( strSize == GDCM_UNFOUND )
    {
-      dbg.Verbose(0, "Header::GetBitsStored: this is supposed to "
-                     "be mandatory");
+      gdcmVerboseMacro( "(0028,0100) is supposed to be mandatory");
       return 0; // It's supposed to be mandatory
                 // the caller will have to check
    }
@@ -822,11 +891,10 @@ int Header::GetBitsAllocated()
  */
 int Header::GetSamplesPerPixel()
 {
-   std::string strSize = GetEntryByNumber(0x0028,0x0002);
+   const std::string& strSize = GetEntry(0x0028,0x0002);
    if ( strSize == GDCM_UNFOUND )
    {
-      dbg.Verbose(0, "Header::GetBitsStored: this is supposed to "
-                     "be mandatory");
+      gdcmVerboseMacro( "(0028,0002) is supposed to be mandatory");
       return 1; // Well, it's supposed to be mandatory ...
                 // but sometimes it's missing : *we* assume Gray pixels
    }
@@ -840,16 +908,15 @@ int Header::GetSamplesPerPixel()
  */
 bool Header::IsMonochrome()
 {
-   std::string PhotometricInterp = GetEntryByNumber( 0x0028, 0x0004 );
-   if (   PhotometricInterp == "MONOCHROME1 "
-       || PhotometricInterp == "MONOCHROME2 " )
+   const std::string& PhotometricInterp = GetEntry( 0x0028, 0x0004 );
+   if (  Util::DicomStringEqual(PhotometricInterp, "MONOCHROME1")
+      || Util::DicomStringEqual(PhotometricInterp, "MONOCHROME2") )
    {
       return true;
    }
    if ( PhotometricInterp == GDCM_UNFOUND )
    {
-      dbg.Verbose(0, "Header::IsMonochrome: absent Photometric "
-                     "Interpretation");
+      gdcmVerboseMacro( "Not found : Photometric Interpretation (0028,0004)");
    }
    return false;
 }
@@ -861,15 +928,14 @@ bool Header::IsMonochrome()
  */
 bool Header::IsPaletteColor()
 {
-   std::string PhotometricInterp = GetEntryByNumber( 0x0028, 0x0004 );
+   std::string PhotometricInterp = GetEntry( 0x0028, 0x0004 );
    if (   PhotometricInterp == "PALETTE COLOR " )
    {
       return true;
    }
    if ( PhotometricInterp == GDCM_UNFOUND )
    {
-      dbg.Verbose(0, "Header::IsPaletteColor: absent Photometric "
-                     "Interpretation");
+      gdcmVerboseMacro( "Not found : Palette color (0028,0004)");
    }
    return false;
 }
@@ -881,15 +947,14 @@ bool Header::IsPaletteColor()
  */
 bool Header::IsYBRFull()
 {
-   std::string PhotometricInterp = GetEntryByNumber( 0x0028, 0x0004 );
+   std::string PhotometricInterp = GetEntry( 0x0028, 0x0004 );
    if (   PhotometricInterp == "YBR_FULL" )
    {
       return true;
    }
    if ( PhotometricInterp == GDCM_UNFOUND )
    {
-      dbg.Verbose(0, "Header::IsYBRFull: absent Photometric "
-                     "Interpretation");
+      gdcmVerboseMacro( "Not found : YBR Full (0028,0004)");
    }
    return false;
 }
@@ -901,9 +966,10 @@ bool Header::IsYBRFull()
  */
 int Header::GetPlanarConfiguration()
 {
-   std::string strSize = GetEntryByNumber(0x0028,0x0006);
+   std::string strSize = GetEntry(0x0028,0x0006);
    if ( strSize == GDCM_UNFOUND )
    {
+      gdcmVerboseMacro( "Not found : Planar Configuration (0028,0006)");
       return 0;
    }
    return atoi( strSize.c_str() );
@@ -918,7 +984,7 @@ int Header::GetPixelSize()
 {
    // 0028 0100 US IMG Bits Allocated
    // (in order no to be messed up by old RGB images)
-   //   if (Header::GetEntryByNumber(0x0028,0x0100) == "24")
+   //   if (Header::GetEntry(0x0028,0x0100) == "24")
    //      return 3;
 
    std::string pixelType = GetPixelType();
@@ -938,7 +1004,7 @@ int Header::GetPixelSize()
    {
       return 8;
    }
-   dbg.Verbose(0, "Header::GetPixelSize: Unknown pixel type");
+   gdcmVerboseMacro( "Unknown pixel type");
    return 0;
 }
 
@@ -958,10 +1024,10 @@ int Header::GetPixelSize()
  */
 std::string Header::GetPixelType()
 {
-   std::string bitsAlloc = GetEntryByNumber(0x0028, 0x0100); // Bits Allocated
+   std::string bitsAlloc = GetEntry(0x0028, 0x0100); // Bits Allocated
    if ( bitsAlloc == GDCM_UNFOUND )
    {
-      dbg.Verbose(0, "Header::GetPixelType: unfound Bits Allocated");
+      gdcmVerboseMacro( "Missing  Bits Allocated (0028,0100)");
       bitsAlloc = "16";
    }
 
@@ -969,7 +1035,7 @@ std::string Header::GetPixelType()
    {
       return "FD";
    }
-   if ( bitsAlloc == "12" )
+   else if ( bitsAlloc == "12" )
    {
       // It will be unpacked
       bitsAlloc = "16";
@@ -980,14 +1046,14 @@ std::string Header::GetPixelType()
       bitsAlloc = "8";  // by old RGB images)
    }
 
-   std::string sign = GetEntryByNumber(0x0028, 0x0103);//"Pixel Representation"
+   std::string sign = GetEntry(0x0028, 0x0103);//"Pixel Representation"
 
    if (sign == GDCM_UNFOUND )
    {
-      dbg.Verbose(0, "Header::GetPixelType: unfound Pixel Representation");
+      gdcmVerboseMacro( "Missing Pixel Representation (0028,0103)");
       bitsAlloc = "0";
    }
-   if ( sign == "0" )
+   else if ( sign == "0" )
    {
       sign = "U";
    }
@@ -1006,7 +1072,7 @@ std::string Header::GetPixelType()
  */
 size_t Header::GetPixelOffset()
 {
-   DocEntry* pxlElement = GetDocEntryByNumber(GrPixel,NumPixel);
+   DocEntry* pxlElement = GetDocEntry(GrPixel,NumPixel);
    if ( pxlElement )
    {
       return pxlElement->GetOffset();
@@ -1032,7 +1098,7 @@ size_t Header::GetPixelOffset()
  */
 size_t Header::GetPixelAreaLength()
 {
-   DocEntry* pxlElement = GetDocEntryByNumber(GrPixel,NumPixel);
+   DocEntry* pxlElement = GetDocEntry(GrPixel,NumPixel);
    if ( pxlElement )
    {
       return pxlElement->GetLength();
@@ -1060,32 +1126,32 @@ bool Header::HasLUT()
 {
    // Check the presence of the LUT Descriptors, and LUT Tables    
    // LutDescriptorRed    
-   if ( !GetDocEntryByNumber(0x0028,0x1101) )
+   if ( !GetDocEntry(0x0028,0x1101) )
    {
       return false;
    }
    // LutDescriptorGreen 
-   if ( !GetDocEntryByNumber(0x0028,0x1102) )
+   if ( !GetDocEntry(0x0028,0x1102) )
    {
       return false;
    }
    // LutDescriptorBlue 
-   if ( !GetDocEntryByNumber(0x0028,0x1103) )
+   if ( !GetDocEntry(0x0028,0x1103) )
    {
       return false;
    }
    // Red Palette Color Lookup Table Data
-   if ( !GetDocEntryByNumber(0x0028,0x1201) )
+   if ( !GetDocEntry(0x0028,0x1201) )
    {
       return false;
    }
    // Green Palette Color Lookup Table Data       
-   if ( !GetDocEntryByNumber(0x0028,0x1202) )
+   if ( !GetDocEntry(0x0028,0x1202) )
    {
       return false;
    }
    // Blue Palette Color Lookup Table Data      
-   if ( !GetDocEntryByNumber(0x0028,0x1203) )
+   if ( !GetDocEntry(0x0028,0x1203) )
    {
       return false;
    }
@@ -1110,7 +1176,7 @@ int Header::GetLUTNbits()
    //Just hope Lookup Table Desc-Red = Lookup Table Desc-Red
    //                                = Lookup Table Desc-Blue
    // Consistency already checked in GetLUTLength
-   std::string lutDescription = GetEntryByNumber(0x0028,0x1101);
+   std::string lutDescription = GetEntry(0x0028,0x1101);
    if ( lutDescription == GDCM_UNFOUND )
    {
       return 0;
@@ -1127,62 +1193,6 @@ int Header::GetLUTNbits()
    return lutNbits;
 }
 
-/**
- * \brief Accesses the info from 0002,0010 : Transfert Syntax and TS
- *        else 1.
- * @return The full Transfert Syntax Name (as opposed to Transfert Syntax UID)
- */
-std::string Header::GetTransfertSyntaxName()
-{
-   // use the TS (TS : Transfert Syntax)
-   std::string transfertSyntax = GetEntryByNumber(0x0002,0x0010);
-
-   if ( transfertSyntax == GDCM_NOTLOADED )
-   {
-      std::cout << "Transfert Syntax not loaded. " << std::endl
-               << "Better you increase MAX_SIZE_LOAD_ELEMENT_VALUE"
-               << std::endl;
-      return "Uncompressed ACR-NEMA";
-   }
-   if ( transfertSyntax == GDCM_UNFOUND )
-   {
-      dbg.Verbose(0, "Header::GetTransfertSyntaxName:"
-                     " unfound Transfert Syntax (0002,0010)");
-      return "Uncompressed ACR-NEMA";
-   }
-
-   while ( ! isdigit(transfertSyntax[transfertSyntax.length()-1]) )
-   {
-      transfertSyntax.erase(transfertSyntax.length()-1, 1);
-   }
-   // we do it only when we need it
-   TS* ts         = Global::GetTS();
-   std::string tsName = ts->GetValue( transfertSyntax );
-
-   //delete ts; /// \todo Seg Fault when deleted ?!
-   return tsName;
-}
-
-/**
- * \brief Sets the Pixel Area size in the Header
- *        --> not-for-rats function
- * @param ImageDataSize new Pixel Area Size
- *        warning : nothing else is checked
- */
-void Header::SetImageDataSize(size_t ImageDataSize)
-{
-   ///FIXME I don't understand this code why do we set two times 'car' ?
-   std::string car = Util::Format("%d", ImageDataSize);
-   DocEntry *a = GetDocEntryByNumber(GrPixel, NumPixel);
-   a->SetLength(ImageDataSize);
-
-   ImageDataSize += 8;
-   car = Util::Format("%d", ImageDataSize);
-   car = Util::DicomString( car.c_str() );
-
-   SetEntryByNumber(car, GrPixel, NumPixel);
-}
 
 //-----------------------------------------------------------------------------
 // Protected
@@ -1194,22 +1204,22 @@ void Header::SetImageDataSize(size_t ImageDataSize)
 bool Header::AnonymizeHeader()
 {
    // If exist, replace by spaces
-   SetEntryByNumber ("  ",0x0010, 0x2154); // Telephone   
-   SetEntryByNumber ("  ",0x0010, 0x1040); // Adress
-   SetEntryByNumber ("  ",0x0010, 0x0020); // Patient ID
+   SetEntry ("  ",0x0010, 0x2154); // Telephone   
+   SetEntry ("  ",0x0010, 0x1040); // Adress
+   SetEntry ("  ",0x0010, 0x0020); // Patient ID
 
-   DocEntry* patientNameHE = GetDocEntryByNumber (0x0010, 0x0010);
+   DocEntry* patientNameHE = GetDocEntry (0x0010, 0x0010);
   
    if ( patientNameHE ) // we replace it by Study Instance UID (why not)
    {
-      std::string studyInstanceUID =  GetEntryByNumber (0x0020, 0x000d);
+      std::string studyInstanceUID =  GetEntry (0x0020, 0x000d);
       if ( studyInstanceUID != GDCM_UNFOUND )
       {
-         ReplaceOrCreateByNumber(studyInstanceUID, 0x0010, 0x0010);
+         ReplaceOrCreate(studyInstanceUID, 0x0010, 0x0010);
       }
       else
       {
-         ReplaceOrCreateByNumber("anonymised", 0x0010, 0x0010);
+         ReplaceOrCreate("anonymised", 0x0010, 0x0010);
       }
    }
 
@@ -1280,28 +1290,102 @@ void Header::GetImageOrientationPatient( float iop[6] )
    iop[0] = iop[1] = iop[2] = iop[3] = iop[4] = iop[5] = 0.;
 
    // 0020 0037 DS REL Image Orientation (Patient)
-   if ( (strImOriPat = GetEntryByNumber(0x0020,0x0037)) != GDCM_UNFOUND )
+   if ( (strImOriPat = GetEntry(0x0020,0x0037)) != GDCM_UNFOUND )
    {
       if( sscanf( strImOriPat.c_str(), "%f\\%f\\%f\\%f\\%f\\%f", 
           &iop[0], &iop[1], &iop[2], &iop[3], &iop[4], &iop[5]) != 6 )
       {
-         dbg.Verbose(0, "Header::GetImageOrientationPatient: "
-                        "wrong Image Orientation Patient (0020,0037)");
+         gdcmVerboseMacro( "Wrong Image Orientation Patient (0020,0037). Less than 6 values were found." );
       }
    }
    //For ACR-NEMA
    // 0020 0035 DS REL Image Orientation (RET)
-   else if ( (strImOriPat = GetEntryByNumber(0x0020,0x0035)) != GDCM_UNFOUND )
+   else if ( (strImOriPat = GetEntry(0x0020,0x0035)) != GDCM_UNFOUND )
    {
       if( sscanf( strImOriPat.c_str(), "%f\\%f\\%f\\%f\\%f\\%f", 
           &iop[0], &iop[1], &iop[2], &iop[3], &iop[4], &iop[5]) != 6 )
       {
-         dbg.Verbose(0, "Header::GetImageOrientationPatient: "
-                        "wrong Image Orientation Patient (0020,0035)");
+         gdcmVerboseMacro( "wrong Image Orientation Patient (0020,0035). Less than 6 values were found." );
       }
    }
 }
 
+/**
+ * \brief Initialize a default DICOM header that should contain all the
+ *        field require by other reader. DICOM standard does not 
+ *        explicitely defines those fields, heuristic has been choosen.
+ *        This is not perfect as we are writting a CT image...
+ */
+void Header::InitializeDefaultHeader()
+{
+   typedef struct
+   {
+      const char *value;
+      uint16_t group;
+      uint16_t elem;
+   } DICOM_DEFAULT_VALUE;
+
+   std::string date = Util::GetCurrentDate();
+   std::string time = Util::GetCurrentTime();
+   std::string uid = Util::CreateUniqueUID();
+   std::string uidMedia = uid;
+   std::string uidClass = uid + ".1";
+   std::string uidInst  = uid + ".10";
+   std::string uidStudy = uid + ".100";
+   std::string uidSerie = uid + ".1000";
+
+   static DICOM_DEFAULT_VALUE defaultvalue[] = {
+    { "146 ",                      0x0002, 0x0000}, // Meta Element Group Length // FIXME: how to recompute ?
+    { "1.2.840.10008.5.1.4.1.1.2", 0x0002, 0x0002}, // Media Storage SOP Class UID (CT Image Storage)
+    { uidClass.c_str(),            0x0002, 0x0003}, // Media Storage SOP Instance UID
+    { uidClass.c_str(),            0x0002, 0x0012}, // META Implementation Class UID
+    { "GDCM",                      0x0002, 0x0016}, // Source Application Entity Title
+
+    { date.c_str(),                0x0008, 0x0012}, // Instance Creation Date
+    { time.c_str(),                0x0008, 0x0013}, // Instance Creation Time
+    { "1.2.840.10008.5.1.4.1.1.2", 0x0008, 0x0016}, // SOP Class UID
+    { uidInst.c_str(),             0x0008, 0x0018}, // SOP Instance UID
+    { "CT",                        0x0008, 0x0060}, // Modality    
+    { "GDCM",                      0x0008, 0x0070}, // Manufacturer
+    { "GDCM",                      0x0008, 0x0080}, // Institution Name
+    { "http://www-creatis.insa-lyon.fr/Public/Gdcm", 0x0008, 0x0081},  // Institution Address
+
+    { "GDCM",                      0x0010, 0x0010}, // Patient's Name
+    { "GDCMID",                    0x0010, 0x0020}, // Patient ID
+
+    { uidStudy.c_str(),            0x0020, 0x000d}, // Study Instance UID
+    { uidSerie.c_str(),            0x0020, 0x000e}, // Series Instance UID
+    { "1",                         0x0020, 0x0010}, // StudyID
+    { "1",                         0x0020, 0x0011}, // SeriesNumber
+
+    { "1",                         0x0028, 0x0002}, // Samples per pixel 1 or 3
+    { "MONOCHROME1",               0x0028, 0x0004}, // photochromatic interpretation
+    { "0",                         0x0028, 0x0010}, // nbRows
+    { "0",                         0x0028, 0x0011}, // nbCols
+    { "8",                         0x0028, 0x0100}, // BitsAllocated 8 or 12 or 16
+    { "8",                         0x0028, 0x0101}, // BitsStored    <= BitsAllocated
+    { "7",                         0x0028, 0x0102}, // HighBit       <= BitsAllocated - 1
+    { "0",                         0x0028, 0x0103}, // Pixel Representation 0(unsigned) or 1(signed)
+    { 0, 0, 0 }
+   };
+
+   // default value
+   // Special case this is the image (not a string)
+   GrPixel = 0x7fe0;
+   NumPixel = 0x0010;
+   ReplaceOrCreate(0, 0, GrPixel, NumPixel);
+
+   // All remaining strings:
+   unsigned int i = 0;
+   DICOM_DEFAULT_VALUE current = defaultvalue[i];
+   while( current.value )
+   {
+      ReplaceOrCreate(current.value, current.group, current.elem);
+      current = defaultvalue[++i];
+   }
+}
+
+
 //-----------------------------------------------------------------------------
 // Private