X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmHeader.cxx;h=a2bece5180e74a3a48decff566b0f06c739246c6;hb=f66abc53491ab130c2dbea483ba241edf6da2e88;hp=f0027e1552af8789d338939d5e467b6e27b526d5;hpb=70e24c6c61481f9836e26b6b44a9670d92a4f43b;p=gdcm.git

diff --git a/src/gdcmHeader.cxx b/src/gdcmHeader.cxx
index f0027e15..a2bece51 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,11 +6,23 @@ extern "C" {
 #else
 #include <netinet/in.h>
 #endif
+#include <cctype>		// for isalpha
 #include <map>
 #include <sstream>
 #include "gdcmUtil.h"
 
-#define LGR_ENTETE_A_LIRE 256 // on ne lit plus que le debut
+#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,23 +33,21 @@ gdcmDictSet* gdcmHeader::Dicts = new gdcmDictSet();
 void gdcmHeader::Initialise(void) {
 	if (!gdcmHeader::dicom_vr)
 		InitVRDict();
-	bool grPixelTrouve = false;
-	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;
 }
 
@@ -50,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;	
 }
 
@@ -105,135 +112,135 @@ void gdcmHeader::CheckSwap()
 	 
 	int lgrLue;
 	char * entCur;
-	char deb[LGR_ENTETE_A_LIRE];
+	char deb[HEADER_LENGHT_TO_READ];
 	 
-	// On teste le processeur
-	if (x==ntohs(x)) {
+	// First, compare HostByteOrder and NetworkByteOrder in order to
+	// determine if we shall need to swap bytes (i.e. the Endian type).
+	if (x==ntohs(x))
 		net2host = true;
-	} else {
+	else
 		net2host = false;
-	}
 	
-	// On commence par verifier si c'est du DICOM 'actuel'
-	//                                      -------------
-	lgrLue = fread(deb,1,LGR_ENTETE_A_LIRE, fp);
+	// The easiest case is the one of a DICOM header, since it possesses a
+	// file preamble where it suffice to look for the sting "DICM".
+	lgrLue = fread(deb, 1, HEADER_LENGHT_TO_READ, fp);
 	
-	entCur = deb+128;
+	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) {
-		// on saute le File Preamble (souvent a ZERO) : 128 Octets
-		// + le DICM (4), et le (0002, 0000) soit 4 (136 = 128 + 4 + 4)
-		entCur = deb+136;
+		// Next, determine the value representation (VR). Let's skip to the
+		// first element (0002, 0000) and check there if we find "UL", in
+		// which case we (almost) know it is explicit VR.
+		// WARNING: if it happens to be implicit VR then what we will read
+		// is the length of the group. If this ascii representation of this
+		// length happens to be "UL" then we shall believe it is explicit VR.
+		// FIXME: in order to fix the above warning, we could read the next
+		// element value (or a couple of elements values) in order to make
+		// sure we are not commiting a big mistake.
+		// We need to skip :
+		// * the 128 bytes of File Preamble (often padded with zeroes),
+		// * the 4 bytes of "DICM" string,
+		// * the 4 bytes of the first tag (0002, 0000),
+		// i.e. a total of  136 bytes.
+		entCur = deb + 136;
 		if(memcmp(entCur, "UL", (size_t)2) == 0) {
-			// les 2 premiers octets de la lgr peuvent valoir UL --> Explicit VR
 			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) { // HostByteOrder is different from NetworkByteOrder
-			sw = 0;    // on est sur PC ou DEC --> LITTLE-ENDIAN -> Rien a faire
-			dbg.Verbose(0, "gdcmHeader::CheckSwap:",
-			               "HostByteOrder = NetworkByteOrder");
-		} else {    /* on est sur une Sun ou une SGI */
+
+		if (net2host) {
 			sw = 4321;
-			dbg.Verbose(0, "gdcmHeader::CheckSwap:",
+			dbg.Verbose(1, "gdcmHeader::CheckSwap:",
 			               "HostByteOrder != NetworkByteOrder");
+		} else {
+			sw = 0;
+			dbg.Verbose(1, "gdcmHeader::CheckSwap:",
+			               "HostByteOrder = NetworkByteOrder");
 		}
 		
+		// Position the file position indicator at first tag (i.e.
+		// after the file preamble and the "DICM" string).
 		rewind(fp);
-		fseek (fp, 132L, SEEK_SET); //On se positionne sur le debut des info
-		offsetCourant=132;
+		fseek (fp, 132L, SEEK_SET);
+		return;
 	} // End of TrueDicom
 
-	// Pas du TrueDicom : permiere hypothese c'est de l'ACR 'propre', auquel
-	// cas la lgr du premier element du groupe est FORCEMENT 4
-	entCur=deb + 4;
-	s=str2num(entCur,int);
+	// Alas, this is not a DicomV3 file and whatever happens there is no file
+	// preamble. We can reset the file position indicator to where the data
+	// is (i.e. the beginning of the file).
+	rewind(fp);
+
+	// Our next best chance would be to be considering a 'clean' ACR/NEMA file.
+	// By clean we mean that the length of the first tag is written down.
+	// If this is the case and since the length of the first group HAS to be
+	// four (bytes), then determining the proper swap code is straightforward.
+
+	entCur = deb + 4;
+	s = str2num(entCur, guint32);
 	
 	switch (s) {
 	case 0x00040000 :
-		sw=3412;
+		sw = 3412;
 		filetype = ACR;
-		break;
+		return;
 	case 0x04000000 :
-		sw=4321;
+		sw = 4321;
 		filetype = ACR;
-		break;
+		return;
 	case 0x00000400 :
-		sw=2143;
-			filetype = ACR;
-		break;
+		sw = 2143;
+		filetype = ACR;
+		return;
 	case 0x00000004 :
-		sw=0;
+		sw = 0;
 		filetype = ACR;
-		break;
+		return;
 	default :
-		sw = -1;
 		dbg.Verbose(0, "gdcmHeader::CheckSwap:",
-		               "unfound swap info (time to raise bets)");
-	}
-	if(sw!=-1) {
-		rewind(fp);    // les info commencent au debut
-		offsetCourant=0;
-		return;
+		               "ACE/NEMA unfound swap info (time to raise bets)");
 	}
 
-	// Deuxieme hypothese : c'est de l'ACR 'pas propre' i.e. il manque
-	// la lgr du groupe
+	// 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.
+	//FIXME  Si c'est du RAW, ca degagera + tard
 	
-	// On n'a pas trouve l'info de swap.
-	// Si c'est du VRAI ACR NEMA et
-	//  * si on est sur une DEC ou un PC alors swap=0,
-	//  * si on est sur SUN ou SGI,      alors swap=4321
-	// Si c'est du RAW, ca degagera + tard
-	dbg.Verbose(0, "gdcmHeader::CheckSwap:",
-	               "time for wild guesses...");
-	
-	if (x!=ntohs(x)) // HostByteOrder is different from NetworkByteOrder
-		// on est sur PC ou DEC --> LITTLE-ENDIAN -> Rien a faire
+	if (! net2host )
 		sw = 0;
 	else
-		// on est sur Sun ou SGI
 		sw = 4321;
-	rewind(fp);    // les info commencent au debut
-	offsetCourant=0;
 	return;
 }
 
-/**
- * \ingroup gdcmHeader
- * \brief   Pour les fichiers non TrueDicom, si le recognition
- *          code (0008,0010) s'avere etre "ACR_LIBIDO", alors
- *          valide la reconnaissance du fichier en positionnant
- *          filetype.
- */
-void gdcmHeader::setAcrLibido() {
-	string RecCode;
-	
-	if ( filetype != TrueDicom) {
-		printf("_setAcrLibido expects a presumably ACR file\n");
-		// Recognition Code  --> n'existe plus en DICOM V3 ...
-		RecCode = GetPubElValByNumber(0x0008, 0x0010);
-		// FIXME NOW
-		if (RecCode == "ACRNEMA_LIBIDO" ||
-		    RecCode == "CANRME_AILIBOD" )
-			filetype = ACR_LIBIDO;
-		else
-			filetype = ACR;
+void gdcmHeader::SwitchSwapToBigEndian(void) {
+	dbg.Verbose(1, "gdcmHeader::FindLength", "Switching to BigEndian mode.");
+	if ( sw == 0    ) {
+		sw = 4321;
+		return;
 	}
-	return;
+	if ( sw == 4321 ) {
+		sw = 0;
+		return;
+	}
+	if ( sw == 3412 ) {
+		sw = 2143;
+		return;
+	}
+	if ( sw == 2143 )
+		sw = 3412;
 }
 
 /**
@@ -275,113 +282,179 @@ void gdcmHeader::setAcrLibido() {
  * @return               longueur retenue pour le champ 
  */
 
-long int gdcmHeader::RecupLgr( ElValue *pleCourant, int *skippedLength) {
-	guint32 l_gr; 
-	unsigned short int l_gr_2;
-	int i;
-	char VR[5];
+void gdcmHeader::FindVR( ElValue *ElVal) {
+	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
+	// cases (see e-film filtered files) one finds implicit VR tags mixed
+	// 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.
+	bool RealExplicit = true;
 	
-	//  FIX ME
-	//   ATTENTION : nbCode correspond au nombre d'elements dans la table
-	//               de type DICOM_VR. A nettoyer.
-	//
-	int nbCode=26;
-	
-	if (filetype == ExplicitVR) {
-		lgrLue=fread (&VR, (size_t)2,(size_t)1, fp);
-		VR[2]=0;
+	if (filetype != ExplicitVR)
+		return;
+
+	lgrLue=fread (&VR, (size_t)2,(size_t)1, fp);
+	VR[2]=0;
+	vr = string(VR);
 		
-		// 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
-		// cases (see e-film filtered files) one finds implicit VR tags mixed
-		// 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);
-		} else {
-			
-			// On est mal : implicit VR repere
-			// mais ce n'est pas un code connu ...
-			// On reconstitue la longueur
-			
-			dbg.Verbose(1, "gdcmHeader::RecupLgr:",
-							"Explicit VR, but no known code");
-			memcpy(&l_gr, VR,(size_t)2);
-			lgrLue=fread ( ((char*)&l_gr)+2, (size_t)2, (size_t)1, fp);
-			l_gr = SwapLong((guint32)l_gr);
-			pleCourant->SetLgrLue(l_gr);
-			if ( (int)l_gr == -1)
-				l_gr=0;
-			 
-			*skippedLength = 4; 
-			return(l_gr);
+	// 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() ) 
+			ElVal->SetVR(vr);
+		return; 
+	}
+	
+	// We thought this was explicit VR, but we end up with an
+	// implicit VR tag. Let's backtrack.
+	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();
+}
+
+/**
+ * \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);
+}
+
+void gdcmHeader::FindLength( ElValue * ElVal) {
+	guint16 element = ElVal->GetElement();
+	string  vr      = ElVal->GetVR();
+	guint16 length16;
+	
+	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);
+			FixFoundLength(ElVal, ReadInt32());
+			return;
 		}
+
+		// Length is encoded on 2 bytes.
+		length16 = ReadInt16();
 		
-		// On repart dans la sequence 'sensee'
-		if ( (!memcmp( VR,"OB",(size_t)2 )) || 
-		     (!memcmp( VR,"OW",(size_t)2 )) || 
-		     (!memcmp( VR,"SQ",(size_t)2 )) ||
-		     (!memcmp( VR,"UN",(size_t)2 )) ) {
-			
-			// les 2 octets suivants sont reserves: on les saute
-			fseek(fp, 2L,SEEK_CUR);
-			
-			//on lit la lgr sur QUATRE octets
-			lgrLue=fread (&l_gr, (size_t)4,(size_t)1, fp);
-			l_gr = SwapLong((guint32)l_gr);
-			*skippedLength = 8;
-		
-		} else {
-			//on lit la lgr sur DEUX octets
-			lgrLue=fread (&l_gr_2, (size_t)2,(size_t)1, fp);
-			
-			if(sw) l_gr_2 = SwapShort((unsigned short)l_gr_2);
-			
-			pleCourant->SetLgrLue(l_gr_2);
-			
-			if ( l_gr_2 == 0xffff) {
-				l_gr = 0;
-			} else {
-				l_gr = l_gr_2;
+		// 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 bie 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 to wait 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);
 			}
-			*skippedLength = 4;
+			// FIXME this can create a memory leaks on the old entry that be
+			// left unreferenced.
+			ElVal->SetDictEntry(NewTag);
 		}
-	} else {
-		// Explicit VR = 0
-		//on lit la lgr sur QUATRE octets
-		
-		lgrLue=fread (&l_gr, (size_t)4,(size_t)1, fp);
-		
-		l_gr= SwapLong((long)l_gr);
-		*skippedLength = 4;
-	}
-	
-	pleCourant->SetLgrLue(l_gr);
-	
-	// Traitement des curiosites sur la longueur
-	
-	if ( (int)l_gr == 0xffffffff)
-		l_gr=0; 
-	
-	if(!memcmp( VR,"SQ",(size_t)2 )) { // ca annonce une SEQUENCE d'items ?!
-		l_gr=0;                         // on lira donc les items de la sequence 
+		 
+		// 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;
 	}
-	
-	return(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 ...
@@ -409,214 +482,273 @@ 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::SkipElementValue(ElValue * ElVal) {
+	//FIXME don't dump the returned value
+	(void)fseek(fp, (long)ElVal->GetLength(), SEEK_CUR);
+}
+
+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  
  */
+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;
 
-ElValue * gdcmHeader::ReadNextElement(void) {
-	unsigned short g;
-	unsigned short n;
-	guint32 l;
-	long int posFich;
-	int skL;
-	size_t lgrLue;
-	//CLEANME DICOM_ELEMENTS *t;
-	ElValue * nouvDcmElem;
+	fseek(fp, (long)ElVal->GetOffset(), SEEK_SET);
 	
-	// FIXME la probabilte pour depasser sans s'en rendre compte
-	// est grande avec le test d'egalite' suivant !
-	if(offsetCourant == taille_fich) { // On a atteint la fin du fichier
-		dbg.Verbose(1, "ReadNextElement: EOF reached");
-		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;
 	}
-	
-	// ------------------------- Lecture Num group : g
-	lgrLue=fread (&g, (size_t)2,(size_t)1, fp);
-	
-	if (feof(fp))  {
-		dbg.Verbose(1, "ReadNextElement: EOF encountered");
-		return (NULL);
+
+	// When the length is zero things are easy:
+	if ( length == 0 ) {
+		ElVal->SetValue("");
+		return;
 	}
-	if (ferror(fp)){
-		dbg.Verbose(1, "ReadNextElement: failed to read NumGr");
-		return (NULL);
+
+	// 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;
 	}
 
-	// ------------------------- Lecture longueur element : l
-	
-	l = RecupLgr(nouvDcmElem, &skL);
-	
-	if(g==0xfffe) l=0;  // pour sauter les indicateurs de 'SQ'
+	FindVR(NewElVal);
+	try { FindLength(NewElVal); }
+	catch ( Error::FileReadError ) { // Call it quits
+		return (ElValue *)0;
+	}
+	NewElVal->SetOffset(ftell(fp));
+	return NewElVal;
+}
+
+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)
+			return true;
+		else
+			dbg.Error("gdcmHeader::IsAnInteger",
+			          "Erroneous Group Length element length.");
+	}
 	
-	nouvDcmElem->LgrElem=l;
+	if ( group % 2 != 0 )
+		// We only have some semantics on documented elements, which are
+		// the even ones.
+		return false;
 	
-	// ------------------------- Lecture Valeur element 
+	if ( (length != 4) && ( length != 2) )
+		// Swapping only make sense on integers which are 2 or 4 bytes long.
+		return false;
 	
-	// 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);
-	}
+	if ( (vr == "UL") || (vr == "US") || (vr == "SL") || (vr == "SS") )
+		return true;
 	
-	// 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 ( (group == 0x0028) && (element == 0x0005) )
+		// This tag is retained from ACR/NEMA
+		// CHECKME Why should "Image Dimensions" be a single integer ?
+		return true;
 	
-	offsetCourant +=  2 + 2 + skL; // gr +  num + lgr
-	nouvDcmElem->Offset = offsetCourant;
-	offsetCourant += l;            // debut elem suivant
-
-	// ------------------------- Doit-on le Swapper ?
+	if ( (group == 0x0028) && (element == 0x0200) )
+		// This tag is retained from ACR/NEMA
+		return true;
 	
-	if ((n==0) && sw)  {  // n=0 : lgr du groupe : guint32
-		*(guint32 *) NewValue = SwapLong ((*(guint32 *) NewValue));  
-	} else {
-		if(sw) {
-			if ( (g/2)*2-g==0) { /* on ne teste pas les groupes impairs */
-				
-				if ((l==4)||(l==2)) {  // pour eviter de swapper les chaines 
-					                    // de lgr 2 ou 4
-					
-					// FIXME make reference to nouvDcmElem->GetTag
-					string VR = NewTag->GetVR();
-					if (   (VR == "UL") || (VR == "US")
-					    || (VR == "SL") || (VR == "SS")
-					    || (g == 0x0028 && ( n == 0x0005 || n == 0x0200) )) {
-						// seuls (28,5) de vr RET et (28,200) sont des entiers
-						// ... jusqu'a preuve du contraire
-						
-						if(l==4) { 
-							*(guint32 *) NewValue =
-							    SwapLong  ((*(guint32 *) NewValue)); 
-						} else {
-							if(l==2) 
-						    *(unsigned short *) NewValue =
-						    	SwapShort ((*(unsigned short *)NewValue));
-						 }
-					}
-				} /* fin if l==2 ==4 */
-			} /* fin if g pair */
-		} /* fin sw */	
-	}
-	nouvDcmElem->value = NewValue;
-	// CLEAN ME: simply trash the following line and postpone the process !
-	// SetAsidePixelData(nouvDcmElem);
-	return nouvDcmElem;
+	return false;
 }
 
 /**
  * \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) {
-	  /// FIXME this wall process is bizarre:
-	  // on peut pas lire pixel data et pixel location puis
-	  // a la fin de la lecture aller interpreter ce qui existe ?
-	  // penser a nettoyer les variables globales associes genre
-	  // PixelsTrouve ou grPixelTrouve...
-	  //
-	// 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 it.
-	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->GetLgrElem()+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) {
@@ -638,36 +770,43 @@ gdcmDictEntry * gdcmHeader::IsInDicts(guint32 group, guint32 element) {
 	return found;
 }
 
-string gdcmHeader::GetPubElValByNumber(unsigned short, unsigned short) {
+string gdcmHeader::GetPubElValByNumber(guint16 group, guint16 element) {
+	return PubElVals.GetElValue(group, element);
+}
+
+string gdcmHeader::GetPubElValByName(string TagName) {
+	return PubElVals.GetElValue(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);
-	fseek(fp, 0L, SEEK_END);
-	/*
-	 * obtains the current value of the file-position    
-	 * indicator for the stream pointed to by stream      
-	 */
-	taille_fich = ftell(fp);
 	rewind(fp);
 	CheckSwap();
 	while ( (newElValue = ReadNextElement()) ) {
+		SkipElementValue(newElValue);
 		PubElVals.Add(newElValue);
 	}
-	setAcrLibido();
 }
 
-int gdcmHeader::PrintPubElVal(ostream & os) {
-	return PubElVals.Print(os);
+/**
+ * \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) {
+	PubElVals.Print(os);
 }
 
 void gdcmHeader::PrintPubDict(ostream & os) {