X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmHeader.cxx;h=d3e99c2062ff83f549af69c9ff94646fdd29910b;hb=8afb2999a90aefbce7662c43fe19dad237d49331;hp=dc6bbf41a7ee6ca995746d9a3baad681f57b3ca1;hpb=e8be02129ece7a8c7dd90307a8c83e1ef5d157b6;p=gdcm.git

diff --git a/src/gdcmHeader.cxx b/src/gdcmHeader.cxx
index dc6bbf41..d3e99c20 100644
--- a/src/gdcmHeader.cxx
+++ b/src/gdcmHeader.cxx
@@ -1,7 +1,4 @@
-#include "gdcmlib.h"
-extern "C" {
-#include "glib.h"
-}
+#include "gdcm.h"
 #include <stdio.h>
 // For nthos:
 #ifdef _MSC_VER
@@ -9,12 +6,24 @@ extern "C" {
 #else
 #include <netinet/in.h>
 #endif
+#include <cctype>		// for isalpha
 #include <map>
 #include <sstream>
 #include "gdcmUtil.h"
 
 #define HEADER_LENGHT_TO_READ 256 // on ne lit plus que le debut
 
+namespace Error {
+	struct FileReadError {
+		FileReadError(FILE* fp, const char* Mesg) {
+			if (feof(fp))
+				dbg.Verbose(1, "EOF encountered :", Mesg);
+			if (ferror(fp))
+				dbg.Verbose(1, "Error on reading :", Mesg);
+		}
+	};
+}
+
 //FIXME: this looks dirty to me...
 #define str2num(str, typeNum) *((typeNum *)(str))
 
@@ -24,22 +33,21 @@ gdcmDictSet* gdcmHeader::Dicts = new gdcmDictSet();
 void gdcmHeader::Initialise(void) {
 	if (!gdcmHeader::dicom_vr)
 		InitVRDict();
-	PixelPosition = (size_t)0;
-	PixelsTrouves = false;
 	RefPubDict = gdcmHeader::Dicts->GetDefaultPublicDict();
 	RefShaDict = (gdcmDict*)0;
 }
 
-gdcmHeader::gdcmHeader (char* InFilename) {
+gdcmHeader::gdcmHeader (const char* InFilename) {
+	SetMaxSizeLoadElementValue(1024);
 	filename = InFilename;
 	Initialise();
 	fp=fopen(InFilename,"rw");
 	dbg.Error(!fp, "gdcmHeader::gdcmHeader cannot open file", InFilename);
-	BuildHeader();
-	fclose(fp);
+	ParseHeader();
 }
 
 gdcmHeader::~gdcmHeader (void) {
+	fclose(fp);
 	return;
 }
 
@@ -49,32 +57,32 @@ void gdcmHeader::InitVRDict (void) {
 		return;
 	}
 	VRHT *vr = new VRHT;
-	(*vr)["AE"] = "Application Entity";       // 16 car max
-	(*vr)["AS"] = "Age String";               // 4 car fixe
-	(*vr)["AT"] = "Attribute Tag";            // 2 unsigned short int
-	(*vr)["CS"] = "Code String";              // 16 car max
-	(*vr)["DA"] = "Date";                     // 8 car fixe
-	(*vr)["DS"] = "Decimal String";           // Decimal codé Binaire 16 max
-	(*vr)["DT"] = "Date Time";                // 26 car max
-	(*vr)["FL"] = "Floating Point Single";    // 4 octets IEEE 754:1985
-	(*vr)["FD"] = "Floating Point Double";    // 8 octets IEEE 754:1985
-	(*vr)["IS"] = "Integer String";           // en format externe 12 max
-	(*vr)["LO"] = "Long String";              // 64 octets max
-	(*vr)["LT"] = "Long Text";                // 10240 max
-	(*vr)["OB"] = "Other Byte String";
-	(*vr)["OW"] = "Other Word String";
-	(*vr)["PN"] = "Person Name";
-	(*vr)["SH"] = "Short String";             // 16 car max
-	(*vr)["SL"] = "Signed Long";
+	(*vr)["AE"] = "Application Entity";       // At most 16 bytes
+	(*vr)["AS"] = "Age String";               // Exactly 4 bytes
+	(*vr)["AT"] = "Attribute Tag";            // 2 16-bit unsigned short integers
+	(*vr)["CS"] = "Code String";              // At most 16 bytes
+	(*vr)["DA"] = "Date";                     // Exactly 8 bytes
+	(*vr)["DS"] = "Decimal String";           // At most 16 bytes
+	(*vr)["DT"] = "Date Time";                // At most 26 bytes
+	(*vr)["FL"] = "Floating Point Single";    // 32-bit IEEE 754:1985 float
+	(*vr)["FD"] = "Floating Point Double";    // 64-bit IEEE 754:1985 double
+	(*vr)["IS"] = "Integer String";           // At most 12 bytes
+	(*vr)["LO"] = "Long String";              // At most 64 chars
+	(*vr)["LT"] = "Long Text";                // At most 10240 chars
+	(*vr)["OB"] = "Other Byte String";        // String of bytes (vr independant)
+	(*vr)["OW"] = "Other Word String";        // String of 16-bit words (vr dep)
+	(*vr)["PN"] = "Person Name";              // At most 64 chars
+	(*vr)["SH"] = "Short String";             // At most 16 chars
+	(*vr)["SL"] = "Signed Long";              // Exactly 4 bytes
 	(*vr)["SQ"] = "Sequence of Items";        // Not Applicable
-	(*vr)["SS"] = "Signed Short";             // 2 octets
-	(*vr)["ST"] = "Short Text";               // 1024 car max
-	(*vr)["TM"] = "Time";                     // 16 car max
-	(*vr)["UI"] = "Unique Identifier";        // 64 car max
-	(*vr)["UN"] = "Unknown";
-	(*vr)["UT"] = "Unlimited Text";           //  2 puissance 32 -1 car max
-	(*vr)["UL"] = "Unsigned Long ";           // 4 octets fixe
-	(*vr)["US"] = "Unsigned Short ";          // 2 octets fixe
+	(*vr)["SS"] = "Signed Short";             // Exactly 2 bytes
+	(*vr)["ST"] = "Short Text";               // At most 1024 chars
+	(*vr)["TM"] = "Time";                     // At most 16 bytes
+	(*vr)["UI"] = "Unique Identifier";        // At most 64 bytes
+	(*vr)["UL"] = "Unsigned Long ";           // Exactly 4 bytes
+	(*vr)["UN"] = "Unknown";                  // Any length of bytes
+	(*vr)["US"] = "Unsigned Short ";          // Exactly 2 bytes
+	(*vr)["UT"] = "Unlimited Text";           // At most 2^32 -1 chars
    dicom_vr = vr;	
 }
 
@@ -120,10 +128,10 @@ void gdcmHeader::CheckSwap()
 	entCur = deb + 128;
 	if(memcmp(entCur, "DICM", (size_t)4) == 0) {
 		filetype = TrueDicom;
-		dbg.Verbose(0, "gdcmHeader::CheckSwap:", "looks like DICOM Version3");
+		dbg.Verbose(1, "gdcmHeader::CheckSwap:", "looks like DICOM Version3");
 	} else {
 		filetype = Unknown;
-		dbg.Verbose(0, "gdcmHeader::CheckSwap:", "not a DICOM Version3 file");
+		dbg.Verbose(1, "gdcmHeader::CheckSwap:", "not a DICOM Version3 file");
 	}
 
 	if(filetype == TrueDicom) {
@@ -144,21 +152,21 @@ void gdcmHeader::CheckSwap()
 		entCur = deb + 136;
 		if(memcmp(entCur, "UL", (size_t)2) == 0) {
 			filetype = ExplicitVR;
-			dbg.Verbose(0, "gdcmHeader::CheckSwap:",
+			dbg.Verbose(1, "gdcmHeader::CheckSwap:",
 			            "explicit Value Representation");
 		} else {
 			filetype = ImplicitVR;
-			dbg.Verbose(0, "gdcmHeader::CheckSwap:",
+			dbg.Verbose(1, "gdcmHeader::CheckSwap:",
 			            "not an explicit Value Representation");
 		}
 
 		if (net2host) {
 			sw = 4321;
-			dbg.Verbose(0, "gdcmHeader::CheckSwap:",
+			dbg.Verbose(1, "gdcmHeader::CheckSwap:",
 			               "HostByteOrder != NetworkByteOrder");
 		} else {
 			sw = 0;
-			dbg.Verbose(0, "gdcmHeader::CheckSwap:",
+			dbg.Verbose(1, "gdcmHeader::CheckSwap:",
 			               "HostByteOrder = NetworkByteOrder");
 		}
 		
@@ -180,23 +188,23 @@ void gdcmHeader::CheckSwap()
 	// four (bytes), then determining the proper swap code is straightforward.
 
 	entCur = deb + 4;
-	s = str2num(entCur, int);
+	s = str2num(entCur, guint32);
 	
 	switch (s) {
 	case 0x00040000 :
-		sw=3412;
+		sw = 3412;
 		filetype = ACR;
 		return;
 	case 0x04000000 :
-		sw=4321;
+		sw = 4321;
 		filetype = ACR;
 		return;
 	case 0x00000400 :
-		sw=2143;
+		sw = 2143;
 		filetype = ACR;
 		return;
 	case 0x00000004 :
-		sw=0;
+		sw = 0;
 		filetype = ACR;
 		return;
 	default :
@@ -206,7 +214,7 @@ void gdcmHeader::CheckSwap()
 
 	// 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 it
+	// 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.
 	//FIXME  Si c'est du RAW, ca degagera + tard
 	
@@ -217,6 +225,25 @@ void gdcmHeader::CheckSwap()
 	return;
 }
 
+void gdcmHeader::SwitchSwapToBigEndian(void) {
+	dbg.Verbose(1, "gdcmHeader::SwitchSwapToBigEndian",
+	               "Switching to BigEndian mode.");
+	if ( sw == 0    ) {
+		sw = 4321;
+		return;
+	}
+	if ( sw == 4321 ) {
+		sw = 0;
+		return;
+	}
+	if ( sw == 3412 ) {
+		sw = 2143;
+		return;
+	}
+	if ( sw == 2143 )
+		sw = 3412;
+}
+
 /**
  * \ingroup   gdcmHeader
  * \brief     recupere la longueur d'un champ DICOM.
@@ -256,17 +283,14 @@ void gdcmHeader::CheckSwap()
  * @return               longueur retenue pour le champ 
  */
 
-void gdcmHeader::FindVR( ElValue *pleCourant) {
-	char VR[3];
-	int lgrLue;
-	long PositionOnEntry = ftell(fp);
-	
+void gdcmHeader::FindVR( ElValue *ElVal) {
 	if (filetype != ExplicitVR)
 		return;
 
-	lgrLue=fread (&VR, (size_t)2,(size_t)1, fp);
-	VR[2]=0;
-		
+	char VR[3];
+	string vr;
+	int lgrLue;
+	long PositionOnEntry = ftell(fp);
 	// Warning: we believe this is explicit VR (Value Representation) because
 	// we used a heuristic that found "UL" in the first tag. Alas this
 	// doesn't guarantee that all the tags will be in explicit VR. In some
@@ -274,69 +298,221 @@ void gdcmHeader::FindVR( ElValue *pleCourant) {
 	// within an explicit VR file. Hence we make sure the present tag
 	// is in explicit VR and try to fix things if it happens not to be
 	// the case.
-
-	// FIXME There should be only one occurence returned. Avoid the
-	// first extraction by calling proper method.
-	VRAtr FoundVR = dicom_vr->find(string(VR))->first;
-	if ( ! FoundVR.empty()) {
-		pleCourant->SetVR(FoundVR);
+	bool RealExplicit = true;
+	
+	lgrLue=fread (&VR, (size_t)2,(size_t)1, fp);
+	VR[2]=0;
+	vr = string(VR);
+		
+	// Assume we are reading a falsely explicit VR file i.e. we reached
+	// a tag where we expect reading a VR but are in fact we read the
+	// first to bytes of the length. Then we will interogate (through find)
+	// the dicom_vr dictionary with oddities like "\004\0" which crashes
+	// both GCC and VC++ implentations of the STL map. Hence when the
+	// expected VR read happens to be non-ascii characters we consider
+	// we hit falsely explicit VR tag.
+
+	if ( (!isalpha(VR[0])) && (!isalpha(VR[1])) )
+		RealExplicit = false;
+
+	// CLEANME searching the dicom_vr at each occurence is expensive.
+	// PostPone this test in an optional integrity check at the end
+	// of parsing or only in debug mode.
+	if ( RealExplicit && !dicom_vr->count(vr) )
+		RealExplicit = false;
+
+	if ( RealExplicit ) {
+		if ( ElVal->IsVrUnknown() ) {
+			// When not a dictionary entry, we can safely overwrite the vr.
+			ElVal->SetVR(vr);
+			return; 
+		}
+		if ( ElVal->GetVR() == vr ) {
+			// The vr we just read and the dictionary agree. Nothing to do.
+			return;
+		}
+		// The vr present in the file and the dictionary disagree. We assume
+		// the file writer knew best and use the vr of the file. Since it would
+		// 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 = new gdcmDictEntry(ElVal->GetGroup(),
+		                           ElVal->GetElement(),
+		                           vr,
+		                           "FIXME",
+		                           ElVal->GetName());
+		ElVal->SetDictEntry(NewTag);
 		return; 
 	}
 	
 	// We thought this was explicit VR, but we end up with an
 	// implicit VR tag. Let's backtrack.
-	pleCourant->SetVR("Implicit");
+	dbg.Verbose(1, "gdcmHeader::FindVR:", "Falsely explicit vr file");
 	fseek(fp, PositionOnEntry, SEEK_SET);
+	// When this element is known in the dictionary we shall use, e.g. for
+	// the semantics (see  the usage of IsAnInteger), the vr proposed by the
+	// dictionary entry. Still we have to flag the element as implicit since
+	// we know now our assumption on expliciteness is not furfilled.
+	// avoid  .
+	if ( ElVal->IsVrUnknown() )
+		ElVal->SetVR("Implicit");
+	ElVal->SetImplicitVr();
 }
 
-void gdcmHeader::FindLength( ElValue *pleCourant) {
-	int lgrLue;
-	guint32 l_gr;
-	unsigned short int l_gr_2;
-	
-	string vr = pleCourant->GetVR();
+/**
+ * \ingroup gdcmHeader
+ * \brief   Determines if the Transfer Syntax was allready encountered
+ *          and if it corresponds to a Big Endian one.
+ *
+ * @return  True when big endian found. False in all other cases.
+ */
+bool gdcmHeader::IsBigEndianTransferSyntax(void) {
+	ElValue* Element = PubElVals.GetElement(0x0002, 0x0010);
+	if ( !Element )
+		return false;
+	LoadElementValueSafe(Element);
+	string Transfer = Element->GetValue();
+	if ( Transfer == "1.2.840.10008.1.2.2" )
+		return true;
+	return false;
+}
+
+void gdcmHeader::FixFoundLength(ElValue * ElVal, guint32 FoudLength) {
+	// Heuristic: a final fix.
+	if ( FoudLength == 0xffffffff)
+		FoudLength = 0;
+	ElVal->SetLength(FoudLength);
+}
+
+guint32 gdcmHeader::FindLengthOB(void) {
+	// See PS 3.5-2001, section A.4 p. 49 on encapsulation of encoded pixel data.
+	guint16 g;
+	guint16 n; 
+	long PositionOnEntry = ftell(fp);
+	bool FoundSequenceDelimiter = false;
+	guint32 TotalLength = 0;
+	guint32 ItemLength;
+
+	while ( ! FoundSequenceDelimiter) {
+		g = ReadInt16();
+		n = ReadInt16();
+		TotalLength += 4;  // We even have to decount the group and element 
+		if ( g != 0xfffe ) {
+			dbg.Verbose(1, "gdcmHeader::FindLengthOB: ",
+			            "wrong group for an item sequence.");
+			throw Error::FileReadError(fp, "gdcmHeader::FindLengthOB");
+		}
+		if ( n == 0xe0dd )
+			FoundSequenceDelimiter = true;
+		else if ( n != 0xe000) {
+			dbg.Verbose(1, "gdcmHeader::FindLengthOB: ",
+			            "wrong element for an item sequence.");
+			throw Error::FileReadError(fp, "gdcmHeader::FindLengthOB");
+		}
+		ItemLength = ReadInt32();
+		TotalLength += ItemLength + 4;  // We add 4 bytes since we just read
+		                                // the ItemLength with ReadInt32
+		SkipBytes(ItemLength);
+	}
+	fseek(fp, PositionOnEntry, SEEK_SET);
+	return TotalLength;
+}
+
+void gdcmHeader::FindLength(ElValue * ElVal) {
+	guint16 element = ElVal->GetElement();
+	string  vr      = ElVal->GetVR();
+	guint16 length16;
 	
-	if ( (filetype == ExplicitVR) && (vr != "Implicit") ) {
-		if (   ( vr == "OB" ) || ( vr == "OW" )
-			 || ( vr == "SQ" ) || ( vr == "UN" ) ) {
-			
-			// The following two bytes are reserved, so we skip them,
-			// and we proceed on reading the length on 4 bytes.
-			fseek(fp, 2L,SEEK_CUR);
-			lgrLue=fread (&l_gr, (size_t)4,(size_t)1, fp);
-			l_gr = SwapLong((guint32)l_gr);
-			
-		} else {
-			// Length is encoded on 2 bytes.
-			lgrLue=fread (&l_gr_2, (size_t)2,(size_t)1, fp);
-			
-			l_gr_2 = SwapShort((unsigned short)l_gr_2);
-			
-			if ( l_gr_2 == 0xffff) {
-				l_gr = 0;
-			} else {
-				l_gr = l_gr_2;
+	if ( (filetype == ExplicitVR) && ! ElVal->IsImplicitVr() ) {
+
+		if ( (vr=="OB") || (vr=="OW") || (vr=="SQ") || (vr=="UN") ) {
+			// The following reserved two bytes (see PS 3.5-2001, section
+			// 7.1.2 Data element structure with explicit vr p27) must be
+			// skipped before proceeding on reading the length on 4 bytes.
+			fseek(fp, 2L, SEEK_CUR);
+			guint32 length32 = ReadInt32();
+			if ( (vr == "OB") && (length32 == 0xffffffff) ) {
+				ElVal->SetLength(FindLengthOB());
+				return;
 			}
+			FixFoundLength(ElVal, length32);
+			return;
 		}
-	} else {
-		// Either implicit VR or an explicit VR that (at least for this
-		// element) lied a little bit. Length is on 4 bytes.
-		lgrLue=fread (&l_gr, (size_t)4,(size_t)1, fp);
-		l_gr= SwapLong((long)l_gr);
+
+		// Length is encoded on 2 bytes.
+		length16 = ReadInt16();
+		
+		// We can tell the current file is encoded in big endian (like
+		// Data/US-RGB-8-epicard) when we find the "Transfer Syntax" tag
+		// and it's value is the one of the encoding of a big endian file.
+		// In order to deal with such big endian encoded files, we have
+		// (at least) two strategies:
+		// * when we load the "Transfer Syntax" tag with value of big endian
+		//   encoding, we raise the proper flags. Then we wait for the end
+		//   of the META group (0x0002) among which is "Transfer Syntax",
+		//   before switching the swap code to big endian. We have to postpone
+		//   the switching of the swap code since the META group is fully encoded
+		//   in little endian, and big endian coding only starts at the next
+		//   group. The corresponding code can be hard to analyse and adds
+		//   many additional unnecessary tests for regular tags.
+		// * the second strategy consist in waiting for trouble, that shall appear
+		//   when we find the first group with big endian encoding. This is
+		//   easy to detect since the length of a "Group Length" tag (the
+		//   ones with zero as element number) has to be of 4 (0x0004). When we
+		//   encouter 1024 (0x0400) chances are the encoding changed and we
+		//   found a group with big endian encoding.
+		// We shall use this second strategy. In order make sure that we
+		// can interpret the presence of an apparently big endian encoded
+		// length of a "Group Length" without committing a big mistake, we
+		// add an additional check: we look in the allready parsed elements
+		// for the presence of a "Transfer Syntax" whose value has to be "big
+		// endian encoding". When this is the case, chances are we got our
+		// hands on a big endian encoded file: we switch the swap code to
+		// big endian and proceed...
+		if ( (element  == 0) && (length16 == 1024) ) {
+			if ( ! IsBigEndianTransferSyntax() )
+				throw Error::FileReadError(fp, "gdcmHeader::FindLength");
+			length16 = 4;
+			SwitchSwapToBigEndian();
+			// Restore the unproperly loaded values i.e. the group, the element
+			// and the dictionary entry depending on them.
+			guint16 CorrectGroup   = SwapShort(ElVal->GetGroup());
+			guint16 CorrectElem    = SwapShort(ElVal->GetElement());
+			gdcmDictEntry * NewTag = IsInDicts(CorrectGroup, CorrectElem);
+			if (!NewTag) {
+				// This correct tag is not in the dictionary. Create a new one.
+				NewTag = new gdcmDictEntry(CorrectGroup, CorrectElem);
+			}
+			// FIXME this can create a memory leaks on the old entry that be
+			// left unreferenced.
+			ElVal->SetDictEntry(NewTag);
+		}
+		 
+		// Heuristic: well some files are really ill-formed.
+		if ( length16 == 0xffff) {
+			length16 = 0;
+			dbg.Verbose(0, "gdcmHeader::FindLength",
+			            "Erroneous element length fixed.");
+		}
+		FixFoundLength(ElVal, (guint32)length16);
+		return;
 	}
 
-	// Traitement des curiosites sur la longueur
-	if ( l_gr == 0xffffffff)
-		l_gr=0; 
-	
-	pleCourant->SetLength(l_gr);
+	// 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.
+	FixFoundLength(ElVal, ReadInt32());
 }
 
 /**
  * \ingroup gdcmHeader
- * \brief   remet les octets dans un ordre compatible avec celui du processeur
-
- * @return  longueur retenue pour le champ 
+ * \brief   Swaps back the bytes of 4-byte long integer accordingly to
+ *          processor order.
+ *
+ * @return  The suggested integer.
  */
 guint32 gdcmHeader::SwapLong(guint32 a) {
 	// FIXME: il pourrait y avoir un pb pour les entiers negatifs ...
@@ -364,131 +540,220 @@ guint32 gdcmHeader::SwapLong(guint32 a) {
 
 /**
  * \ingroup gdcmHeader
- * \brief   remet les octets dans un ordre compatible avec celui du processeur
-
- * @return  longueur retenue pour le champ 
+ * \brief   Swaps the bytes so they agree with the processor order
+ * @return  The properly swaped 16 bits integer.
  */
-short int gdcmHeader::SwapShort(short int a) {
+guint16 gdcmHeader::SwapShort(guint16 a) {
 	if ( (sw==4321)  || (sw==2143) )
 		a =(((a<<8) & 0x0ff00) | ((a>>8)&0x00ff));
 	return (a);
 }
 
+void gdcmHeader::SkipBytes(guint32 NBytes) {
+	//FIXME don't dump the returned value
+	(void)fseek(fp, (long)NBytes, SEEK_CUR);
+}
+
+void gdcmHeader::SkipElementValue(ElValue * ElVal) {
+	SkipBytes(ElVal->GetLength());
+}
+
+void gdcmHeader::SetMaxSizeLoadElementValue(long NewSize) {
+	if (NewSize < 0)
+		return;
+	if ((guint32)NewSize >= (guint32)0xffffffff) {
+		MaxSizeLoadElementValue = 0xffffffff;
+		return;
+	}
+	MaxSizeLoadElementValue = NewSize;
+}
+
 /**
  * \ingroup       gdcmHeader
- * \brief         lit le dicom_element suivant.
- *			(le fichier doit deja avoir ete ouvert,
- *			 _IdAcrCheckSwap(ID_DCM_HDR *e) avoir ete appele)
- * @param e      ID_DCM_HDR  dans lequel effectuer la recherche.
- * @param sw    	code swap.
- * @return        	En cas de succes, 1 
- *               	0 en cas d'echec.
+ * \brief         Loads the element if it's size is not to big.
+ * @param ElVal   Element whose value shall be loaded. 
+ * @param MaxSize Size treshold above which the element value is not
+ *                loaded in memory. The element value is allways loaded
+ *                when MaxSize is equal to UINT32_MAX.
+ * @return  
  */
-
-ElValue * gdcmHeader::ReadNextElement(void) {
-	guint16 g;
-	guint16 n;
-	guint32 l;
-	size_t lgrLue;
-	ElValue * nouvDcmElem;
-	
-	// ------------------------- Lecture Num group : g
-	lgrLue=fread (&g, (size_t)2,(size_t)1, fp);
+void gdcmHeader::LoadElementValue(ElValue * ElVal) {
+	size_t item_read;
+	guint16 group  = ElVal->GetGroup();
+	guint16 elem   = ElVal->GetElement();
+	string  vr     = ElVal->GetVR();
+	guint32 length = ElVal->GetLength();
+	bool SkipLoad  = false;
+
+	fseek(fp, (long)ElVal->GetOffset(), SEEK_SET);
 	
-	if (feof(fp))  {
-		dbg.Verbose(1, "ReadNextElement: EOF encountered");
-		return (NULL);
+	// Sequences not treated yet !
+	if( vr == "SQ" )
+		SkipLoad = true;
+
+	// Heuristic : a sequence "contains" a set of tags (called items). It looks
+	// like the last tag of a sequence (the one that terminates the sequence)
+	// has a group of 0xfffe (with a dummy length).
+	if( group == 0xfffe )
+		SkipLoad = true;
+
+	// The group length doesn't represent data to be loaded in memory, since
+	// each element of the group shall be loaded individualy.
+	if( elem == 0 )
+ 		SkipLoad = true;
+
+	if ( SkipLoad ) {
+			  // FIXME the following skip is not necessary
+		SkipElementValue(ElVal);
+		ElVal->SetLength(0);
+		ElVal->SetValue("gdcm::Skipped");
+		return;
 	}
-	if (ferror(fp)){
-		dbg.Verbose(1, "ReadNextElement: failed to read NumGr");
-		return (NULL);
+
+	// When the length is zero things are easy:
+	if ( length == 0 ) {
+		ElVal->SetValue("");
+		return;
+	}
+
+	// Values bigger than specified are not loaded.
+	if (length > MaxSizeLoadElementValue) {
+		ostringstream s;
+		s << "gdcm::NotLoaded.";
+		s << " Address:" << (long)ElVal->GetOffset();
+		s << " Length:"  << ElVal->GetLength();
+		//mesg += " Length:"  + ElVal->GetLength();
+		ElVal->SetValue(s.str());
+		return;
 	}
 	
-	if (sw) g= SwapShort(((short)g));
-	
-	// ------------------------- Lecture Num Elem : n
-	lgrLue=fread (&n, (size_t)2,(size_t)1, fp);
+	// When an integer is expected, read and convert the following two or
+	// four bytes properly i.e. as an integer as opposed to a string.
+	if ( IsAnInteger(ElVal) ) {
+		guint32 NewInt;
+		if( length == 2 ) {
+			NewInt = ReadInt16();
+		} else if( length == 4 ) {
+			NewInt = ReadInt32();
+		} else
+			dbg.Error(true, "LoadElementValue: Inconsistency when reading Int.");
+		
+		//FIXME: make the following an util fonction
+		ostringstream s;
+		s << NewInt;
+		ElVal->SetValue(s.str());
+		return;
+	}
 	
-	if (feof(fp))  {
-		dbg.Verbose(1, "ReadNextElement: EOF encountered");
-		return (NULL);
+	// FIXME The exact size should be length if we move to strings or whatever
+	char* NewValue = (char*)g_malloc(length+1);
+	if( !NewValue) {
+		dbg.Verbose(1, "LoadElementValue: Failed to allocate NewValue");
+		return;
 	}
-	if (ferror(fp)){
-		dbg.Verbose(1, "ReadNextElement: failed to read NumElem");
-		return (NULL);
+	NewValue[length]= 0;
+	
+	item_read = fread(NewValue, (size_t)length, (size_t)1, fp);
+	if ( item_read != 1 ) {
+		g_free(NewValue);
+		Error::FileReadError(fp, "gdcmHeader::LoadElementValue");
+		ElVal->SetValue("gdcm::UnRead");
+		return;
 	}
+	ElVal->SetValue(NewValue);
+}
+
+/**
+ * \ingroup       gdcmHeader
+ * \brief         Loads the element while preserving the current
+ *                underlying file position indicator as opposed to
+ *                to LoadElementValue that modifies it.
+ * @param ElVal   Element whose value shall be loaded. 
+ * @return  
+ */
+void gdcmHeader::LoadElementValueSafe(ElValue * ElVal) {
+	long PositionOnEntry = ftell(fp);
+	LoadElementValue(ElVal);
+	fseek(fp, PositionOnEntry, SEEK_SET);
+}
+
+
+guint16 gdcmHeader::ReadInt16(void) {
+	guint16 g;
+	size_t item_read;
+	item_read = fread (&g, (size_t)2,(size_t)1, fp);
+	if ( item_read != 1 )
+		throw Error::FileReadError(fp, "gdcmHeader::ReadInt16");
+	g = SwapShort(g);
+	return g;
+}
+
+guint32 gdcmHeader::ReadInt32(void) {
+	guint32 g;
+	size_t item_read;
+	item_read = fread (&g, (size_t)4,(size_t)1, fp);
+	if ( item_read != 1 )
+		throw Error::FileReadError(fp, "gdcmHeader::ReadInt32");
+	g = SwapLong(g);
+	return g;
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief   Read the next tag without loading it's value
+ * @return  On succes the newly created ElValue, NULL on failure.      
+ */
+
+ElValue * gdcmHeader::ReadNextElement(void) {
+	guint16 g;
+	guint16 n;
+	ElValue * NewElVal;
 	
-	if(sw) n= SwapShort(((short)n));
+	try {
+		g = ReadInt16();
+		n = ReadInt16();
+	}
+	catch ( Error::FileReadError ) {
+		// We reached the EOF (or an error occured) and header parsing
+		// has to be considered as finished.
+		return (ElValue *)0;
+	}
 
 	// Find out if the tag we encountered is in the dictionaries:
 	gdcmDictEntry * NewTag = IsInDicts(g, n);
 	if (!NewTag)
-		NewTag = new gdcmDictEntry(g, n, "Unknown", "Unknown", "Unkown");
+		NewTag = new gdcmDictEntry(g, n);
 
-	nouvDcmElem = new ElValue(NewTag);
-	if (!nouvDcmElem) {
+	NewElVal = new ElValue(NewTag);
+	if (!NewElVal) {
 		dbg.Verbose(1, "ReadNextElement: failed to allocate ElValue");
-		return(NULL);
+		return (ElValue*)0;
 	}
 
-	FindVR(nouvDcmElem);
-	FindLength(nouvDcmElem);
-	nouvDcmElem->SetOffset(ftell(fp));
-	l = nouvDcmElem->GetLength();
-
-	//FIXMEif(!memcmp( VR,"SQ",(size_t)2 )) { // ca annonce une SEQUENCE d'items ?!
-	//FIXME	l_gr=0;                         // on lira donc les items de la sequence 
-	//FIXME}
-	//FIXMEreturn(l_gr);
-
-   // Une sequence contient un ensemble de group element repetes n fois
-	// et g=fffe indique la fin (contient une longueur bidon).
-	if(g==0xfffe) l=0;  // pour sauter les indicateurs de 'SQ'
-	
-	
-	// ------------------------- Lecture Valeur element 
-	
-	// FIXME The exact size should be l if we move to strings or whatever
-	// CLEAN ME NEWValue used to be nouvDcmElem->valeurElem
-	char* NewValue = (char*)g_malloc(l+1);
-	if(NewValue) {
-		NewValue[l]= 0;
-	} else {
-		return (NULL);
+	FindVR(NewElVal);
+	try { FindLength(NewElVal); }
+	catch ( Error::FileReadError ) { // Call it quits
+		return (ElValue *)0;
 	}
-	
-	// FIXME les elements trop long (seuil a fixer a la main) ne devraient
-	// pas etre charge's !!!! Voir TODO.
-	lgrLue=fread (NewValue, (size_t)l,(size_t)1, fp);
-	
-	if ( IsAnInteger(g, n, NewTag->GetVR(), l) ) {
-		// CLEANME THe following is really UGLY ! 
-		if( l == 4 ) {
-			*(guint32 *) NewValue = SwapLong  ((*(guint32 *) NewValue)); 
-		} else {
-			if( l == 2 )
-				*(guint16 *) NewValue = SwapShort ((*(guint16 *)NewValue));
-		}
-		//FIXME: don't we have to distinguish guin16 and guint32
-		//FIXME: make the following an util fonction
-		ostringstream s;
-		s << *(guint32 *) NewValue;
-		nouvDcmElem->value = s.str();
-		g_free(NewValue);
-	} else
-		nouvDcmElem->value = NewValue;
-	return nouvDcmElem;
+	NewElVal->SetOffset(ftell(fp));
+	return NewElVal;
 }
 
-bool gdcmHeader::IsAnInteger(guint16 group, guint16 element,
-	                             string vr, guint32 length ) {
-	// When we have some semantics on the element we just read, and we
-	// a priori now we are dealing with an integer, then we can swap it's
-	// element value properly.
+bool gdcmHeader::IsAnInteger(ElValue * ElVal) {
+	guint16 group   = ElVal->GetGroup();
+	guint16 element = ElVal->GetElement();
+	string  vr      = ElVal->GetVR();
+	guint32 length  = ElVal->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.
 	if ( element == 0 )  {  // This is the group length of the group
-		if (length != 4)
-			dbg.Error("gdcmHeader::ShouldBeSwaped", "should be four");
-		return true;
+		if (length == 4)
+			return true;
+		else
+			dbg.Error("gdcmHeader::IsAnInteger",
+			          "Erroneous Group Length element length.");
 	}
 	
 	if ( group % 2 != 0 )
@@ -517,78 +782,35 @@ bool gdcmHeader::IsAnInteger(guint16 group, guint16 element,
 
 /**
  * \ingroup gdcmHeader
- * \brief   If we encountered the offset of the pixels in the file
- *          (Pixel Data) then keep the info aside.
+ * \brief   Recover the offset (from the beginning of the file) of the pixels.
  */
-void gdcmHeader::SetAsidePixelData(ElValue* elem) {
-	// They are two cases :
-	// * the pixel data (i.e. the image or the volume) is pointed by it's
-	//   default official tag (0x7fe0,0x0010),
-	// * the writer of this file decided to put the image "address" (i.e the
-	//   offset from the begining of the file) at a different tag.
-	//   Then the "Pixel Data" offset might be found by indirection through
-	//   the "Image Location" tag (0x0028,  0x0200). In other terms the Image
-	//   Location tag contains the group where the "Pixel Data" offset is and
-	//   inside this group the element is conventionally at element 0x0010
-	//   (when the norm is respected).
-	// 
-	// Hence getting our hands on the Pixel Data is a two stage process:
-	//  1/ * find if the "Pixel Data" tag exists.
-	//     * if it does not exist, look for the "Pixel Location" tag.
-	//  2/ look at the proper tag ("Pixel Data" or "Pixel Location" when
-	//     it exists) what the offset is.
-	cout << "aaaaaaaaaaaaaaaaaaaaa";
-	// PubElVals.PrintByName(cout);
-	ostringstream val;
-	val << hex << GetPubElValByName("Image Location");
-	cout << GetPubElValByName("Image Location") << endl;
-	cout <<hex << GetPubElValByName("Image Location") << dec << endl;
-	cout << "aaaa" << hex << val << dec << endl;
-	if (val)
-		//grPixel  = val.hex().str();
-		grPixel = 0;
-	else
-		grPixel  = 0x7FE0;
-	return;
-
-	guint16 g;
-	guint16 n;
-	g = elem->GetGroup();
-	n = elem->GetElement();
-	if (!grPixelTrouve) {   // on n a pas encore trouve les pixels
-		if (g > 0x0028) {
-			if (n > 0x0200 || g == 0x7FE0 ) {  // on a depasse (28,200)
-				grPixel  = 0x7FE0;
-				numPixel = 0x0010;
-				grPixelTrouve = true;
-			}
-		} else {         // on est sur (28,200)
-			if (g == 0x0028) {
-				if (n == 0x0200) {
-					grPixelTrouve = 1;
-					char* NewValue = (char*)g_malloc(elem->GetLength()+1);
-					// FIXME: not very elegant conversion
-					for(int i=0;i<4;i++)
-						*((char*)(&grPixel)+i) = *(NewValue+i); 
-					elem->SetValue(NewValue);
-					
-					if (grPixel != 0x7FE0)   // Vieux pb Philips
-						numPixel = 0x1010;    // encore utile ??
-					else
-						numPixel = 0x0010;
-				}
-			}
-		}
-	} else {     // on vient de trouver les pixels
-		if (g == grPixel) {
-			if (n == numPixel) {
-				PixelPosition = elem->Offset; 
-				PixelsTrouves = true;
-				dbg.Verbose(0, "gdcmHeader::SetAsidePixelData:",
-				            "Pixel data found");
-			}
-		}
+size_t gdcmHeader::GetPixelOffset(void) {
+	// If this file complies with the norm we should encounter the
+	// "Image Location" tag (0x0028,  0x0200). This tag contains the
+	// the group that contains the pixel data (hence the "Pixel Data"
+	// 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.
+	guint16 grPixel;
+	guint16 numPixel;
+	string ImageLocation = GetPubElValByName("Image Location");
+	if ( ImageLocation == "UNFOUND" ) {
+		grPixel = 0x7FE0;
+	} else {
+		grPixel = (guint16) atoi( ImageLocation.c_str() );
 	}
+	if (grPixel != 0x7fe0)
+		// FIXME is this still necessary ?
+		// Now, this looks like an old dirty fix for Philips imager
+		numPixel = 0x1010;
+	else
+		numPixel = 0x0010;
+	ElValue* PixelElement = PubElVals.GetElement(grPixel, numPixel);
+	if (PixelElement)
+		return PixelElement->GetOffset();
+	else
+		return 0;
 }
 
 gdcmDictEntry * gdcmHeader::IsInDicts(guint32 group, guint32 element) {
@@ -619,21 +841,30 @@ string gdcmHeader::GetPubElValByName(string TagName) {
 }
 
 /**
- * \ingroup       gdcmHeader
- * \brief         renvoie un pointeur sur le ID_DCM_HDR correspondant au fichier
- * @param filename      Nom du fichier ACR / LibIDO / DICOM
- * @return       le ID_DCM_HDR 
+ * \ingroup gdcmHeader
+ * \brief   Parses the header of the file but does NOT load element values.
  */
- 
-void gdcmHeader::BuildHeader(void) {
+void gdcmHeader::ParseHeader(void) {
 	ElValue * newElValue = (ElValue *)0;
 	
 	rewind(fp);
 	CheckSwap();
 	while ( (newElValue = ReadNextElement()) ) {
+		SkipElementValue(newElValue);
 		PubElVals.Add(newElValue);
 	}
-	SetAsidePixelData((ElValue*)0);
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief   Loads the element values of all the elements present in the
+ *          public tag based hash table.
+ */
+void gdcmHeader::LoadElements(void) {
+	rewind(fp);    
+	TagElValueHT ht = PubElVals.GetTagHt();
+	for (TagElValueHT::iterator tag = ht.begin(); tag != ht.end(); ++tag)
+		LoadElementValue(tag->second);
 }
 
 void gdcmHeader::PrintPubElVal(ostream & os) {