]> Creatis software - gdcm.git/blob - src/gdcmHeader.cxx
* Corrected a leak, the pSource was find thanks to valgrind. valgrind rules !
[gdcm.git] / src / gdcmHeader.cxx
1
2 // $Header: /cvs/public/gdcm/src/Attic/gdcmHeader.cxx,v 1.80 2003/07/28 12:21:09 malaterre Exp $
3
4 #include <stdio.h>
5 #include <cerrno>
6 // For nthos:
7 #ifdef _MSC_VER
8 #include <winsock.h>
9 #else
10 #include <netinet/in.h>
11 #endif
12 #include <cctype>    // for isalpha
13 #include <sstream>
14 #include "gdcmUtil.h"
15 #include "gdcmHeader.h"
16 using namespace std;
17 #include "gdcmTS.h"
18
19
20 // TODO : remove DEBUG
21 #define DEBUG 0
22
23 // Refer to gdcmHeader::CheckSwap()
24 #define HEADER_LENGTH_TO_READ       256
25 // Refer to gdcmHeader::SetMaxSizeLoadElementValue()
26 //#define _MaxSizeLoadElementValue_   1024
27 #define _MaxSizeLoadElementValue_   4096
28 /**
29  * \ingroup gdcmHeader
30  * \brief   
31  */
32 void gdcmHeader::Initialise(void) {
33    dicom_vr = gdcmGlobal::GetVR();
34    dicom_ts = gdcmGlobal::GetTS();
35    Dicts =    gdcmGlobal::GetDicts();
36    RefPubDict = Dicts->GetDefaultPubDict();
37    RefShaDict = (gdcmDict*)0;
38 }
39
40 /**
41  * \ingroup gdcmHeader
42  * \brief   
43  * @param   InFilename
44  * @param   exception_on_error
45  */
46 gdcmHeader::gdcmHeader(const char *InFilename, bool exception_on_error) {
47    SetMaxSizeLoadElementValue(_MaxSizeLoadElementValue_);
48    filename = InFilename;
49    Initialise();
50    if ( !OpenFile(exception_on_error))
51       return;
52    ParseHeader();
53    LoadElements();
54    CloseFile();
55 }
56
57 /**
58  * \ingroup gdcmHeader
59  * \brief   
60  * @param   exception_on_error
61  */
62 gdcmHeader::gdcmHeader(bool exception_on_error) {
63   SetMaxSizeLoadElementValue(_MaxSizeLoadElementValue_);
64   Initialise();
65 }
66
67 /**
68  * \ingroup gdcmHeader
69  * \brief   
70  * @param   exception_on_error
71  * @return  
72  */
73  bool gdcmHeader::OpenFile(bool exception_on_error)
74   throw(gdcmFileError) {
75   fp=fopen(filename.c_str(),"rb");
76   if(exception_on_error) {
77     if(!fp)
78       throw gdcmFileError("gdcmHeader::gdcmHeader(const char *, bool)");
79   }
80   if ( fp )
81      return true;
82   dbg.Verbose(0, "gdcmHeader::gdcmHeader cannot open file", filename.c_str());
83   return false;
84 }
85
86 /**
87  * \ingroup gdcmHeader
88  * \brief   
89  * @return  TRUE if the close was successfull 
90  */
91 bool gdcmHeader::CloseFile(void) {
92   int closed = fclose(fp);
93   fp = (FILE *)0;
94   if (! closed)
95      return false;
96   return true;
97 }
98
99 /**
100  * \ingroup gdcmHeader
101  * \brief   Canonical destructor.
102  */
103 gdcmHeader::~gdcmHeader (void) {
104    dicom_vr =   (gdcmVR*)0; 
105    Dicts    =   (gdcmDictSet*)0;
106    RefPubDict = (gdcmDict*)0;
107    RefShaDict = (gdcmDict*)0;
108    return;
109 }
110
111 // Fourth semantics:
112 // CMD      Command        
113 // META     Meta Information 
114 // DIR      Directory
115 // ID
116 // PAT      Patient
117 // ACQ      Acquisition
118 // REL      Related
119 // IMG      Image
120 // SDY      Study
121 // VIS      Visit 
122 // WAV      Waveform
123 // PRC
124 // DEV      Device
125 // NMI      Nuclear Medicine
126 // MED
127 // BFS      Basic Film Session
128 // BFB      Basic Film Box
129 // BIB      Basic Image Box
130 // BAB
131 // IOB
132 // PJ
133 // PRINTER
134 // RT       Radio Therapy
135 // DVH   
136 // SSET
137 // RES      Results
138 // CRV      Curve
139 // OLY      Overlays
140 // PXL      Pixels
141 // DL       Delimiters
142 //
143
144 /**
145  * \ingroup gdcmHeader
146  * \brief   Discover what the swap code is (among little endian, big endian,
147  *          bad little endian, bad big endian).
148  *
149  */
150 void gdcmHeader::CheckSwap()
151 {
152    // The only guaranted way of finding the swap code is to find a
153    // group tag since we know it's length has to be of four bytes i.e.
154    // 0x00000004. Finding the swap code in then straigthforward. Trouble
155    // occurs when we can't find such group...
156    guint32  s;
157    guint32  x=4;  // x : for ntohs
158    bool net2host; // true when HostByteOrder is the same as NetworkByteOrder
159     
160    int lgrLue;
161    char * entCur;
162    char deb[HEADER_LENGTH_TO_READ];
163     
164    // First, compare HostByteOrder and NetworkByteOrder in order to
165    // determine if we shall need to swap bytes (i.e. the Endian type).
166    if (x==ntohs(x))
167       net2host = true;
168    else
169       net2host = false;
170    
171    // The easiest case is the one of a DICOM header, since it possesses a
172    // file preamble where it suffice to look for the string "DICM".
173    lgrLue = fread(deb, 1, HEADER_LENGTH_TO_READ, fp);
174    
175    entCur = deb + 128;
176    if(memcmp(entCur, "DICM", (size_t)4) == 0) {
177       dbg.Verbose(1, "gdcmHeader::CheckSwap:", "looks like DICOM Version3");
178       // Next, determine the value representation (VR). Let's skip to the
179       // first element (0002, 0000) and check there if we find "UL" 
180       // - or "OB" if the 1st one is (0002,0001) -,
181       // in which case we (almost) know it is explicit VR.
182       // WARNING: if it happens to be implicit VR then what we will read
183       // is the length of the group. If this ascii representation of this
184       // length happens to be "UL" then we shall believe it is explicit VR.
185       // FIXME: in order to fix the above warning, we could read the next
186       // element value (or a couple of elements values) in order to make
187       // sure we are not commiting a big mistake.
188       // We need to skip :
189       // * the 128 bytes of File Preamble (often padded with zeroes),
190       // * the 4 bytes of "DICM" string,
191       // * the 4 bytes of the first tag (0002, 0000),or (0002, 0001)
192       // i.e. a total of  136 bytes.
193       entCur = deb + 136;
194       // FIXME
195       // Use gdcmHeader::dicom_vr to test all the possibilities
196       // instead of just checking for UL, OB and UI !?
197       if(  (memcmp(entCur, "UL", (size_t)2) == 0) ||
198            (memcmp(entCur, "OB", (size_t)2) == 0) ||
199            (memcmp(entCur, "UI", (size_t)2) == 0) )   
200       {
201          filetype = ExplicitVR;
202          dbg.Verbose(1, "gdcmHeader::CheckSwap:",
203                      "explicit Value Representation");
204       } else {
205          filetype = ImplicitVR;
206          dbg.Verbose(1, "gdcmHeader::CheckSwap:",
207                      "not an explicit Value Representation");
208       }
209       if (net2host) {
210          sw = 4321;
211          dbg.Verbose(1, "gdcmHeader::CheckSwap:",
212                         "HostByteOrder != NetworkByteOrder");
213       } else {
214          sw = 0;
215          dbg.Verbose(1, "gdcmHeader::CheckSwap:",
216                         "HostByteOrder = NetworkByteOrder");
217       }
218       
219       // Position the file position indicator at first tag (i.e.
220       // after the file preamble and the "DICM" string).
221       rewind(fp);
222       fseek (fp, 132L, SEEK_SET);
223       return;
224    } // End of DicomV3
225
226    // Alas, this is not a DicomV3 file and whatever happens there is no file
227    // preamble. We can reset the file position indicator to where the data
228    // is (i.e. the beginning of the file).
229     dbg.Verbose(1, "gdcmHeader::CheckSwap:", "not a DICOM Version3 file");
230    rewind(fp);
231
232    // Our next best chance would be to be considering a 'clean' ACR/NEMA file.
233    // By clean we mean that the length of the first tag is written down.
234    // If this is the case and since the length of the first group HAS to be
235    // four (bytes), then determining the proper swap code is straightforward.
236
237    entCur = deb + 4;
238    // We assume the array of char we are considering contains the binary
239    // representation of a 32 bits integer. Hence the following dirty
240    // trick :
241    s = *((guint32 *)(entCur));
242    
243    switch (s) {
244    case 0x00040000 :
245       sw = 3412;
246       filetype = ACR;
247       return;
248    case 0x04000000 :
249       sw = 4321;
250       filetype = ACR;
251       return;
252    case 0x00000400 :
253       sw = 2143;
254       filetype = ACR;
255       return;
256    case 0x00000004 :
257       sw = 0;
258       filetype = ACR;
259       return;
260    default :
261       dbg.Verbose(0, "gdcmHeader::CheckSwap:",
262                      "ACR/NEMA unfound swap info (time to raise bets)");
263    }
264
265    // We are out of luck. It is not a DicomV3 nor a 'clean' ACR/NEMA file.
266    // It is time for despaired wild guesses. So, let's assume this file
267    // happens to be 'dirty' ACR/NEMA, i.e. the length of the group is
268    // not present. Then the only info we have is the net2host one.
269    filetype = Unknown;
270    if (! net2host )
271       sw = 0;
272    else
273       sw = 4321;
274    return;
275 }
276
277 /**
278  * \ingroup gdcmHeader
279  * \brief   
280  */
281 void gdcmHeader::SwitchSwapToBigEndian(void) {
282    dbg.Verbose(1, "gdcmHeader::SwitchSwapToBigEndian",
283                   "Switching to BigEndian mode.");
284    if ( sw == 0    ) {
285       sw = 4321;
286       return;
287    }
288    if ( sw == 4321 ) {
289       sw = 0;
290       return;
291    }
292    if ( sw == 3412 ) {
293       sw = 2143;
294       return;
295    }
296    if ( sw == 2143 )
297       sw = 3412;
298 }
299
300 /**
301  * \ingroup   gdcmHeader
302  * \brief     Find the value representation of the current tag.
303  * @param ElVal
304  */
305 void gdcmHeader::FindVR( gdcmElValue *ElVal) {
306    if (filetype != ExplicitVR)
307       return;
308
309    char VR[3];
310    string vr;
311    int lgrLue;
312    char msg[100]; // for sprintf. Sorry
313
314    long PositionOnEntry = ftell(fp);
315    // Warning: we believe this is explicit VR (Value Representation) because
316    // we used a heuristic that found "UL" in the first tag. Alas this
317    // doesn't guarantee that all the tags will be in explicit VR. In some
318    // cases (see e-film filtered files) one finds implicit VR tags mixed
319    // within an explicit VR file. Hence we make sure the present tag
320    // is in explicit VR and try to fix things if it happens not to be
321    // the case.
322    bool RealExplicit = true;
323    
324    lgrLue=fread (&VR, (size_t)2,(size_t)1, fp);
325    VR[2]=0;
326    vr = string(VR);
327       
328    // Assume we are reading a falsely explicit VR file i.e. we reached
329    // a tag where we expect reading a VR but are in fact we read the
330    // first to bytes of the length. Then we will interogate (through find)
331    // the dicom_vr dictionary with oddities like "\004\0" which crashes
332    // both GCC and VC++ implementations of the STL map. Hence when the
333    // expected VR read happens to be non-ascii characters we consider
334    // we hit falsely explicit VR tag.
335
336    if ( (!isalpha(VR[0])) && (!isalpha(VR[1])) )
337       RealExplicit = false;
338
339    // CLEANME searching the dicom_vr at each occurence is expensive.
340    // PostPone this test in an optional integrity check at the end
341    // of parsing or only in debug mode.
342    if ( RealExplicit && !dicom_vr->Count(vr) )
343       RealExplicit= false;
344
345    if ( RealExplicit ) {
346       if ( ElVal->IsVrUnknown() ) {
347          // When not a dictionary entry, we can safely overwrite the vr.
348          ElVal->SetVR(vr);
349          return; 
350       }
351       if ( ElVal->GetVR() == vr ) {
352          // The vr we just read and the dictionary agree. Nothing to do.
353          return;
354       }
355       // The vr present in the file and the dictionary disagree. We assume
356       // the file writer knew best and use the vr of the file. Since it would
357       // be unwise to overwrite the vr of a dictionary (since it would
358       // compromise it's next user), we need to clone the actual DictEntry
359       // and change the vr for the read one.
360       gdcmDictEntry* NewTag = new gdcmDictEntry(ElVal->GetGroup(),
361                                  ElVal->GetElement(),
362                                  vr,
363                                  "FIXME",
364                                  ElVal->GetName());
365       ElVal->SetDictEntry(NewTag);
366       return; 
367    }
368    
369    // We thought this was explicit VR, but we end up with an
370    // implicit VR tag. Let's backtrack.   
371    
372       sprintf(msg,"Falsely explicit vr file (%04x,%04x)\n", ElVal->GetGroup(),ElVal->GetElement());
373       dbg.Verbose(1, "gdcmHeader::FindVR: ",msg);
374    
375    fseek(fp, PositionOnEntry, SEEK_SET);
376    // When this element is known in the dictionary we shall use, e.g. for
377    // the semantics (see  the usage of IsAnInteger), the vr proposed by the
378    // dictionary entry. Still we have to flag the element as implicit since
379    // we know now our assumption on expliciteness is not furfilled.
380    // avoid  .
381    if ( ElVal->IsVrUnknown() )
382       ElVal->SetVR("Implicit");
383    ElVal->SetImplicitVr();
384 }
385
386 /**
387  * \ingroup gdcmHeader
388  * \brief   Determines if the Transfer Syntax was already encountered
389  *          and if it corresponds to a ImplicitVRLittleEndian one.
390  *
391  * @return  True when ImplicitVRLittleEndian found. False in all other cases.
392  */
393 bool gdcmHeader::IsImplicitVRLittleEndianTransferSyntax(void) {
394    gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010);
395    if ( !Element )
396       return false;
397    LoadElementValueSafe(Element);
398    string Transfer = Element->GetValue();
399    if ( Transfer == "1.2.840.10008.1.2" )
400       return true;
401    return false;
402 }
403
404 /**
405  * \ingroup gdcmHeader
406  * \brief   Determines if the Transfer Syntax was already encountered
407  *          and if it corresponds to a ExplicitVRLittleEndian one.
408  *
409  * @return  True when ExplicitVRLittleEndian found. False in all other cases.
410  */
411 bool gdcmHeader::IsExplicitVRLittleEndianTransferSyntax(void) {
412    gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010);
413    if ( !Element )
414       return false;
415    LoadElementValueSafe(Element);
416    string Transfer = Element->GetValue();
417    if ( Transfer == "1.2.840.10008.1.2.1" )
418       return true;
419    return false;
420 }
421
422 /**
423  * \ingroup gdcmHeader
424  * \brief   Determines if the Transfer Syntax was already encountered
425  *          and if it corresponds to a DeflatedExplicitVRLittleEndian one.
426  *
427  * @return  True when DeflatedExplicitVRLittleEndian found. False in all other cases.
428  */
429 bool gdcmHeader::IsDeflatedExplicitVRLittleEndianTransferSyntax(void) {
430    gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010);
431    if ( !Element )
432       return false;
433    LoadElementValueSafe(Element);
434    string Transfer = Element->GetValue();
435    if ( Transfer == "1.2.840.10008.1.2.1.99" )
436       return true;
437    return false;
438 }
439
440 /**
441  * \ingroup gdcmHeader
442  * \brief   Determines if the Transfer Syntax was already encountered
443  *          and if it corresponds to a Explicit VR Big Endian one.
444  *
445  * @return  True when big endian found. False in all other cases.
446  */
447 bool gdcmHeader::IsExplicitVRBigEndianTransferSyntax(void) {
448    gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010);
449    if ( !Element )
450       return false;
451    LoadElementValueSafe(Element);
452    string Transfer = Element->GetValue();
453    if ( Transfer == "1.2.840.10008.1.2.2" )  //1.2.2 ??? A verifier !
454       return true;
455    return false;
456 }
457
458 /**
459  * \ingroup gdcmHeader
460  * \brief   Determines if the Transfer Syntax was already encountered
461  *          and if it corresponds to a JPEGBaseLineProcess1 one.
462  *
463  * @return  True when JPEGBaseLineProcess1found. False in all other cases.
464  */
465 bool gdcmHeader::IsJPEGBaseLineProcess1TransferSyntax(void) {
466    gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010);
467    if ( !Element )
468       return false;
469    LoadElementValueSafe(Element);
470    string Transfer = Element->GetValue();
471    if ( Transfer == "1.2.840.10008.1.2.4.50" )
472       return true;
473    return false;
474 }
475
476 /**
477  * \ingroup gdcmHeader
478  * \brief   
479  *
480  * @return 
481  */
482 bool gdcmHeader::IsJPEGLossless(void) {
483    gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010);
484     // faire qq chose d'intelligent a la place de ça
485    if ( !Element )
486       return false;
487    LoadElementValueSafe(Element);
488    const char * Transfert = Element->GetValue().c_str();
489    if ( memcmp(Transfert+strlen(Transfert)-2 ,"70",2)==0) return true;
490    if ( memcmp(Transfert+strlen(Transfert)-2 ,"55",2)==0) return true;
491    return false;
492 }
493
494
495 /**
496  * \ingroup gdcmHeader
497  * \brief   Determines if the Transfer Syntax was already encountered
498  *          and if it corresponds to a JPEGExtendedProcess2-4 one.
499  *
500  * @return  True when JPEGExtendedProcess2-4 found. False in all other cases.
501  */
502 bool gdcmHeader::IsJPEGExtendedProcess2_4TransferSyntax(void) {
503    gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010);
504    if ( !Element )
505       return false;
506    LoadElementValueSafe(Element);
507    string Transfer = Element->GetValue();
508    if ( Transfer == "1.2.840.10008.1.2.4.51" )
509       return true;
510    return false;
511 }
512
513 /**
514  * \ingroup gdcmHeader
515  * \brief   Determines if the Transfer Syntax was already encountered
516  *          and if it corresponds to a JPEGExtendeProcess3-5 one.
517  *
518  * @return  True when JPEGExtendedProcess3-5 found. False in all other cases.
519  */
520 bool gdcmHeader::IsJPEGExtendedProcess3_5TransferSyntax(void) {
521    gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010);
522    if ( !Element )
523       return false;
524    LoadElementValueSafe(Element);
525    string Transfer = Element->GetValue();
526    if ( Transfer == "1.2.840.10008.1.2.4.52" )
527       return true;
528    return false;
529 }
530
531 /**
532  * \ingroup gdcmHeader
533  * \brief   Determines if the Transfer Syntax was already encountered
534  *          and if it corresponds to a JPEGSpectralSelectionProcess6-8 one.
535  *
536  * @return  True when JPEGSpectralSelectionProcess6-8 found. False in all
537  *          other cases.
538  */
539 bool gdcmHeader::IsJPEGSpectralSelectionProcess6_8TransferSyntax(void) {
540    gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010);
541    if ( !Element )
542       return false;
543    LoadElementValueSafe(Element);
544    string Transfer = Element->GetValue();
545    if ( Transfer == "1.2.840.10008.1.2.4.53" )
546       return true;
547    return false;
548 }
549
550 /**
551  * \ingroup gdcmHeader
552  * \brief   Determines if the Transfer Syntax was already encountered
553  *          and if it corresponds to a RLE Lossless one.
554  *
555  * @return  True when RLE Lossless found. False in all
556  *          other cases.
557  */
558 bool gdcmHeader::IsRLELossLessTransferSyntax(void) {
559    gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010);
560    if ( !Element )
561       return false;
562    LoadElementValueSafe(Element);
563    string Transfer = Element->GetValue();
564    if ( Transfer == "1.2.840.10008.1.2.5" )
565       return true;
566    return false;
567 }
568
569 /**
570  * \ingroup gdcmHeader
571  * \brief   Determines if the Transfer Syntax was already encountered
572  *          and if it corresponds to a JPEG200 one.0
573  *
574  * @return  True when JPEG2000 (Lossly or LossLess) found. False in all
575  *          other cases.
576  */
577 bool gdcmHeader::IsJPEG2000(void) {
578    gdcmElValue* Element = PubElValSet.GetElementByNumber(0x0002, 0x0010);
579    if ( !Element )
580       return false;
581    LoadElementValueSafe(Element);
582    string Transfer = Element->GetValue();
583    if (    (Transfer == "1.2.840.10008.1.2.4.90") 
584         || (Transfer == "1.2.840.10008.1.2.4.91") )
585       return true;
586    return false;
587 }
588
589 /**
590  * \ingroup gdcmHeader
591  * \brief   Predicate for dicom version 3 file.
592  * @return  True when the file is a dicom version 3.
593  */
594 bool gdcmHeader::IsDicomV3(void) {
595    if (   (filetype == ExplicitVR)
596        || (filetype == ImplicitVR) )
597       return true;
598    return false;
599 }
600
601 /**
602  * \ingroup gdcmHeader
603  * \brief   When the length of an element value is obviously wrong (because
604  *          the parser went Jabberwocky) one can hope improving things by
605  *          applying this heuristic.
606  */
607 void gdcmHeader::FixFoundLength(gdcmElValue * ElVal, guint32 FoundLength) {
608    if ( FoundLength == 0xffffffff)
609       FoundLength = 0;
610    ElVal->SetLength(FoundLength);
611 }
612
613 /**
614  * \ingroup gdcmHeader
615  * \brief   
616  *
617  * @return 
618  */
619  guint32 gdcmHeader::FindLengthOB(void) {
620    // See PS 3.5-2001, section A.4 p. 49 on encapsulation of encoded pixel data.
621    guint16 g;
622    guint16 n; 
623    long PositionOnEntry = ftell(fp);
624    bool FoundSequenceDelimiter = false;
625    guint32 TotalLength = 0;
626    guint32 ItemLength;
627
628    while ( ! FoundSequenceDelimiter) {
629       g = ReadInt16();
630       n = ReadInt16();
631       
632       long l = ftell(fp);
633
634       if (errno == 1)
635          return 0;
636       TotalLength += 4;  // We even have to decount the group and element 
637      
638       if ( g != 0xfffe           && g!=0xb00c ) /*for bogus header */ {
639          char msg[100]; // for sprintf. Sorry
640          sprintf(msg,"wrong group (%04x) for an item sequence (%04x,%04x)\n",g, g,n);
641          dbg.Verbose(1, "gdcmHeader::FindLengthOB: ",msg); 
642          long l = ftell(fp);
643          errno = 1;
644          return 0;
645       }
646       if ( n == 0xe0dd       || ( g==0xb00c && n==0x0eb6 ) ) /* for bogus header  */ 
647          FoundSequenceDelimiter = true;
648       else if ( n != 0xe000 ){
649          char msg[100];  // for sprintf. Sorry
650          sprintf(msg,"wrong element (%04x) for an item sequence (%04x,%04x)\n",n, g,n);
651          dbg.Verbose(1, "gdcmHeader::FindLengthOB: ",msg);
652          errno = 1;
653          return 0;
654       }
655       ItemLength = ReadInt32();
656       TotalLength += ItemLength + 4;  // We add 4 bytes since we just read
657                                       // the ItemLength with ReadInt32
658                                       
659       SkipBytes(ItemLength);
660    }
661    fseek(fp, PositionOnEntry, SEEK_SET);
662    return TotalLength;
663 }
664
665 /**
666  * \ingroup gdcmHeader
667  * \brief   
668  *
669  * @return 
670  */
671  void gdcmHeader::FindLength (gdcmElValue * ElVal) {
672    guint16 element = ElVal->GetElement();
673    guint16 group   = ElVal->GetGroup();
674    string  vr      = ElVal->GetVR();
675    guint16 length16;
676    if( (element == 0x0010) && (group == 0x7fe0) ) {
677       dbg.SetDebug(0);
678       dbg.Verbose(2, "gdcmHeader::FindLength: ",
679                      "on est sur 7fe0 0010");
680    }   
681    
682    if ( (filetype == ExplicitVR) && ! ElVal->IsImplicitVr() ) {
683       if ( (vr=="OB") || (vr=="OW") || (vr=="SQ") || (vr=="UN") ) {
684       
685          // The following reserved two bytes (see PS 3.5-2001, section
686          // 7.1.2 Data element structure with explicit vr p27) must be
687          // skipped before proceeding on reading the length on 4 bytes.
688          fseek(fp, 2L, SEEK_CUR);
689
690          guint32 length32 = ReadInt32();
691          if ( (vr == "OB") && (length32 == 0xffffffff) ) {
692             ElVal->SetLength(FindLengthOB());
693             return;
694          }
695          FixFoundLength(ElVal, length32);        
696          return;
697       }
698
699       // Length is encoded on 2 bytes.
700       length16 = ReadInt16();
701       
702       // We can tell the current file is encoded in big endian (like
703       // Data/US-RGB-8-epicard) when we find the "Transfer Syntax" tag
704       // and it's value is the one of the encoding of a big endian file.
705       // In order to deal with such big endian encoded files, we have
706       // (at least) two strategies:
707       // * when we load the "Transfer Syntax" tag with value of big endian
708       //   encoding, we raise the proper flags. Then we wait for the end
709       //   of the META group (0x0002) among which is "Transfer Syntax",
710       //   before switching the swap code to big endian. We have to postpone
711       //   the switching of the swap code since the META group is fully encoded
712       //   in little endian, and big endian coding only starts at the next
713       //   group. The corresponding code can be hard to analyse and adds
714       //   many additional unnecessary tests for regular tags.
715       // * the second strategy consists in waiting for trouble, that shall
716       //   appear when we find the first group with big endian encoding. This
717       //   is easy to detect since the length of a "Group Length" tag (the
718       //   ones with zero as element number) has to be of 4 (0x0004). When we
719       //   encouter 1024 (0x0400) chances are the encoding changed and we
720       //   found a group with big endian encoding.
721       // We shall use this second strategy. In order to make sure that we
722       // can interpret the presence of an apparently big endian encoded
723       // length of a "Group Length" without committing a big mistake, we
724       // add an additional check: we look in the already parsed elements
725       // for the presence of a "Transfer Syntax" whose value has to be "big
726       // endian encoding". When this is the case, chances are we have got our
727       // hands on a big endian encoded file: we switch the swap code to
728       // big endian and proceed...
729       if ( (element  == 0x0000) && (length16 == 0x0400) ) {
730          if ( ! IsExplicitVRBigEndianTransferSyntax() ) {
731             dbg.Verbose(0, "gdcmHeader::FindLength", "not explicit VR");
732             errno = 1;
733             return;
734          }
735          length16 = 4;
736          SwitchSwapToBigEndian();
737          // Restore the unproperly loaded values i.e. the group, the element
738          // and the dictionary entry depending on them.
739          guint16 CorrectGroup   = SwapShort(ElVal->GetGroup());
740          guint16 CorrectElem    = SwapShort(ElVal->GetElement());
741          gdcmDictEntry * NewTag = GetDictEntryByNumber(CorrectGroup,
742                                                        CorrectElem);
743          if (!NewTag) {
744             // This correct tag is not in the dictionary. Create a new one.
745             NewTag = new gdcmDictEntry(CorrectGroup, CorrectElem);
746          }
747          // FIXME this can create a memory leaks on the old entry that be
748          // left unreferenced.
749          ElVal->SetDictEntry(NewTag);
750       }
751        
752       // Heuristic: well some files are really ill-formed.
753       if ( length16 == 0xffff) {
754          length16 = 0;
755          dbg.Verbose(0, "gdcmHeader::FindLength",
756                      "Erroneous element length fixed.");
757       }
758       FixFoundLength(ElVal, (guint32)length16);
759       return;
760    }
761
762    // Either implicit VR or a non DICOM conformal (see not below) explicit
763    // VR that ommited the VR of (at least) this element. Farts happen.
764    // [Note: according to the part 5, PS 3.5-2001, section 7.1 p25
765    // on Data elements "Implicit and Explicit VR Data Elements shall
766    // not coexist in a Data Set and Data Sets nested within it".]
767    // Length is on 4 bytes.
768    FixFoundLength(ElVal, ReadInt32());
769 }
770
771 /**
772  * \ingroup gdcmHeader
773  * \brief   Swaps back the bytes of 4-byte long integer accordingly to
774  *          processor order.
775  *
776  * @return  The suggested integer.
777  */
778 guint32 gdcmHeader::SwapLong(guint32 a) {
779    switch (sw) {
780    case    0 :
781       break;
782    case 4321 :
783       a=(   ((a<<24) & 0xff000000) | ((a<<8)  & 0x00ff0000)    | 
784             ((a>>8)  & 0x0000ff00) | ((a>>24) & 0x000000ff) );
785       break;
786    
787    case 3412 :
788       a=(   ((a<<16) & 0xffff0000) | ((a>>16) & 0x0000ffff) );
789       break;
790    
791    case 2143 :
792       a=(    ((a<<8) & 0xff00ff00) | ((a>>8) & 0x00ff00ff)  );
793       break;
794    default :
795       dbg.Error(" gdcmHeader::SwapLong : unset swap code");
796       a=0;
797    }
798    return(a);
799 }
800
801 /**
802  * \ingroup gdcmHeader
803  * \brief   Swaps the bytes so they agree with the processor order
804  * @return  The properly swaped 16 bits integer.
805  */
806 guint16 gdcmHeader::SwapShort(guint16 a) {
807    if ( (sw==4321)  || (sw==2143) )
808       a =(((a<<8) & 0x0ff00) | ((a>>8)&0x00ff));
809    return (a);
810 }
811
812 /**
813  * \ingroup gdcmHeader
814  * \brief   
815  *
816  * @return 
817  */
818  void gdcmHeader::SkipBytes(guint32 NBytes) {
819    //FIXME don't dump the returned value
820    (void)fseek(fp, (long)NBytes, SEEK_CUR);
821 }
822
823 /**
824  * \ingroup gdcmHeader
825  * \brief   
826  * @param ElVal 
827  * @return 
828  */
829  void gdcmHeader::SkipElementValue(gdcmElValue * ElVal) {
830    SkipBytes(ElVal->GetLength());
831 }
832
833 /**
834  * \ingroup gdcmHeader
835  * \brief   
836  * @param NewSize
837  * @return 
838  */
839  void gdcmHeader::SetMaxSizeLoadElementValue(long NewSize) {
840    if (NewSize < 0)
841       return;
842    if ((guint32)NewSize >= (guint32)0xffffffff) {
843       MaxSizeLoadElementValue = 0xffffffff;
844       return;
845    }
846    MaxSizeLoadElementValue = NewSize;
847 }
848
849 /**
850  * \ingroup       gdcmHeader
851  * \brief         Loads the element content if it's length is not bigger
852  *                than the value specified with
853  *                gdcmHeader::SetMaxSizeLoadElementValue()
854  */
855 void gdcmHeader::LoadElementValue(gdcmElValue * ElVal) {
856    size_t item_read;
857    guint16 group  = ElVal->GetGroup();
858    string  vr     = ElVal->GetVR();
859    guint32 length = ElVal->GetLength();
860    bool SkipLoad  = false;
861
862    fseek(fp, (long)ElVal->GetOffset(), SEEK_SET);
863    
864    // FIXME Sequences not treated yet !
865    //
866    // Ne faudrait-il pas au contraire trouver immediatement
867    // une maniere 'propre' de traiter les sequences (vr = SQ)
868    // car commencer par les ignorer risque de conduire a qq chose
869    // qui pourrait ne pas etre generalisable
870    // Well, I'm expecting your code !!!
871     
872    if( vr == "SQ" )
873       SkipLoad = true;
874
875    // Heuristic : a sequence "contains" a set of tags (called items). It looks
876    // like the last tag of a sequence (the one that terminates the sequence)
877    // has a group of 0xfffe (with a dummy length).
878    // Well ... 
879    // Actually (fffe e000) tells us an Element is beginning
880    //          (fffe e00d) tells us an Element just ended
881    //          (fffe e0dd) tells us the current SEQuence just ended
882   
883    if( group == 0xfffe )
884       SkipLoad = true;
885
886    if ( SkipLoad ) {
887       ElVal->SetLength(0);
888       ElVal->SetValue("gdcm::Skipped");
889       return;
890    }
891
892    // When the length is zero things are easy:
893    if ( length == 0 ) {
894       ElVal->SetValue("");
895       return;
896    }
897
898    // The elements whose length is bigger than the specified upper bound
899    // are not loaded. Instead we leave a short notice of the offset of
900    // the element content and it's length.
901    if (length > MaxSizeLoadElementValue) {
902       ostringstream s;
903       s << "gdcm::NotLoaded.";
904       s << " Address:" << (long)ElVal->GetOffset();
905       s << " Length:"  << ElVal->GetLength();
906       ElVal->SetValue(s.str());
907       return;
908    }
909    
910    // When an integer is expected, read and convert the following two or
911    // four bytes properly i.e. as an integer as opposed to a string.
912         
913         // pour les elements de Value Multiplicity > 1
914         // on aura en fait une serie d'entiers  
915         // on devrait pouvoir faire + compact (?)
916                 
917    if ( IsAnInteger(ElVal) ) {
918       guint32 NewInt;
919       ostringstream s;
920       int nbInt;
921       if (vr == "US" || vr == "SS") {
922          nbInt = length / 2;
923          NewInt = ReadInt16();
924          s << NewInt;
925          if (nbInt > 1) {
926             for (int i=1; i < nbInt; i++) {
927                s << '\\';
928                NewInt = ReadInt16();
929                s << NewInt;
930             }
931          }
932                         
933       } else if (vr == "UL" || vr == "SL") {
934          nbInt = length / 4;
935          NewInt = ReadInt32();
936          s << NewInt;
937          if (nbInt > 1) {
938             for (int i=1; i < nbInt; i++) {
939                s << '\\';
940                NewInt = ReadInt32();
941                s << NewInt;
942             }
943          }
944       }                                 
945       ElVal->SetValue(s.str());
946       return;   
947    }
948    
949    // We need an additional byte for storing \0 that is not on disk
950    char* NewValue = (char*)malloc(length+1);
951    if( !NewValue) {
952       dbg.Verbose(1, "LoadElementValue: Failed to allocate NewValue");
953       return;
954    }
955    NewValue[length]= 0;
956    
957    item_read = fread(NewValue, (size_t)length, (size_t)1, fp);
958    if ( item_read != 1 ) {
959       free(NewValue);
960       dbg.Verbose(1, "gdcmHeader::LoadElementValue","unread element value");
961       ElVal->SetValue("gdcm::UnRead");
962       return;
963    }
964    ElVal->SetValue(NewValue);
965    free(NewValue);
966 }
967
968 /**
969  * \ingroup       gdcmHeader
970  * \brief         Loads the element while preserving the current
971  *                underlying file position indicator as opposed to
972  *                to LoadElementValue that modifies it.
973  * @param ElVal   Element whose value shall be loaded. 
974  * @return  
975  */
976 void gdcmHeader::LoadElementValueSafe(gdcmElValue * ElVal) {
977    long PositionOnEntry = ftell(fp);
978    LoadElementValue(ElVal);
979    fseek(fp, PositionOnEntry, SEEK_SET);
980 }
981
982 /**
983  * \ingroup gdcmHeader
984  * \brief Reads a supposed to be 16 Bits integer
985  * \     (swaps it depending on processor endianity) 
986  *
987  * @return integer acts as a boolean
988  */
989 guint16 gdcmHeader::ReadInt16(void) {
990    guint16 g;
991    size_t item_read;
992    item_read = fread (&g, (size_t)2,(size_t)1, fp);
993    if ( item_read != 1 ) {
994       // dbg.Verbose(0, "gdcmHeader::ReadInt16", " Failed to read :");
995       // if(feof(fp)) 
996       //    dbg.Verbose(0, "gdcmHeader::ReadInt16", " End of File encountered");
997       if(ferror(fp)) 
998          dbg.Verbose(0, "gdcmHeader::ReadInt16", " File Error");
999       errno = 1;
1000       return 0;
1001    }
1002    errno = 0;
1003    g = SwapShort(g);
1004    return g;
1005 }
1006
1007 /**
1008  * \ingroup gdcmHeader
1009  * \brief  Reads a supposed to be 32 Bits integer
1010  * \       (swaps it depending on processor endianity)  
1011  *
1012  * @return 
1013  */
1014 guint32 gdcmHeader::ReadInt32(void) {
1015    guint32 g;
1016    size_t item_read;
1017    item_read = fread (&g, (size_t)4,(size_t)1, fp);
1018    if ( item_read != 1 ) { 
1019       //dbg.Verbose(0, "gdcmHeader::ReadInt32", " Failed to read :");
1020       //if(feof(fp)) 
1021       //   dbg.Verbose(0, "gdcmHeader::ReadInt32", " End of File encountered");
1022      if(ferror(fp)) 
1023          dbg.Verbose(0, "gdcmHeader::ReadInt32", " File Error");   
1024       errno = 1;
1025       return 0;
1026    }
1027    errno = 0;   
1028    g = SwapLong(g);
1029    return g;
1030 }
1031
1032 /**
1033  * \ingroup gdcmHeader
1034  * \brief   
1035  *
1036  * @return 
1037  */
1038  gdcmElValue* gdcmHeader::GetElValueByNumber(guint16 Group, guint16 Elem) {
1039
1040    gdcmElValue* elValue = PubElValSet.GetElementByNumber(Group, Elem);   
1041    if (!elValue) {
1042       dbg.Verbose(1, "gdcmHeader::GetElValueByNumber",
1043                   "failed to Locate gdcmElValue");
1044       return (gdcmElValue*)0;
1045    }
1046    return elValue;
1047 }
1048
1049 /**
1050  * \ingroup gdcmHeader
1051  * \brief   Build a new Element Value from all the low level arguments. 
1052  *          Check for existence of dictionary entry, and build
1053  *          a default one when absent.
1054  * @param   Group group   of the underlying DictEntry
1055  * @param   Elem  element of the underlying DictEntry
1056  */
1057 gdcmElValue* gdcmHeader::NewElValueByNumber(guint16 Group, guint16 Elem) {
1058    // Find out if the tag we encountered is in the dictionaries:
1059    gdcmDictEntry * NewTag = GetDictEntryByNumber(Group, Elem);
1060    if (!NewTag)
1061       NewTag = new gdcmDictEntry(Group, Elem);
1062
1063    gdcmElValue* NewElVal = new gdcmElValue(NewTag);
1064    if (!NewElVal) {
1065       dbg.Verbose(1, "gdcmHeader::NewElValueByNumber",
1066                   "failed to allocate gdcmElValue");
1067       return (gdcmElValue*)0;
1068    }
1069    return NewElVal;
1070 }
1071
1072 /**
1073  * \ingroup gdcmHeader
1074  * \brief   TODO
1075  * @param   Value
1076  * @param   Group
1077  * @param   Elem
1078  * \return integer acts as a boolean
1079  */
1080 int gdcmHeader::ReplaceOrCreateByNumber(string Value, guint16 Group, guint16 Elem ) {
1081
1082         // TODO : FIXME JPRx
1083         // curieux, non ?
1084         // on (je) cree une Elvalue ne contenant pas de valeur
1085         // on l'ajoute au ElValSet
1086         // on affecte une valeur a cette ElValue a l'interieur du ElValSet
1087         // --> devrait pouvoir etre fait + simplement ???
1088         
1089    gdcmElValue* nvElValue=NewElValueByNumber(Group, Elem);
1090    PubElValSet.Add(nvElValue);  
1091    PubElValSet.SetElValueByNumber(Value, Group, Elem);
1092    return(1);
1093 }   
1094
1095
1096 /**
1097  * \ingroup gdcmHeader
1098  * \brief   Modify or (Creates if not found) an element
1099  * @param   Value new value
1100  * @param   Group
1101  * @param   Elem
1102  * \return integer acts as a boolean 
1103  * 
1104  */
1105 int gdcmHeader::ReplaceOrCreateByNumber(char* Value, guint16 Group, guint16 Elem ) {
1106
1107    gdcmElValue* nvElValue=NewElValueByNumber(Group, Elem);
1108    PubElValSet.Add(nvElValue);
1109    string v = Value;    
1110    PubElValSet.SetElValueByNumber(v, Group, Elem);
1111    return(1);
1112 }  
1113
1114
1115 /**
1116  * \ingroup gdcmHeader
1117  * \brief   Set a new value if the invoked element exists
1118  * @param   Value
1119  * @param   Group
1120  * @param   Elem
1121  * \return integer acts as a boolean 
1122  */
1123 int gdcmHeader::ReplaceIfExistByNumber(char* Value, guint16 Group, guint16 Elem ) {
1124
1125    gdcmElValue* elValue = PubElValSet.GetElementByNumber(Group, Elem);
1126    string v = Value;    
1127    PubElValSet.SetElValueByNumber(v, Group, Elem);
1128    return 1;
1129
1130
1131
1132 /**
1133  * \ingroup gdcmHeader
1134  * \brief   Checks if a given ElValue (group,number) 
1135  * \ exists in the Public ElValSet
1136  * @param   Group
1137  * @param   Elem
1138  * @return  integer acts as a boolean  
1139  */
1140  
1141 int gdcmHeader::CheckIfExistByNumber(guint16 Group, guint16 Elem ) {
1142    return (PubElValSet.CheckIfExistByNumber(Group, Elem));
1143  }
1144   
1145 /**
1146  * \ingroup gdcmHeader
1147  * \brief   Build a new Element Value from all the low level arguments. 
1148  *          Check for existence of dictionary entry, and build
1149  *          a default one when absent.
1150  * @param   Name    Name of the underlying DictEntry
1151  */
1152 gdcmElValue* gdcmHeader::NewElValueByName(string Name) {
1153
1154    gdcmDictEntry * NewTag = GetDictEntryByName(Name);
1155    if (!NewTag)
1156       NewTag = new gdcmDictEntry(0xffff, 0xffff, "LO", "Unknown", Name);
1157
1158    gdcmElValue* NewElVal = new gdcmElValue(NewTag);
1159    if (!NewElVal) {
1160       dbg.Verbose(1, "gdcmHeader::ObtainElValueByName",
1161                   "failed to allocate gdcmElValue");
1162       return (gdcmElValue*)0;
1163    }
1164    return NewElVal;
1165 }  
1166
1167 /**
1168  * \ingroup gdcmHeader
1169  * \brief   Read the next tag but WITHOUT loading it's value
1170  * @return  On succes the newly created ElValue, NULL on failure.      
1171  */
1172 gdcmElValue * gdcmHeader::ReadNextElement(void) {
1173   
1174    guint16 g,n;
1175    gdcmElValue * NewElVal;
1176    
1177    g = ReadInt16();
1178    n = ReadInt16();
1179    
1180    if ( (g==0x7fe0) && (n==0x0010) ) 
1181         if (DEBUG) 
1182            printf("in gdcmHeader::ReadNextElement try to read 7fe0 0010 \n");
1183    
1184    if (errno == 1)
1185       // We reached the EOF (or an error occured) and header parsing
1186       // has to be considered as finished.
1187       return (gdcmElValue *)0;
1188    
1189    NewElVal = NewElValueByNumber(g, n);
1190    FindVR(NewElVal);
1191    FindLength(NewElVal);
1192    if (errno == 1) {
1193       // Call it quits
1194       if (DEBUG) printf("in gdcmHeader::ReadNextElement : g %04x n %04x errno %d\n",g, n, errno);
1195       return (gdcmElValue *)0;
1196    }
1197    NewElVal->SetOffset(ftell(fp));  
1198    if ( (g==0x7fe0) && (n==0x0010) ) 
1199       if (DEBUG) 
1200          printf("sortie de gdcmHeader::ReadNextElement 7fe0 0010 \n");
1201    return NewElVal;
1202 }
1203
1204 /**
1205  * \ingroup gdcmHeader
1206  * \brief   Apply some heuristics to predict wether the considered 
1207  *          element value contains/represents an integer or not.
1208  * @param   ElVal The element value on which to apply the predicate.
1209  * @return  The result of the heuristical predicate.
1210  */
1211 bool gdcmHeader::IsAnInteger(gdcmElValue * ElVal) {
1212    guint16 group   = ElVal->GetGroup();
1213    guint16 element = ElVal->GetElement();
1214    string  vr      = ElVal->GetVR();
1215    guint32 length  = ElVal->GetLength();
1216
1217    // When we have some semantics on the element we just read, and if we
1218    // a priori know we are dealing with an integer, then we shall be
1219    // able to swap it's element value properly.
1220    if ( element == 0 )  {  // This is the group length of the group
1221       if (length == 4)
1222          return true;
1223       else {
1224          if (DEBUG) printf("Erroneous Group Length element length (%04x , %04x) : %d\n",
1225             group, element,length);
1226                     
1227          dbg.Error("gdcmHeader::IsAnInteger",
1228             "Erroneous Group Length element length.");     
1229       }
1230    }
1231    if ( (vr == "UL") || (vr == "US") || (vr == "SL") || (vr == "SS") )
1232       return true;
1233    
1234    return false;
1235 }
1236
1237 /**
1238  * \ingroup gdcmHeader
1239  * \brief   Recover the offset (from the beginning of the file) of the pixels.
1240  */
1241 size_t gdcmHeader::GetPixelOffset(void) {
1242    // If this file complies with the norm we should encounter the
1243    // "Image Location" tag (0x0028,  0x0200). This tag contains the
1244    // the group that contains the pixel data (hence the "Pixel Data"
1245    // is found by indirection through the "Image Location").
1246    // Inside the group pointed by "Image Location" the searched element
1247    // is conventionally the element 0x0010 (when the norm is respected).
1248    // When the "Image Location" is absent we default to group 0x7fe0.
1249    guint16 grPixel;
1250    guint16 numPixel;
1251    string ImageLocation = GetPubElValByName("Image Location");
1252    if ( ImageLocation == "gdcm::Unfound" ) {
1253       grPixel = 0x7fe0;
1254    } else {
1255       grPixel = (guint16) atoi( ImageLocation.c_str() );
1256    }
1257    if (grPixel != 0x7fe0)
1258       // This is a kludge for old dirty Philips imager.
1259       numPixel = 0x1010;
1260    else
1261       numPixel = 0x0010;
1262          
1263    gdcmElValue* PixelElement = PubElValSet.GetElementByNumber(grPixel,
1264                                                               numPixel);
1265    if (PixelElement)
1266       return PixelElement->GetOffset();
1267    else
1268       return 0;
1269 }
1270
1271 /**
1272  * \ingroup gdcmHeader
1273  * \brief   Searches both the public and the shadow dictionary (when they
1274  *          exist) for the presence of the DictEntry with given
1275  *          group and element. The public dictionary has precedence on the
1276  *          shadow one.
1277  * @param   group   group of the searched DictEntry
1278  * @param   element element of the searched DictEntry
1279  * @return  Corresponding DictEntry when it exists, NULL otherwise.
1280  */
1281 gdcmDictEntry * gdcmHeader::GetDictEntryByNumber(guint16 group,
1282                                                  guint16 element) {
1283    gdcmDictEntry * found = (gdcmDictEntry*)0;
1284    if (!RefPubDict && !RefShaDict) {
1285       dbg.Verbose(0, "gdcmHeader::GetDictEntry",
1286                      "we SHOULD have a default dictionary");
1287    }
1288    if (RefPubDict) {
1289       found = RefPubDict->GetTagByNumber(group, element);
1290       if (found)
1291          return found;
1292    }
1293    if (RefShaDict) {
1294       found = RefShaDict->GetTagByNumber(group, element);
1295       if (found)
1296          return found;
1297    }
1298    return found;
1299 }
1300
1301 /**
1302  * \ingroup gdcmHeader
1303  * \brief   Searches both the public and the shadow dictionary (when they
1304  *          exist) for the presence of the DictEntry with given name.
1305  *          The public dictionary has precedence on the shadow one.
1306  * @param   Name name of the searched DictEntry
1307  * @return  Corresponding DictEntry when it exists, NULL otherwise.
1308  */
1309 gdcmDictEntry * gdcmHeader::GetDictEntryByName(string Name) {
1310    gdcmDictEntry * found = (gdcmDictEntry*)0;
1311    if (!RefPubDict && !RefShaDict) {
1312       dbg.Verbose(0, "gdcmHeader::GetDictEntry",
1313                      "we SHOULD have a default dictionary");
1314    }
1315    if (RefPubDict) {
1316       found = RefPubDict->GetTagByName(Name);
1317       if (found)
1318          return found;
1319    }
1320    if (RefShaDict) {
1321       found = RefShaDict->GetTagByName(Name);
1322       if (found)
1323          return found;
1324    }
1325    return found;
1326 }
1327
1328 /**
1329  * \ingroup gdcmHeader
1330  * \brief   Searches within the public dictionary for element value of
1331  *          a given tag.
1332  * @param   group Group of the researched tag.
1333  * @param   element Element of the researched tag.
1334  * @return  Corresponding element value when it exists, and the string
1335  *          "gdcm::Unfound" otherwise.
1336  */
1337 string gdcmHeader::GetPubElValByNumber(guint16 group, guint16 element) {
1338    return PubElValSet.GetElValueByNumber(group, element);
1339 }
1340
1341 /**
1342  * \ingroup gdcmHeader
1343  * \brief   Searches within the public dictionary for element value
1344  *          representation of a given tag.
1345  *
1346  *          Obtaining the VR (Value Representation) might be needed by caller
1347  *          to convert the string typed content to caller's native type 
1348  *          (think of C++ vs Python). The VR is actually of a higher level
1349  *          of semantics than just the native C++ type.
1350  * @param   group Group of the researched tag.
1351  * @param   element Element of the researched tag.
1352  * @return  Corresponding element value representation when it exists,
1353  *          and the string "gdcm::Unfound" otherwise.
1354  */
1355 string gdcmHeader::GetPubElValRepByNumber(guint16 group, guint16 element) {
1356    gdcmElValue* elem =  PubElValSet.GetElementByNumber(group, element);
1357    if ( !elem )
1358       return "gdcm::Unfound";
1359    return elem->GetVR();
1360 }
1361
1362 /**
1363  * \ingroup gdcmHeader
1364  * \brief   Searches within the public dictionary for element value of
1365  *          a given tag.
1366  * @param   TagName name of the researched element.
1367  * @return  Corresponding element value when it exists, and the string
1368  *          "gdcm::Unfound" otherwise.
1369  */
1370 string gdcmHeader::GetPubElValByName(string TagName) {
1371    return PubElValSet.GetElValueByName(TagName);
1372 }
1373
1374 /**
1375  * \ingroup gdcmHeader
1376  * \brief   Searches within the elements parsed with the public dictionary for
1377  *          the element value representation of a given tag.
1378  *
1379  *          Obtaining the VR (Value Representation) might be needed by caller
1380  *          to convert the string typed content to caller's native type 
1381  *          (think of C++ vs Python). The VR is actually of a higher level
1382  *          of semantics than just the native C++ type.
1383  * @param   TagName name of the researched element.
1384  * @return  Corresponding element value representation when it exists,
1385  *          and the string "gdcm::Unfound" otherwise.
1386  */
1387 string gdcmHeader::GetPubElValRepByName(string TagName) {
1388    gdcmElValue* elem =  PubElValSet.GetElementByName(TagName);
1389    if ( !elem )
1390       return "gdcm::Unfound";
1391    return elem->GetVR();
1392 }
1393
1394 /**
1395  * \ingroup gdcmHeader
1396  * \brief   Searches within elements parsed with the SHADOW dictionary 
1397  *          for the element value of a given tag.
1398  * @param   group Group of the researched tag.
1399  * @param   element Element of the researched tag.
1400  * @return  Corresponding element value representation when it exists,
1401  *          and the string "gdcm::Unfound" otherwise.
1402  */
1403 string gdcmHeader::GetShaElValByNumber(guint16 group, guint16 element) {
1404    return ShaElValSet.GetElValueByNumber(group, element);
1405 }
1406
1407 /**
1408  * \ingroup gdcmHeader
1409  * \brief   Searches within the elements parsed with the SHADOW dictionary
1410  *          for the element value representation of a given tag.
1411  *
1412  *          Obtaining the VR (Value Representation) might be needed by caller
1413  *          to convert the string typed content to caller's native type 
1414  *          (think of C++ vs Python). The VR is actually of a higher level
1415  *          of semantics than just the native C++ type.
1416  * @param   group Group of the researched tag.
1417  * @param   element Element of the researched tag.
1418  * @return  Corresponding element value representation when it exists,
1419  *          and the string "gdcm::Unfound" otherwise.
1420  */
1421 string gdcmHeader::GetShaElValRepByNumber(guint16 group, guint16 element) {
1422    gdcmElValue* elem =  ShaElValSet.GetElementByNumber(group, element);
1423    if ( !elem )
1424       return "gdcm::Unfound";
1425    return elem->GetVR();
1426 }
1427
1428 /**
1429  * \ingroup gdcmHeader
1430  * \brief   Searches within the elements parsed with the shadow dictionary
1431  *          for an element value of given tag.
1432  * @param   TagName name of the researched element.
1433  * @return  Corresponding element value when it exists, and the string
1434  *          "gdcm::Unfound" otherwise.
1435  */
1436 string gdcmHeader::GetShaElValByName(string TagName) {
1437    return ShaElValSet.GetElValueByName(TagName);
1438 }
1439
1440 /**
1441  * \ingroup gdcmHeader
1442  * \brief   Searches within the elements parsed with the shadow dictionary for
1443  *          the element value representation of a given tag.
1444  *
1445  *          Obtaining the VR (Value Representation) might be needed by caller
1446  *          to convert the string typed content to caller's native type 
1447  *          (think of C++ vs Python). The VR is actually of a higher level
1448  *          of semantics than just the native C++ type.
1449  * @param   TagName name of the researched element.
1450  * @return  Corresponding element value representation when it exists,
1451  *          and the string "gdcm::Unfound" otherwise.
1452  */
1453 string gdcmHeader::GetShaElValRepByName(string TagName) {
1454    gdcmElValue* elem =  ShaElValSet.GetElementByName(TagName);
1455    if ( !elem )
1456       return "gdcm::Unfound";
1457    return elem->GetVR();
1458 }
1459
1460 /**
1461  * \ingroup gdcmHeader
1462  * \brief   Searches within elements parsed with the public dictionary 
1463  *          and then within the elements parsed with the shadow dictionary
1464  *          for the element value of a given tag.
1465  * @param   group Group of the researched tag.
1466  * @param   element Element of the researched tag.
1467  * @return  Corresponding element value representation when it exists,
1468  *          and the string "gdcm::Unfound" otherwise.
1469  */
1470 string gdcmHeader::GetElValByNumber(guint16 group, guint16 element) {
1471    string pub = GetPubElValByNumber(group, element);
1472    if (pub.length())
1473       return pub;
1474    return GetShaElValByNumber(group, element);
1475 }
1476
1477 /**
1478  * \ingroup gdcmHeader
1479  * \brief   Searches within elements parsed with the public dictionary 
1480  *          and then within the elements parsed with the shadow dictionary
1481  *          for the element value representation of a given tag.
1482  *
1483  *          Obtaining the VR (Value Representation) might be needed by caller
1484  *          to convert the string typed content to caller's native type 
1485  *          (think of C++ vs Python). The VR is actually of a higher level
1486  *          of semantics than just the native C++ type.
1487  * @param   group Group of the researched tag.
1488  * @param   element Element of the researched tag.
1489  * @return  Corresponding element value representation when it exists,
1490  *          and the string "gdcm::Unfound" otherwise.
1491  */
1492 string gdcmHeader::GetElValRepByNumber(guint16 group, guint16 element) {
1493    string pub = GetPubElValRepByNumber(group, element);
1494    if (pub.length())
1495       return pub;
1496    return GetShaElValRepByNumber(group, element);
1497 }
1498
1499 /**
1500  * \ingroup gdcmHeader
1501  * \brief   Searches within elements parsed with the public dictionary 
1502  *          and then within the elements parsed with the shadow dictionary
1503  *          for the element value of a given tag.
1504  * @param   TagName name of the researched element.
1505  * @return  Corresponding element value when it exists,
1506  *          and the string "gdcm::Unfound" otherwise.
1507  */
1508 string gdcmHeader::GetElValByName(string TagName) {
1509    string pub = GetPubElValByName(TagName);
1510    if (pub.length())
1511       return pub;
1512    return GetShaElValByName(TagName);
1513 }
1514
1515 /**
1516  * \ingroup gdcmHeader
1517  * \brief   Searches within elements parsed with the public dictionary 
1518  *          and then within the elements parsed with the shadow dictionary
1519  *          for the element value representation of a given tag.
1520  *
1521  *          Obtaining the VR (Value Representation) might be needed by caller
1522  *          to convert the string typed content to caller's native type 
1523  *          (think of C++ vs Python). The VR is actually of a higher level
1524  *          of semantics than just the native C++ type.
1525  * @param   TagName name of the researched element.
1526  * @return  Corresponding element value representation when it exists,
1527  *          and the string "gdcm::Unfound" otherwise.
1528  */
1529 string gdcmHeader::GetElValRepByName(string TagName) {
1530    string pub = GetPubElValRepByName(TagName);
1531    if (pub.length())
1532       return pub;
1533    return GetShaElValRepByName(TagName);
1534 }
1535
1536 /**
1537  * \ingroup gdcmHeader
1538  * \brief   Accesses an existing gdcmElValue in the PubElValSet of this instance
1539  *          through it's (group, element) and modifies it's content with
1540  *          the given value.
1541  * @param   content new value to substitute with
1542  * @param   group   group of the ElVal to modify
1543  * @param   element element of the ElVal to modify
1544  */
1545 int gdcmHeader::SetPubElValByNumber(string content, guint16 group,
1546                                     guint16 element)
1547                                     
1548 //TODO  : homogeneiser les noms : SetPubElValByNumber   qui appelle PubElValSet.SetElValueByNumber 
1549 //        pourquoi pas            SetPubElValueByNumber ??
1550 {
1551
1552    return (  PubElValSet.SetElValueByNumber (content, group, element) );
1553 }
1554
1555 /**
1556  * \ingroup gdcmHeader
1557  * \brief   Accesses an existing gdcmElValue in the PubElValSet of this instance
1558  *          through tag name and modifies it's content with the given value.
1559  * @param   content new value to substitute with
1560  * @param   TagName name of the tag to be modified
1561  */
1562 int gdcmHeader::SetPubElValByName(string content, string TagName) {
1563    return (  PubElValSet.SetElValueByName (content, TagName) );
1564 }
1565
1566 /**
1567  * \ingroup gdcmHeader
1568  * \brief   Accesses an existing gdcmElValue in the PubElValSet of this instance
1569  *          through it's (group, element) and modifies it's length with
1570  *          the given value.
1571  * \warning Use with extreme caution.
1572  * @param   length new length to substitute with
1573  * @param   group   group of the ElVal to modify
1574  * @param   element element of the ElVal to modify
1575  * @return  1 on success, 0 otherwise.
1576  */
1577
1578 int gdcmHeader::SetPubElValLengthByNumber(guint32 length, guint16 group,
1579                                     guint16 element) {
1580         return (  PubElValSet.SetElValueLengthByNumber (length, group, element) );
1581 }
1582
1583 /**
1584  * \ingroup gdcmHeader
1585  * \brief   Accesses an existing gdcmElValue in the ShaElValSet of this instance
1586  *          through it's (group, element) and modifies it's content with
1587  *          the given value.
1588  * @param   content new value to substitute with
1589  * @param   group   group of the ElVal to modify
1590  * @param   element element of the ElVal to modify
1591  * @return  1 on success, 0 otherwise.
1592  */
1593 int gdcmHeader::SetShaElValByNumber(string content,
1594                                     guint16 group, guint16 element) {
1595    return (  ShaElValSet.SetElValueByNumber (content, group, element) );
1596 }
1597
1598 /**
1599  * \ingroup gdcmHeader
1600  * \brief   Accesses an existing gdcmElValue in the ShaElValSet of this instance
1601  *          through tag name and modifies it's content with the given value.
1602  * @param   content new value to substitute with
1603  * @param   ShadowTagName name of the tag to be modified
1604  */
1605 int gdcmHeader::SetShaElValByName(string content, string ShadowTagName) {
1606    return (  ShaElValSet.SetElValueByName (content, ShadowTagName) );
1607 }
1608
1609 /**
1610  * \ingroup gdcmHeader
1611  * \brief   Parses the header of the file but WITHOUT loading element values.
1612  */
1613 void gdcmHeader::ParseHeader(bool exception_on_error) throw(gdcmFormatError) {
1614    gdcmElValue * newElValue = (gdcmElValue *)0;
1615    
1616    rewind(fp);
1617    CheckSwap();
1618    while ( (newElValue = ReadNextElement()) ) {
1619       SkipElementValue(newElValue);
1620       PubElValSet.Add(newElValue);
1621    }
1622 }
1623
1624 /**
1625  * \ingroup gdcmHeader
1626  * \brief  This predicate, based on hopefully reasonnable heuristics,
1627  *         decides whether or not the current gdcmHeader was properly parsed
1628  *         and contains the mandatory information for being considered as
1629  *         a well formed and usable image.
1630  * @return true when gdcmHeader is the one of a reasonable Dicom file,
1631  *         false otherwise. 
1632  */
1633 bool gdcmHeader::IsReadable(void) {
1634    if (   GetElValByName("Image Dimensions") != "gdcm::Unfound"
1635       && atoi(GetElValByName("Image Dimensions").c_str()) > 4 ) {
1636       return false;
1637    }
1638    if ( GetElValByName("Bits Allocated")       == "gdcm::Unfound" )
1639       return false;
1640    if ( GetElValByName("Bits Stored")          == "gdcm::Unfound" )
1641       return false;
1642    if ( GetElValByName("High Bit")             == "gdcm::Unfound" )
1643       return false;
1644    if ( GetElValByName("Pixel Representation") == "gdcm::Unfound" )
1645       return false;
1646    return true;
1647 }
1648
1649 /**
1650  * \ingroup gdcmHeader
1651  * \brief   Small utility function that creates a new manually crafted
1652  *          (as opposed as read from the file) gdcmElValue with user
1653  *          specified name and adds it to the public tag hash table.
1654  * \note    A fake TagKey is generated so the PubDict can keep it's coherence.
1655  * @param   NewTagName The name to be given to this new tag.
1656  * @param   VR The Value Representation to be given to this new tag.
1657  * @ return The newly hand crafted Element Value.
1658  */
1659 gdcmElValue* gdcmHeader::NewManualElValToPubDict(string NewTagName, string VR) {
1660    gdcmElValue* NewElVal = (gdcmElValue*)0;
1661    guint32 StuffGroup = 0xffff;   // Group to be stuffed with additional info
1662    guint32 FreeElem = 0;
1663    gdcmDictEntry* NewEntry = (gdcmDictEntry*)0;
1664
1665    FreeElem = PubElValSet.GenerateFreeTagKeyInGroup(StuffGroup);
1666    if (FreeElem == UINT32_MAX) {
1667       dbg.Verbose(1, "gdcmHeader::NewManualElValToPubDict",
1668                      "Group 0xffff in Public Dict is full");
1669       return (gdcmElValue*)0;
1670    }
1671    NewEntry = new gdcmDictEntry(StuffGroup, FreeElem,
1672                                 VR, "GDCM", NewTagName);
1673    NewElVal = new gdcmElValue(NewEntry);
1674    PubElValSet.Add(NewElVal);
1675    return NewElVal;
1676 }
1677
1678 /**
1679  * \ingroup gdcmHeader
1680  * \brief   Loads the element values of all the elements present in the
1681  *          public tag based hash table.
1682  */
1683 void gdcmHeader::LoadElements(void) {
1684    rewind(fp);   
1685    TagElValueHT ht = PubElValSet.GetTagHt();
1686    for (TagElValueHT::iterator tag = ht.begin(); tag != ht.end(); ++tag) {
1687       LoadElementValue(tag->second);
1688    }
1689    // Load 'non string' values
1690    rewind(fp);    
1691    string PhotometricInterpretation = GetPubElValByNumber(0x0028,0x0004);   
1692    if( PhotometricInterpretation == "PALETTE COLOR " ){ 
1693       LoadElementVoidArea(0x0028,0x1200);  // gray LUT   
1694       LoadElementVoidArea(0x0028,0x1201);  // R    LUT
1695       LoadElementVoidArea(0x0028,0x1202);  // G    LUT
1696       LoadElementVoidArea(0x0028,0x1203);  // B    LUT
1697       
1698       LoadElementVoidArea(0x0028,0x1221);  // Segmented Red   Palette Color LUT Data
1699       LoadElementVoidArea(0x0028,0x1222);  // Segmented Green Palette Color LUT Data
1700       LoadElementVoidArea(0x0028,0x1223);  // Segmented Blue  Palette Color LUT Data
1701    }
1702 }
1703
1704 /**
1705   * \ingroup gdcmHeader
1706   * \brief
1707   * @return
1708   */ 
1709 void gdcmHeader::PrintPubElVal(std::ostream & os) {
1710    PubElValSet.Print(os);
1711 }
1712
1713 /**
1714   * \ingroup gdcmHeader
1715   * \brief
1716   * @return
1717   */  
1718 void gdcmHeader::PrintPubDict(std::ostream & os) {
1719    RefPubDict->Print(os);
1720 }
1721
1722 /**
1723   * \ingroup gdcmHeader
1724   * \brief
1725   * @return
1726   */ 
1727 int gdcmHeader::Write(FILE * fp, FileType type) {
1728    return PubElValSet.Write(fp, type);
1729 }
1730
1731 //
1732 // ------------------------ 'non string' elements related functions
1733 //
1734
1735 /**
1736  * \ingroup       gdcmHeader
1737  * \brief         Loads (from disk) the element content 
1738  *                when a string is not suitable
1739  */
1740 void * gdcmHeader::LoadElementVoidArea(guint16 Group, guint16 Elem) {
1741    gdcmElValue * Element= PubElValSet.GetElementByNumber(Group, Elem);
1742    if ( !Element )
1743       return NULL;
1744    size_t o =(size_t)Element->GetOffset();
1745    fseek(fp, o, SEEK_SET);
1746    int l=Element->GetLength();
1747    void * a = malloc(l);
1748    if(!a) {
1749         cout << "Big Broblem (LoadElementVoidArea, malloc) " 
1750              << hex << Group << " " << Elem << "\n";
1751         return NULL;
1752    }  
1753    int res = PubElValSet.SetVoidAreaByNumber(a, Group, Elem);
1754    // TODO check the result 
1755    size_t l2 = fread(a, 1, l ,fp);
1756    if(l != l2) {
1757         cout << "Big Broblem (LoadElementVoidArea, fread) " 
1758              << hex << Group << " " << Elem << "\n";
1759         free(a);
1760         return NULL;
1761    }  
1762 }
1763
1764 /**
1765  * \ingroup gdcmHeader
1766  * \brief   Gets (from Header) the offset  of a 'non string' element value 
1767  * \        (LoadElementValue has already be executed)
1768  * @param   Group
1769  * @param   Elem
1770  * @return File Offset of the Element Value 
1771  */
1772  size_t gdcmHeader::GetPubElValOffsetByNumber(guint16 Group, guint16 Elem) {
1773    gdcmElValue* elValue = PubElValSet.GetElementByNumber(Group, Elem);   
1774    if (!elValue) {
1775       dbg.Verbose(1, "gdcmHeader::GetElValueByNumber",
1776                   "failed to Locate gdcmElValue");
1777       return (size_t)0;
1778    }
1779    return elValue->GetOffset();
1780 }
1781
1782 /**
1783  * \ingroup gdcmHeader
1784 * \brief   Gets (from Header) a 'non string' element value 
1785  * \        (LoadElementValue has already be executed)  
1786  * @param   Group
1787  * @param   Elem
1788  * @return Pointer to the 'non string' area
1789  
1790  */
1791  void * gdcmHeader::GetPubElValVoidAreaByNumber(guint16 Group, guint16 Elem) {
1792    gdcmElValue* elValue = PubElValSet.GetElementByNumber(Group, Elem);   
1793    if (!elValue) {
1794       dbg.Verbose(1, "gdcmHeader::GetElValueByNumber",
1795                   "failed to Locate gdcmElValue");
1796       return (NULL);
1797    }
1798    return elValue->GetVoidArea();
1799 }
1800
1801
1802 //
1803 // =============================================================================
1804 //   Heuristics based accessors
1805 //==============================================================================
1806 //
1807
1808 // TODO : move to an other file.
1809
1810
1811 /**
1812  * \ingroup gdcmHeader
1813  * \brief   Retrieve the number of columns of image.
1814  * @return  The encountered size when found, 0 by default.
1815  */
1816 int gdcmHeader::GetXSize(void) {
1817    // We cannot check for "Columns" because the "Columns" tag is present
1818    // both in IMG (0028,0011) and OLY (6000,0011) sections of the dictionary.
1819    string StrSize = GetPubElValByNumber(0x0028,0x0011);
1820    if (StrSize == "gdcm::Unfound")
1821       return 0;
1822    return atoi(StrSize.c_str());
1823 }
1824
1825 /**
1826  * \ingroup gdcmHeader
1827  * \brief   Retrieve the number of lines of image.
1828  * \warning The defaulted value is 1 as opposed to gdcmHeader::GetXSize()
1829  * @return  The encountered size when found, 1 by default.
1830  */
1831 int gdcmHeader::GetYSize(void) {
1832    // We cannot check for "Rows" because the "Rows" tag is present
1833    // both in IMG (0028,0010) and OLY (6000,0010) sections of the dictionary.
1834    string StrSize = GetPubElValByNumber(0x0028,0x0010);
1835    if (StrSize != "gdcm::Unfound")
1836       return atoi(StrSize.c_str());
1837    if ( IsDicomV3() )
1838       return 0;
1839    else
1840       // The Rows (0028,0010) entry is optional for ACR/NEMA. It might
1841       // hence be a signal (1d image). So we default to 1:
1842       return 1;
1843 }
1844
1845 /**
1846  * \ingroup gdcmHeader
1847  * \brief   Retrieve the number of planes of volume or the number
1848  *          of frames of a multiframe.
1849  * \warning When present we consider the "Number of Frames" as the third
1850  *          dimension. When absent we consider the third dimension as
1851  *          being the "Planes" tag content.
1852  * @return  The encountered size when found, 1 by default.
1853  */
1854 int gdcmHeader::GetZSize(void) {
1855    // Both in DicomV3 and ACR/Nema the consider the "Number of Frames"
1856    // as the third dimension.
1857    string StrSize = GetPubElValByNumber(0x0028,0x0008);
1858    if (StrSize != "gdcm::Unfound")
1859       return atoi(StrSize.c_str());
1860
1861    // We then consider the "Planes" entry as the third dimension [we
1862    // cannot retrieve by name since "Planes tag is present both in
1863    // IMG (0028,0012) and OLY (6000,0012) sections of the dictionary]. 
1864    StrSize = GetPubElValByNumber(0x0028,0x0012);
1865    if (StrSize != "gdcm::Unfound")
1866       return atoi(StrSize.c_str());
1867    return 1;
1868 }
1869
1870 /**
1871  * \ingroup gdcmHeader
1872  * \brief   Retrieve the number of Bits Stored
1873  *          (as opposite to number of Bits Allocated)
1874  * 
1875  * @return  The encountered number of Bits Stored, 0 by default.
1876  */
1877 int gdcmHeader::GetBitsStored(void) { 
1878    string StrSize = GetPubElValByNumber(0x0028,0x0101);
1879    if (StrSize == "gdcm::Unfound")
1880       return 1;
1881    return atoi(StrSize.c_str());
1882 }
1883
1884
1885 /**
1886  * \ingroup gdcmHeader
1887  * \brief   Retrieve the number of Samples Per Pixel
1888  *          (1 : gray level, 3 : RGB)
1889  * 
1890  * @return  The encountered number of Samples Per Pixel, 1 by default.
1891  */
1892 int gdcmHeader::GetSamplesPerPixel(void) { 
1893    string StrSize = GetPubElValByNumber(0x0028,0x0002);
1894    if (StrSize == "gdcm::Unfound")
1895       return 1; // Well, it's supposed to be mandatory ...
1896    return atoi(StrSize.c_str());
1897 }
1898
1899 /**
1900  * \ingroup gdcmHeader
1901  * \brief   Retrieve the Planar Configuration for RGB images
1902  *          (0 : RGB Pixels , 1 : R Plane + G Plane + B Plane)
1903  * 
1904  * @return  The encountered Planar Configuration, 0 by default.
1905  */
1906 int gdcmHeader::GetPlanarConfiguration(void) { 
1907    string StrSize = GetPubElValByNumber(0x0028,0x0006);
1908    if (StrSize == "gdcm::Unfound")
1909       return 0;
1910    return atoi(StrSize.c_str());
1911 }
1912
1913 /**
1914  * \ingroup gdcmHeader
1915  * \brief   Return the size (in bytes) of a single pixel of data.
1916  * @return  The size in bytes of a single pixel of data.
1917  *
1918  */
1919 int gdcmHeader::GetPixelSize(void) {
1920    string PixelType = GetPixelType();
1921    if (PixelType == "8U"  || PixelType == "8S")
1922       return 1;
1923    if (PixelType == "16U" || PixelType == "16S")
1924       return 2;
1925    if (PixelType == "32U" || PixelType == "32S")
1926       return 4;
1927    dbg.Verbose(0, "gdcmHeader::GetPixelSize: Unknown pixel type");
1928    return 0;
1929 }
1930
1931 /**
1932  * \ingroup gdcmHeader
1933  * \brief   Build the Pixel Type of the image.
1934  *          Possible values are:
1935  *          - 8U  unsigned  8 bit,
1936  *          - 8S    signed  8 bit,
1937  *          - 16U unsigned 16 bit,
1938  *          - 16S   signed 16 bit,
1939  *          - 32U unsigned 32 bit,
1940  *          - 32S   signed 32 bit,
1941  * \warning 12 bit images appear as 16 bit.
1942  * @return  
1943  */
1944 string gdcmHeader::GetPixelType(void) {
1945    string BitsAlloc;
1946    BitsAlloc = GetElValByName("Bits Allocated");
1947    if (BitsAlloc == "gdcm::Unfound") {
1948       dbg.Verbose(0, "gdcmHeader::GetPixelType: unfound Bits Allocated");
1949       BitsAlloc = string("16");
1950    }
1951    if (BitsAlloc == "12")
1952       BitsAlloc = string("16");
1953
1954    string Signed;
1955    Signed = GetElValByName("Pixel Representation");
1956    if (Signed == "gdcm::Unfound") {
1957       dbg.Verbose(0, "gdcmHeader::GetPixelType: unfound Pixel Representation");
1958       BitsAlloc = string("0");
1959    }
1960    if (Signed == "0")
1961       Signed = string("U");
1962    else
1963       Signed = string("S");
1964
1965    return( BitsAlloc + Signed);
1966 }
1967
1968 /**
1969   * \ingroup gdcmHeader
1970   * \brief gets the info from 0028,0030 : Pixel Spacing
1971   * \           else 1.
1972   * @return X dimension of a pixel
1973   */
1974 float gdcmHeader::GetXSpacing(void) {
1975     float xspacing, yspacing;
1976     string StrSpacing = GetPubElValByNumber(0x0028,0x0030);
1977
1978     if (StrSpacing == "gdcm::Unfound") {
1979        dbg.Verbose(0, "gdcmHeader::GetXSpacing: unfound Pixel Spacing (0028,0030)");
1980        return 1.;
1981      }
1982    if( sscanf( StrSpacing.c_str(), "%f\\%f", &xspacing, &yspacing) != 2)
1983      return 0.;
1984    //else
1985    return xspacing;
1986 }
1987
1988 /**
1989   * \ingroup gdcmHeader
1990   * \brief gets the info from 0028,0030 : Pixel Spacing
1991   * \           else 1.
1992   * @return Y dimension of a pixel
1993   */
1994 float gdcmHeader::GetYSpacing(void) {
1995    float xspacing, yspacing;
1996    string StrSpacing = GetPubElValByNumber(0x0028,0x0030);
1997   
1998    if (StrSpacing == "gdcm::Unfound") {
1999       dbg.Verbose(0, "gdcmHeader::GetYSpacing: unfound Pixel Spacing (0028,0030)");
2000       return 1.;
2001     }
2002   if( sscanf( StrSpacing.c_str(), "%f\\%f", &xspacing, &yspacing) != 2)
2003     return 0.;
2004   if (yspacing == 0.) {
2005     dbg.Verbose(0, "gdcmHeader::GetYSpacing: gdcmData/CT-MONO2-8-abdo.dcm problem");
2006     // seems to be a bug in the header ...
2007     sscanf( StrSpacing.c_str(), "%f\\0\\%f", &xspacing, &yspacing);
2008   }
2009   return yspacing;
2010
2011
2012
2013 /**
2014   *\ingroup gdcmHeader
2015   *\brief gets the info from 0018,0088 : Space Between Slices
2016   *\               else from 0018,0050 : Slice Thickness
2017   *\               else 1.
2018   * @return Z dimension of a voxel-to be
2019   */
2020 float gdcmHeader::GetZSpacing(void) {
2021    // TODO : translate into English
2022    // Spacing Between Slices : distance entre le milieu de chaque coupe
2023    // Les coupes peuvent etre :
2024    //   jointives     (Spacing between Slices = Slice Thickness)
2025    //   chevauchantes (Spacing between Slices < Slice Thickness)
2026    //   disjointes    (Spacing between Slices > Slice Thickness)
2027    // Slice Thickness : epaisseur de tissus sur laquelle est acquis le signal
2028    //   ca interesse le physicien de l'IRM, pas le visualisateur de volumes ...
2029    //   Si le Spacing Between Slices est absent, 
2030    //   on suppose que les coupes sont jointives
2031    
2032    string StrSpacingBSlices = GetPubElValByNumber(0x0018,0x0088);
2033
2034    if (StrSpacingBSlices == "gdcm::Unfound") {
2035       dbg.Verbose(0, "gdcmHeader::GetZSpacing: unfound StrSpacingBSlices");
2036       string StrSliceThickness = GetPubElValByNumber(0x0018,0x0050);       
2037       if (StrSliceThickness == "gdcm::Unfound")
2038          return 1.;
2039       else
2040          // if no 'Spacing Between Slices' is found, 
2041          // we assume slices join together
2042          // (no overlapping, no interslice gap)
2043          // if they don't, we're fucked up
2044          return atof(StrSliceThickness.c_str());  
2045    } else {
2046       return atof(StrSpacingBSlices.c_str());
2047    }
2048 }
2049
2050 //
2051 // Image Position Patient                              (0020,0032):
2052 // If not found (ACR_NEMA) we try Image Position       (0020,0030)
2053 // If not found (ACR-NEMA), we consider Slice Location (0020,1041)
2054 //                                   or Location       (0020,0050) 
2055 // as the Z coordinate, 
2056 // 0. for all the coordinates if nothing is found
2057
2058 // TODO : find a way to inform the caller nothing was found
2059 // TODO : How to tell the caller a wrong number of values was found?
2060
2061 /**
2062   * \ingroup gdcmHeader
2063   * \brief gets the info from 0020,0032 : Image Position Patient
2064   *\                else from 0020,0030 : Image Position (RET)
2065   *\                else 0.
2066   * @return up-left image corner position
2067   */
2068 float gdcmHeader::GetXImagePosition(void) {
2069     float xImPos, yImPos, zImPos;  
2070     string StrImPos = GetPubElValByNumber(0x0020,0x0032);
2071
2072     if (StrImPos == "gdcm::Unfound") {
2073        dbg.Verbose(0, "gdcmHeader::GetXImagePosition: unfound Image Position Patient (0020,0032)");
2074        StrImPos = GetPubElValByNumber(0x0020,0x0030); // For ACR-NEMA images
2075        if (StrImPos == "gdcm::Unfound") {
2076           dbg.Verbose(0, "gdcmHeader::GetXImagePosition: unfound Image Position (RET) (0020,0030)");
2077           // How to tell the caller nothing was found ?
2078           return 0.;
2079        }  
2080      }
2081    if( sscanf( StrImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3)
2082      return 0.;
2083    return xImPos;
2084 }
2085
2086 /**
2087   * \ingroup gdcmHeader
2088   * \brief gets the info from 0020,0032 : Image Position Patient
2089   * \               else from 0020,0030 : Image Position (RET)
2090   * \               else 0.
2091   * @return up-left image corner position
2092   */
2093 float gdcmHeader::GetYImagePosition(void) {
2094     float xImPos, yImPos, zImPos;
2095     string StrImPos = GetPubElValByNumber(0x0020,0x0032);
2096
2097     if (StrImPos == "gdcm::Unfound") {
2098        dbg.Verbose(0, "gdcmHeader::GetYImagePosition: unfound Image Position Patient (0020,0032)");
2099        StrImPos = GetPubElValByNumber(0x0020,0x0030); // For ACR-NEMA images
2100        if (StrImPos == "gdcm::Unfound") {
2101           dbg.Verbose(0, "gdcmHeader::GetYImagePosition: unfound Image Position (RET) (0020,0030)");
2102           // How to tell the caller nothing was found ?
2103           return 0.;
2104        }  
2105      }
2106    if( sscanf( StrImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3)
2107      return 0.;
2108    return yImPos;
2109 }
2110
2111 /**
2112   * \ingroup gdcmHeader
2113   * \brief gets the info from 0020,0032 : Image Position Patient
2114   * \               else from 0020,0030 : Image Position (RET)
2115   * \               else from 0020,1041 : Slice Location
2116   * \               else from 0020,0050 : Location
2117   * \               else 0.
2118   * @return up-left image corner position
2119   */
2120 float gdcmHeader::GetZImagePosition(void) {
2121    float xImPos, yImPos, zImPos; 
2122    string StrImPos = GetPubElValByNumber(0x0020,0x0032);
2123    if (StrImPos != "gdcm::Unfound") {
2124       if( sscanf( StrImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3) {
2125          dbg.Verbose(0, "gdcmHeader::GetZImagePosition: wrong Image Position Patient (0020,0032)");
2126          return 0.;  // bug in the element 0x0020,0x0032
2127       } else {
2128          return zImPos;
2129       }    
2130    }  
2131    StrImPos = GetPubElValByNumber(0x0020,0x0030); // For ACR-NEMA images
2132    if (StrImPos != "gdcm::Unfound") {
2133       if( sscanf( StrImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3) {
2134          dbg.Verbose(0, "gdcmHeader::GetZImagePosition: wrong Image Position (RET) (0020,0030)");
2135          return 0.;  // bug in the element 0x0020,0x0032
2136       } else {
2137          return zImPos;
2138       }    
2139    }                
2140    string StrSliceLocation = GetPubElValByNumber(0x0020,0x1041);// for *very* old ACR-NEMA images
2141    if (StrSliceLocation != "gdcm::Unfound") {
2142       if( sscanf( StrSliceLocation.c_str(), "%f", &zImPos) !=1) {
2143          dbg.Verbose(0, "gdcmHeader::GetZImagePosition: wrong Slice Location (0020,1041)");
2144          return 0.;  // bug in the element 0x0020,0x1041
2145       } else {
2146          return zImPos;
2147       }
2148    }   
2149    dbg.Verbose(0, "gdcmHeader::GetZImagePosition: unfound Slice Location (0020,1041)");
2150    string StrLocation = GetPubElValByNumber(0x0020,0x0050);
2151    if (StrLocation != "gdcm::Unfound") {
2152       if( sscanf( StrLocation.c_str(), "%f", &zImPos) !=1) {
2153          dbg.Verbose(0, "gdcmHeader::GetZImagePosition: wrong Location (0020,0050)");
2154          return 0.;  // bug in the element 0x0020,0x0050
2155       } else {
2156          return zImPos;
2157       }
2158    }
2159    dbg.Verbose(0, "gdcmHeader::GetYImagePosition: unfound Location (0020,0050)");  
2160    return 0.; // Hopeless
2161 }
2162
2163
2164 /**
2165   * \ingroup gdcmHeader
2166   * \brief gets the info from 0002,0010 : Transfert Syntax
2167   * \           else 1.
2168   * @return Transfert Syntax Name (as oposite to Transfert Syntax UID)
2169   */
2170 string gdcmHeader::GetTransferSyntaxName(void) { 
2171    string TransfertSyntax = GetPubElValByNumber(0x0002,0x0010);
2172    if (TransfertSyntax == "gdcm::Unfound") {
2173       dbg.Verbose(0, "gdcmHeader::GetTransferSyntaxName: unfound Transfert Syntax (0002,0010)");
2174       return "Uncompressed ACR-NEMA";
2175    }
2176    // we do it only when we need it
2177    gdcmTS * ts = gdcmGlobal::GetTS();
2178    string tsName=ts->GetValue(TransfertSyntax);
2179    //delete ts; // Seg Fault when deleted ?!
2180    return tsName;
2181 }
2182
2183 // -------------------------------- Lookup Table related functions ------------
2184
2185 /**
2186   * \ingroup gdcmHeader
2187   * \brief gets the info from 0028,1101 : Lookup Table Desc-Red
2188   * \           else 0
2189   * @return Lookup Table Length 
2190   * \       when (0028,0004),Photometric Interpretation = [PALETTE COLOR ] 
2191   */
2192   
2193 int gdcmHeader::GetLUTLength(void) {
2194    vector<string> tokens;
2195    int LutLength;
2196    //int LutDepth;
2197    //int LutNbits;
2198    // Just hope Lookup Table Desc-Red = Lookup Table Desc-Red = Lookup Table Desc-Blue
2199    string LutDescriptionR = GetPubElValByNumber(0x0028,0x1101);
2200    if (LutDescriptionR == "gdcm::Unfound")
2201       return 0;
2202    string LutDescriptionG = GetPubElValByNumber(0x0028,0x1102);
2203    if (LutDescriptionG == "gdcm::Unfound")
2204       return 0;
2205    string LutDescriptionB = GetPubElValByNumber(0x0028,0x1103);
2206    if (LutDescriptionB == "gdcm::Unfound")
2207       return 0;
2208    if( (LutDescriptionR != LutDescriptionG) || (LutDescriptionR != LutDescriptionB) ) {
2209       dbg.Verbose(0, "gdcmHeader::GetLUTLength: The CLUT R,G,B are not equal");
2210       return 0;   
2211    } 
2212    cout << "Lut Description " << LutDescriptionR <<"\n";
2213    tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
2214    Tokenize (LutDescriptionR, tokens, "\\");
2215    LutLength=atoi(tokens[0].c_str());
2216    //LutDepth=atoi(tokens[1].c_str());
2217    //LutNbits=atoi(tokens[2].c_str());
2218    tokens.clear();
2219    return LutLength;
2220 }
2221
2222 /**
2223   * \ingroup gdcmHeader
2224   * \brief gets the info from 0028,1101 : Lookup Table Desc-Red
2225   * \           else 0
2226   * @return Lookup Table nBit 
2227   * \       when (0028,0004),Photometric Interpretation = [PALETTE COLOR ] 
2228   */
2229   
2230 int gdcmHeader::GetLUTNbits(void) {
2231    vector<string> tokens;
2232    //int LutLength;
2233    //int LutDepth;
2234    int LutNbits;
2235    // Just hope Lookup Table Desc-Red = Lookup Table Desc-Red = Lookup Table Desc-Blue
2236    // Consistency already checked in GetLUTLength
2237    string LutDescription = GetPubElValByNumber(0x0028,0x1101);
2238    if (LutDescription == "gdcm::Unfound")
2239       return 0;
2240    tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
2241    Tokenize (LutDescription, tokens, "\\");
2242    //LutLength=atoi(tokens[0].c_str());
2243    //LutDepth=atoi(tokens[1].c_str());
2244    LutNbits=atoi(tokens[2].c_str());
2245    tokens.clear();
2246    return LutNbits;
2247 }
2248   
2249
2250 /**
2251   * \ingroup gdcmHeader
2252   * \brief gets the info from 0028,1201 : Lookup Table Red
2253   * \           else 0
2254   * @return Lookup Table Red 
2255   * \       when (0028,0004),Photometric Interpretation = [PALETTE COLOR ] 
2256   */ 
2257 void * gdcmHeader::GetLUTRed(void) {
2258    return GetPubElValVoidAreaByNumber(0x0028,0x1201);  
2259 }
2260
2261 /**
2262   * \ingroup gdcmHeader
2263   * \brief gets the info from 0028,1202 : Lookup Table Green
2264   * \           else 0
2265   * @return Lookup Table Red 
2266   * \       when (0028,0004),Photometric Interpretation = [PALETTE COLOR ] 
2267   */ 
2268   void * gdcmHeader::GetLUTGreen(void) {
2269    return GetPubElValVoidAreaByNumber(0x0028,0x1202);
2270 }
2271
2272 /**
2273   * \ingroup gdcmHeader
2274   * \brief gets the info from 0028,1202 : Lookup Table Blue
2275   * \           else 0
2276   * @return Lookup Table Blue 
2277   * \       when (0028,0004),Photometric Interpretation = [PALETTE COLOR ] 
2278   */ 
2279 void * gdcmHeader::GetLUTBlue(void) {
2280    return GetPubElValVoidAreaByNumber(0x0028,0x1203);
2281 }
2282
2283 /**
2284   * \ingroup gdcmHeader
2285   * \brief 
2286   * @return Lookup Table RGB
2287   * \       when (0028,0004),Photometric Interpretation = [PALETTE COLOR ]
2288   * \        and (0028,1201),(0028,1202),(0028,1202) are found
2289   * \warning : hazardous ! Use better GetPubElValVoidAreaByNumber
2290   */ 
2291 void * gdcmHeader::GetLUTRGB(void) {
2292 // Not so easy : see 
2293 // http://www.barre.nom.fr/medical/dicom2/limitations.html#Color%20Lookup%20Tables
2294 // and  OT-PAL-8-face.dcm
2295
2296    if (GetPubElValByNumber(0x0028,0x0004) == "gdcm::Unfound") {
2297    dbg.Verbose(0, "gdcmHeader::GetLUTRGB: unfound Photometric Interpretation");
2298         return NULL;
2299    }  
2300    void * LutR,*LutG,*LutB;
2301    int l;
2302      
2303   // Maybe, some day we get an image 
2304   // that respects the definition ...
2305   // Let's consider no ones does.
2306   
2307    l= GetLUTLength();  
2308    if(l==0) 
2309      return (NULL);     
2310    int nBits=GetLUTNbits();
2311   // a virer quand on aura trouve UNE image 
2312   // qui correspond VRAIMENT à la definition !
2313     cout << "l " << l << " nBits " << nBits;
2314    
2315    l= l/(nBits/8);
2316     
2317    LutR =GetPubElValVoidAreaByNumber(0x0028,0x1201);
2318    LutG =GetPubElValVoidAreaByNumber(0x0028,0x1202);
2319    LutB =GetPubElValVoidAreaByNumber(0x0028,0x1203);
2320    
2321    // Warning : Any value for nBits  as to be considered as 8
2322    //           Any value for Length as to be considered as 256
2323    // That's DICOM ...
2324    
2325    // Just wait before removing the following code
2326    /*
2327    if (nBits == 16) {
2328       guint16 * LUTRGB, *rgb;
2329       LUTRGB = rgb = (guint16 *) malloc(3*l*sizeof( guint16));
2330       guint16 * r = (guint16 *)LutR;
2331       guint16 * g = (guint16 *)LutG;
2332       guint16 * b = (guint16 *)LutB;
2333       for(int i=0;i<l;i++) {
2334          *rgb++ = *r++;
2335          *rgb++ = *g++;
2336          *rgb++ = *b++;
2337       }
2338       return(LUTRGB); 
2339    } else
2340    
2341    */ {      // we assume it's always 8 Bits
2342       l=256; // we assume ...
2343       unsigned char * LUTRGB, *rgb;
2344       LUTRGB = rgb = (unsigned char *) malloc(3*l*sizeof( char));
2345       unsigned char * r = (unsigned char *)LutR;
2346       unsigned char * g = (unsigned char *)LutG;
2347       unsigned char * b = (unsigned char *)LutB;
2348       for(int i=0;i<l;i++) {
2349       //cout << "lut16 " << i << " : " << *r << " " << *g << " " << *b << "\n";
2350       printf("lut 8 %d : %d %d %d \n",i,*r,*g,*b);
2351          *rgb++ = *r++;
2352          *rgb++ = *g++;
2353          *rgb++ = *b++;
2354       } 
2355       free(LutR); free(LutB); free(LutG);
2356       return(LUTRGB);   
2357    } 
2358 }
2359