]> Creatis software - gdcm.git/blob - src/gdcmDocument.cxx
- Comment out a for the moment too much verbose warning message.
[gdcm.git] / src / gdcmDocument.cxx
1 /*=========================================================================
2                                                                                 
3   Program:   gdcm
4   Module:    $RCSfile: gdcmDocument.cxx,v $
5   Language:  C++
6   Date:      $Date: 2005/07/06 08:42:33 $
7   Version:   $Revision: 1.257 $
8                                                                                 
9   Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
10   l'Image). All rights reserved. See Doc/License.txt or
11   http://www.creatis.insa-lyon.fr/Public/Gdcm/License.html for details.
12                                                                                 
13      This software is distributed WITHOUT ANY WARRANTY; without even
14      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15      PURPOSE.  See the above copyright notices for more information.
16                                                                                 
17 =========================================================================*/
18
19 #include "gdcmDocument.h"
20 #include "gdcmValEntry.h"
21 #include "gdcmBinEntry.h"
22 #include "gdcmSeqEntry.h"
23 #include "gdcmGlobal.h"
24 #include "gdcmUtil.h"
25 #include "gdcmDebug.h"
26 #include "gdcmTS.h"
27 #include "gdcmDictSet.h"
28 #include "gdcmDocEntrySet.h"
29 #include "gdcmSQItem.h"
30
31 #include <vector>
32 #include <iomanip>
33 #include <fstream>
34 #include <ctype.h>  // for isdigit
35 #include <stdlib.h> // for atoi
36
37 namespace gdcm 
38 {
39 //-----------------------------------------------------------------------------
40
41 // Refer to Document::SetMaxSizeLoadEntry()
42 const unsigned int Document::MAX_SIZE_LOAD_ELEMENT_VALUE = 0xfff; // 4096
43
44 //-----------------------------------------------------------------------------
45 // Constructor / Destructor
46 // Constructors and destructors are protected to avoid user to invoke directly
47
48 /**
49  * \brief This default constructor neither loads nor parses the file. 
50  *        You should then invoke \ref Document::Load.
51  *         
52  */
53 Document::Document() 
54          :ElementSet(-1)
55 {
56    Fp = 0;
57
58    SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
59    Initialize();
60    SwapCode = 1234;
61    Filetype = ExplicitVR;
62    // Load will set it to true if sucessfull
63    Group0002Parsed = false;
64    IsDocumentAlreadyLoaded = false;
65    LoadMode = 0x00000000; // default : load everything, later
66 }
67
68 /**
69  * \brief   Constructor (not to break the API) 
70  * @param   fileName 'Document' (File or DicomDir) to be open for parsing
71  */
72 Document::Document( std::string const &fileName )
73          :ElementSet(-1) 
74 {
75    Fp = 0;
76
77    SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
78    Initialize();
79    SwapCode = 1234;
80    Filetype = ExplicitVR;
81    Group0002Parsed = false;
82    LoadMode = 0x00000000; // Load everything, later
83
84    // Load will set it to true if sucessfull
85    IsDocumentAlreadyLoaded = false;
86
87    Load(fileName);
88 }
89 /**
90  * \brief   Canonical destructor.
91  */
92 Document::~Document ()
93 {
94    RefPubDict = NULL;
95    RefShaDict = NULL;
96 }
97
98 //-----------------------------------------------------------------------------
99 // Public
100
101 /**
102  * \brief   Loader  
103  * @param   fileName 'Document' (File or DicomDir) to be open for parsing
104  * @return false if file cannot be open or no swap info was found,
105  *         or no tag was found.
106  */
107 bool Document::Load( std::string const &fileName ) 
108 {
109    // We should clean out anything that already exists.
110    // Check IsDocumentAlreadyLoaded to be sure.
111    if ( IsDocumentAlreadyLoaded )
112    {
113       gdcmWarningMacro( "A file was already parsed inside this "
114                         << "gdcm::Document (previous name was: "
115                         << Filename.c_str() << ". New name is :"
116                         << fileName );
117      // todo : clean out the 'Document'
118      // Should we call ClearEntry() on the parent object ?!?
119    }
120
121    Filename = fileName;
122
123    Fp = 0;
124    if ( !OpenFile() )
125    {
126       // warning already performed in OpenFile()
127       //gdcmWarningMacro( "Unable to open as an ACR/DICOM file: "
128       //                 << Filename.c_str() );
129       Filetype = Unknown;
130       return false;
131    }
132
133    Group0002Parsed = false;
134
135    gdcmWarningMacro( "Starting parsing of file: " << Filename.c_str());
136
137    Fp->seekg(0, std::ios::end);
138    long lgt = Fp->tellg();       // total length of the file
139
140    Fp->seekg(0, std::ios::beg);
141
142    // CheckSwap returns a boolean 
143    // (false if no swap info of any kind was found)
144    if (! CheckSwap() )
145    {
146       gdcmWarningMacro( "Neither a DICOM V3 nor an ACR-NEMA file: " 
147                    << Filename.c_str());
148       CloseFile(); 
149       return false;      
150     }
151
152    long beg = Fp->tellg();      // just after DICOM preamble (if any)
153
154    lgt -= beg;                  // remaining length to parse    
155
156    // Recursive call.
157    // Loading is done during parsing
158    ParseDES( this, beg, lgt, false); // delim_mode is first defaulted to false
159
160    if ( IsEmpty() )
161    { 
162       gdcmWarningMacro( "No tag in internal hash table for: "
163                         << Filename.c_str());
164       CloseFile(); 
165       return false;
166    }
167    IsDocumentAlreadyLoaded = true;
168
169    Fp->seekg( 0, std::ios::beg);
170    
171    // Load 'non string' values
172       
173    std::string PhotometricInterpretation = GetEntryValue(0x0028,0x0004);   
174    if ( PhotometricInterpretation == "PALETTE COLOR " )
175    {
176    // FIXME
177    // Probabely this line should be outside the 'if'
178    // Try to find an image sample holding a 'gray LUT'
179       LoadEntryBinArea(0x0028,0x1200);  // gray LUT
180    
181       /// FIXME
182       /// The tags refered by the three following lines used to be CORRECTLY
183       /// defined as having an US Value Representation in the public
184       /// dictionary. BUT the semantics implied by the three following
185       /// lines state that the corresponding tag contents are in fact
186       /// the ones of a BinEntry.
187       /// In order to fix things "Quick and Dirty" the dictionary was
188       /// altered on PURPOSE but now contains a WRONG value.
189       /// In order to fix things and restore the dictionary to its
190       /// correct value, one needs to decided of the semantics by deciding
191       /// whether the following tags are either :
192       /// - multivaluated US, and hence loaded as ValEntry, but afterwards
193       ///   also used as BinEntry, which requires the proper conversion,
194       /// - OW, and hence loaded as BinEntry, but afterwards also used
195       ///   as ValEntry, which requires the proper conversion.
196       LoadEntryBinArea(0x0028,0x1201);  // R    LUT
197       LoadEntryBinArea(0x0028,0x1202);  // G    LUT
198       LoadEntryBinArea(0x0028,0x1203);  // B    LUT
199       
200       // Segmented Red   Palette Color LUT Data
201       LoadEntryBinArea(0x0028,0x1221);
202       // Segmented Green Palette Color LUT Data
203       LoadEntryBinArea(0x0028,0x1222);
204       // Segmented Blue  Palette Color LUT Data
205       LoadEntryBinArea(0x0028,0x1223);
206    }
207  
208    //FIXME later : how to use it?
209    SeqEntry *modLutSeq = GetSeqEntry(0x0028,0x3000);
210    if ( modLutSeq !=0 )
211    {
212       SQItem *sqi= modLutSeq->GetFirstSQItem();
213       if ( sqi != 0 )
214       {
215          BinEntry *b = sqi->GetBinEntry(0x0028,0x3006);
216          if ( b != 0 )
217          {
218             if ( b->GetLength() != 0 )
219             {
220                LoadEntryBinArea(b);    //LUT Data (CTX dependent)
221             }   
222         }
223      }      
224    }
225
226    CloseFile(); 
227   
228    // ----------------------------
229    // Specific code to allow gdcm to read ACR-LibIDO formated images
230    // Note: ACR-LibIDO is an extension of the ACR standard that was
231    //       used at CREATIS. For the time being (say a couple of years)
232    //       we keep this kludge to allow CREATIS users 
233    //       reading their old images.
234    //
235    // if recognition code tells us we deal with a LibIDO image
236    // we switch lineNumber and columnNumber
237    //
238    std::string RecCode;
239    RecCode = GetEntryValue(0x0008, 0x0010); // recognition code (RET)
240    if (RecCode == "ACRNEMA_LIBIDO_1.1" ||
241        RecCode == "CANRME_AILIBOD1_1." )  // for brain-damaged softwares
242                                           // with "little-endian strings"
243    {
244          Filetype = ACR_LIBIDO; 
245          std::string rows    = GetEntryValue(0x0028, 0x0010);
246          std::string columns = GetEntryValue(0x0028, 0x0011);
247          SetValEntry(columns, 0x0028, 0x0010);
248          SetValEntry(rows   , 0x0028, 0x0011);
249    }
250    // --- End of ACR-LibIDO kludge --- 
251
252    return true;
253 }
254
255 /**
256  * \brief   Get the public dictionary used
257  */
258 Dict *Document::GetPubDict()
259 {
260    return RefPubDict;
261 }
262
263 /**
264  * \brief   Get the shadow dictionary used
265  */
266 Dict *Document::GetShaDict()
267 {
268    return RefShaDict;
269 }
270
271 /**
272  * \brief   Set the shadow dictionary used
273  * @param   dict dictionary to use in shadow
274  */
275 bool Document::SetShaDict(Dict *dict)
276 {
277    RefShaDict = dict;
278    return !RefShaDict;
279 }
280
281 /**
282  * \brief   Set the shadow dictionary used
283  * @param   dictName name of the dictionary to use in shadow
284  */
285 bool Document::SetShaDict(DictKey const &dictName)
286 {
287    RefShaDict = Global::GetDicts()->GetDict(dictName);
288    return !RefShaDict;
289 }
290
291 /**
292  * \brief  This predicate tells us whether or not the current Document 
293  *         was properly parsed and contains at least *one* Dicom Element
294  *         (and nothing more, sorry).
295  * @return false when we're 150 % sure it's NOT a Dicom/Acr file,
296  *         true otherwise. 
297  */
298 bool Document::IsReadable()
299 {
300    if ( Filetype == Unknown )
301    {
302       gdcmWarningMacro( "Wrong filetype");
303       return false;
304    }
305
306    if ( IsEmpty() )
307    { 
308       gdcmWarningMacro( "No tag in internal hash table.");
309       return false;
310    }
311
312    return true;
313 }
314
315 /**
316  * \brief   Predicate for dicom version 3 file.
317  * @return  True when the file is a dicom version 3.
318  */
319 bool Document::IsDicomV3()
320 {
321    // Checking if Transfer Syntax exists is enough
322    // Anyway, it's too late check if the 'Preamble' was found ...
323    // And ... would it be a rich idea to check ?
324    // (some 'no Preamble' DICOM images exist !)
325    return GetDocEntry(0x0002, 0x0010) != NULL;
326 }
327
328 /**
329  * \brief   Predicate for Papyrus file
330  *          Dedicated to whomsoever it may concern
331  * @return  True when the file is a Papyrus file.
332  */
333 bool Document::IsPapyrus()
334 {
335    // check for Papyrus private Sequence
336    DocEntry *e = GetDocEntry(0x0041, 0x1050);
337    if ( !e )
338       return false;
339    // check if it's actually a Sequence
340    if ( !dynamic_cast<SeqEntry*>(e) )
341       return  false;
342    return true;
343 }
344
345 /**
346  * \brief  returns the File Type 
347  *         (ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown)
348  * @return the FileType code
349  */
350 FileType Document::GetFileType()
351 {
352    return Filetype;
353 }
354
355 /**
356  * \brief   Accessor to the Transfer Syntax (when present) of the
357  *          current document (it internally handles reading the
358  *          value from disk when only parsing occured).
359  * @return  The encountered Transfer Syntax of the current document.
360  */
361 std::string Document::GetTransferSyntax()
362 {
363    DocEntry *entry = GetDocEntry(0x0002, 0x0010);
364    if ( !entry )
365    {
366       return GDCM_UNKNOWN;
367    }
368
369    // The entry might be present but not loaded (parsing and loading
370    // happen at different stages): try loading and proceed with check...
371    LoadDocEntrySafe(entry);
372    if (ValEntry *valEntry = dynamic_cast< ValEntry* >(entry) )
373    {
374       std::string transfer = valEntry->GetValue();
375       // The actual transfer (as read from disk) might be padded. We
376       // first need to remove the potential padding. We can make the
377       // weak assumption that padding was not executed with digits...
378       if  ( transfer.length() == 0 )
379       {
380          // for brain damaged headers
381          return GDCM_UNKNOWN;
382       }
383       while ( !isdigit((unsigned char)transfer[transfer.length()-1]) )
384       {
385          transfer.erase(transfer.length()-1, 1);
386       }
387       return transfer;
388    }
389    return GDCM_UNKNOWN;
390 }
391
392 /**
393  * \brief Accesses the info from 0002,0010 : Transfer Syntax and TS
394  * @return The full Transfer Syntax Name (as opposed to Transfer Syntax UID)
395  */
396 std::string Document::GetTransferSyntaxName()
397 {
398    // use the TS (TS : Transfer Syntax)
399    std::string transferSyntax = GetEntryValue(0x0002,0x0010);
400
401    if ( (transferSyntax.find(GDCM_NOTLOADED) < transferSyntax.length()) )
402    {
403       gdcmErrorMacro( "Transfer Syntax not loaded. " << std::endl
404                << "Better you increase MAX_SIZE_LOAD_ELEMENT_VALUE" );
405       return "Uncompressed ACR-NEMA";
406    }
407    if ( transferSyntax == GDCM_UNFOUND )
408    {
409       gdcmWarningMacro( "Unfound Transfer Syntax (0002,0010)");
410       return "Uncompressed ACR-NEMA";
411    }
412
413    // we do it only when we need it
414    const TSKey &tsName = Global::GetTS()->GetValue( transferSyntax );
415
416    // Global::GetTS() is a global static you shall never try to delete it!
417    return tsName;
418 }
419 //
420 // --------------- Swap Code ------------------
421 /**
422  * \brief   Swaps the bytes so they agree with the processor order
423  * @return  The properly swaped 16 bits integer.
424  */
425 uint16_t Document::SwapShort(uint16_t a)
426 {
427    if ( SwapCode == 4321 || SwapCode == 2143 )
428    {
429       //a = ((( a << 8 ) & 0xff00 ) | (( a >> 8 ) & 0x00ff ) );
430       // Save CPU time
431       a = ( a << 8 ) | ( a >> 8 );
432    }
433    return a;
434 }
435
436 /**
437  * \brief   Swaps back the bytes of 4-byte long integer accordingly to
438  *          processor order.
439  * @return  The properly swaped 32 bits integer.
440  */
441 uint32_t Document::SwapLong(uint32_t a)
442 {
443    switch (SwapCode)
444    {
445       case 1234 :
446          break;
447       case 4321 :
448 //         a=( ((a<<24) & 0xff000000) | ((a<<8)  & 0x00ff0000) | 
449 //             ((a>>8)  & 0x0000ff00) | ((a>>24) & 0x000000ff) );
450 // save CPU time
451          a=( ( a<<24)               | ((a<<8)  & 0x00ff0000) | 
452              ((a>>8)  & 0x0000ff00) |  (a>>24)                );
453          break;   
454       case 3412 :
455 //       a=( ((a<<16) & 0xffff0000) | ((a>>16) & 0x0000ffff) );
456          a=( (a<<16)                | (a>>16)  );
457          break;  
458       case 2143 :
459          a=( ((a<< 8) & 0xff00ff00) | ((a>>8) & 0x00ff00ff)  );
460       break;
461       default :
462          gdcmErrorMacro( "Unset swap code:" << SwapCode );
463          a = 0;
464    }
465    return a;
466
467
468 //
469 // -----------------File I/O ---------------
470 /**
471  * \brief  Tries to open the file \ref Document::Filename and
472  *         checks the preamble when existing.
473  * @return The FILE pointer on success. 
474  */
475 std::ifstream *Document::OpenFile()
476 {
477    HasDCMPreamble = false;
478    if (Filename.length() == 0) 
479    {
480       return 0;
481    }
482
483    if ( Fp )
484    {
485       gdcmWarningMacro( "File already open: " << Filename.c_str());
486       CloseFile();
487    }
488
489    Fp = new std::ifstream(Filename.c_str(), std::ios::in | std::ios::binary);
490    if ( ! *Fp )
491    {
492    // Don't user gdcmErrorMacro :
493    // a spurious message will appear when you use, for instance 
494    // gdcm::FileHelper *fh = new gdcm::FileHelper( outputFileName );
495    // to create outputFileName.
496       gdcmWarningMacro( "Cannot open file: " << Filename.c_str());
497       delete Fp;
498       Fp = 0;
499       return 0;
500       //exit(1); // No function is allowed to leave the application instead
501                  // of warning the caller
502    }
503  
504    uint16_t zero = 0;
505    Fp->read((char*)&zero, (size_t)2);
506    if ( Fp->eof() )
507    {
508       CloseFile();
509       return 0;
510    }
511  
512    //-- ACR or DICOM with no Preamble; may start with a Shadow Group --
513    if ( 
514        zero == 0x0001 || zero == 0x0100 || zero == 0x0002 || zero == 0x0200 ||
515        zero == 0x0003 || zero == 0x0300 || zero == 0x0004 || zero == 0x0400 ||
516        zero == 0x0005 || zero == 0x0500 || zero == 0x0006 || zero == 0x0600 ||
517        zero == 0x0007 || zero == 0x0700 || zero == 0x0008 || zero == 0x0800 )
518    {
519       std::string msg = Util::Format(
520         "ACR/DICOM starting at the begining of the file:(%04x)\n", zero);
521       gdcmWarningMacro( msg.c_str() );
522       return Fp;
523    }
524  
525    //-- DICOM --
526    Fp->seekg(126L, std::ios::cur);
527    char dicm[4] = {' ',' ',' ',' '};
528    Fp->read(dicm,  (size_t)4);
529    if ( Fp->eof() )
530    {
531       CloseFile();
532       return 0;
533    }
534    if ( memcmp(dicm, "DICM", 4) == 0 )
535    {
536       HasDCMPreamble = true;
537       return Fp;
538    }
539
540    // -- Neither ACR/No Preamble Dicom nor DICOMV3 file
541    CloseFile();
542    gdcmWarningMacro( "Neither ACR/No Preamble Dicom nor DICOMV3 file: "
543                       << Filename.c_str()); 
544    return 0;
545 }
546
547 /**
548  * \brief closes the file  
549  * @return  TRUE if the close was successfull 
550  */
551 bool Document::CloseFile()
552 {
553    if ( Fp )
554    {
555       Fp->close();
556       delete Fp;
557       Fp = 0;
558    }
559    return true;
560 }
561
562 /**
563  * \brief Writes in a file all the Header Entries (Dicom Elements) 
564  * @param fp file pointer on an already open file (actually: Output File Stream)
565  * @param filetype Type of the File to be written 
566  *          (ACR-NEMA, ExplicitVR, ImplicitVR)
567  * @return Always true.
568  */
569 void Document::WriteContent(std::ofstream *fp, FileType filetype)
570 {
571    // \TODO move the following lines (and a lot of others, to be written)
572    // to a future function CheckAndCorrectHeader  
573
574    // (necessary if user wants to write a DICOM V3 file
575    // starting from an ACR-NEMA (V2) Header
576
577    if ( filetype == ImplicitVR || filetype == ExplicitVR )
578    {
579       // writing Dicom File Preamble
580       char filePreamble[128];
581       memset(filePreamble, 0, 128);
582       fp->write(filePreamble, 128);
583       fp->write("DICM", 4);
584    }
585
586    /*
587     * \todo rewrite later, if really usefull
588     *       - 'Group Length' element is optional in DICOM
589     *       - but un-updated odd groups lengthes can causes pb
590     *         (xmedcon breaker)
591     *
592     * if ( (filetype == ImplicitVR) || (filetype == ExplicitVR) )
593     *    UpdateGroupLength(false,filetype);
594     * if ( filetype == ACR)
595     *    UpdateGroupLength(true,ACR);
596     */
597
598    ElementSet::WriteContent(fp, filetype); // This one is recursive
599 }
600
601 // -----------------------------------------
602 // Content entries 
603 /**
604  * \brief Loads (from disk) the element content 
605  *        when a string is not suitable
606  * @param group   group number of the Entry 
607  * @param elem  element number of the Entry
608  */
609 void Document::LoadEntryBinArea(uint16_t group, uint16_t elem)
610 {
611    // Search the corresponding DocEntry
612    DocEntry *docElement = GetDocEntry(group, elem);
613    if ( !docElement )
614       return;
615
616    BinEntry *binElement = dynamic_cast<BinEntry *>(docElement);
617    if ( !binElement )
618       return;
619
620    LoadEntryBinArea(binElement);
621 }
622
623 /**
624  * \brief Loads (from disk) the element content 
625  *        when a string is not suitable
626  * @param elem  Entry whose binArea is going to be loaded
627  */
628 void Document::LoadEntryBinArea(BinEntry *elem) 
629 {
630    if (elem->GetBinArea() )
631       return;
632
633    bool openFile = !Fp;
634    if ( openFile )
635       OpenFile();
636
637    size_t o =(size_t)elem->GetOffset();
638    Fp->seekg(o, std::ios::beg);
639
640    size_t l = elem->GetLength();
641    uint8_t *a = new uint8_t[l];
642    if ( !a )
643    {
644       gdcmWarningMacro( "Cannot allocate BinEntry content");
645       return;
646    }
647
648    Fp->read((char*)a, l);
649    if ( Fp->fail() || Fp->eof() )
650    {
651       delete[] a;
652       return;
653    }
654
655    elem->SetBinArea(a);
656
657    if ( openFile )
658       CloseFile();
659 }
660
661 /**
662  * \brief  Loads the element while preserving the current
663  *         underlying file position indicator as opposed to
664  *        LoadDocEntry that modifies it.
665  * @param entry   DocEntry whose value will be loaded. 
666  */
667 void Document::LoadDocEntrySafe(DocEntry *entry)
668 {
669    if ( Fp )
670    {
671       long PositionOnEntry = Fp->tellg();
672       LoadDocEntry(entry);
673       Fp->seekg(PositionOnEntry, std::ios::beg);
674    }
675 }
676
677 /**
678  * \brief   Compares two documents, according to \ref DicomDir rules
679  * \warning Does NOT work with ACR-NEMA files
680  * \todo    Find a trick to solve the pb (use RET fields ?)
681  * @param   document to compare with current one
682  * @return  true if 'smaller'
683  */
684 bool Document::operator<(Document &document)
685 {
686    // Patient Name
687    std::string s1 = GetEntryValue(0x0010,0x0010);
688    std::string s2 = document.GetEntryValue(0x0010,0x0010);
689    if (s1 < s2)
690    {
691       return true;
692    }
693    else if ( s1 > s2 )
694    {
695       return false;
696    }
697    else
698    {
699       // Patient ID
700       s1 = GetEntryValue(0x0010,0x0020);
701       s2 = document.GetEntryValue(0x0010,0x0020);
702       if ( s1 < s2 )
703       {
704          return true;
705       }
706       else if ( s1 > s2 )
707       {
708          return false;
709       }
710       else
711       {
712          // Study Instance UID
713          s1 = GetEntryValue(0x0020,0x000d);
714          s2 = document.GetEntryValue(0x0020,0x000d);
715          if ( s1 < s2 )
716          {
717             return true;
718          }
719          else if ( s1 > s2 )
720          {
721             return false;
722          }
723          else
724          {
725             // Serie Instance UID
726             s1 = GetEntryValue(0x0020,0x000e);
727             s2 = document.GetEntryValue(0x0020,0x000e);    
728             if ( s1 < s2 )
729             {
730                return true;
731             }
732             else if ( s1 > s2 )
733             {
734                return false;
735             }
736          }
737       }
738    }
739    return false;
740 }
741
742 //-----------------------------------------------------------------------------
743 // Protected
744 /**
745  * \brief Reads a supposed to be 16 Bits integer
746  *       (swaps it depending on processor endianness) 
747  * @return read value
748  */
749 uint16_t Document::ReadInt16()
750    throw( FormatError )
751 {
752    uint16_t g;
753    Fp->read ((char*)&g, (size_t)2);
754    if ( Fp->fail() )
755    {
756       throw FormatError( "Document::ReadInt16()", " file error." );
757    }
758    if ( Fp->eof() )
759    {
760       throw FormatError( "Document::ReadInt16()", "EOF." );
761    }
762    g = SwapShort(g); 
763    return g;
764 }
765
766 /**
767  * \brief  Reads a supposed to be 32 Bits integer
768  *        (swaps it depending on processor endianness)  
769  * @return read value
770  */
771 uint32_t Document::ReadInt32()
772    throw( FormatError )
773 {
774    uint32_t g;
775    Fp->read ((char*)&g, (size_t)4);
776    if ( Fp->fail() )
777    {
778       throw FormatError( "Document::ReadInt32()", " file error." );
779    }
780    if ( Fp->eof() )
781    {
782       throw FormatError( "Document::ReadInt32()", "EOF." );
783    }
784    g = SwapLong(g);
785    return g;
786 }
787
788 /**
789  * \brief skips bytes inside the source file 
790  * \warning NOT end user intended method !
791  * @return 
792  */
793 void Document::SkipBytes(uint32_t nBytes)
794 {
795    //FIXME don't dump the returned value
796    Fp->seekg((long)nBytes, std::ios::cur);
797 }
798
799 /**
800  * \brief   Re-computes the length of a ACR-NEMA/Dicom group from a DcmHeader
801  * @param filetype Type of the File to be written 
802  */
803 int Document::ComputeGroup0002Length( FileType filetype ) 
804 {
805    uint16_t gr;
806    std::string vr;
807    
808    int groupLength = 0;
809    bool found0002 = false;   
810   
811    // for each zero-level Tag in the DCM Header
812    DocEntry *entry = GetFirstEntry();
813    while( entry )
814    {
815       gr = entry->GetGroup();
816
817       if ( gr == 0x0002 )
818       {
819          found0002 = true;
820
821          if ( entry->GetElement() != 0x0000 )
822          {
823             vr = entry->GetVR();
824  
825             if ( filetype == ExplicitVR )
826             {
827                if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") || (vr == "UT") ) 
828                {
829                   // explicit VR AND OB, OW, SQ, UT : 4 more bytes
830                   groupLength +=  4;
831                }
832             }
833             groupLength += 2 + 2 + 4 + entry->GetLength();   
834          }
835       }
836       else if (found0002 )
837          break;
838
839       entry = GetNextEntry();
840    }
841    return groupLength; 
842 }
843
844 //-----------------------------------------------------------------------------
845 // Private
846 /**
847  * \brief Loads all the needed Dictionaries
848  * \warning NOT end user intended method !   
849  */
850 void Document::Initialize() 
851 {
852    RefPubDict = Global::GetDicts()->GetDefaultPubDict();
853    RefShaDict = NULL;
854    Filetype   = Unknown;
855 }
856
857 /**
858  * \brief   Parses a DocEntrySet (Zero-level DocEntries or SQ Item DocEntries)
859  * @param set DocEntrySet we are going to parse ('zero level' or a SQItem)
860  * @param offset start of parsing
861  * @param l_max  length to parse (meaningless when we are in 'delimitor mode')
862  * @param delim_mode : whether we are in 'delimitor mode' (l=0xffffff) or not
863  */ 
864 void Document::ParseDES(DocEntrySet *set, long offset, 
865                         long l_max, bool delim_mode)
866 {
867    DocEntry *newDocEntry;
868    ValEntry *newValEntry;
869    BinEntry *newBinEntry;
870    SeqEntry *newSeqEntry;
871    VRKey vr;
872    bool used;
873    bool delim_mode_intern = delim_mode;
874
875    while (true)
876    {
877       if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max)
878       {
879          break;
880       }
881
882       newDocEntry = ReadNextDocEntry( );
883
884       if ( !newDocEntry )
885       {
886          break;
887       }
888
889       used = true;
890       newValEntry = dynamic_cast<ValEntry*>(newDocEntry);
891       newBinEntry = dynamic_cast<BinEntry*>(newDocEntry);
892
893       if ( newValEntry || newBinEntry )
894       {
895          if ( newBinEntry )
896          {
897             vr = newDocEntry->GetVR();
898             if ( Filetype == ExplicitVR && 
899                  !Global::GetVR()->IsVROfBinaryRepresentable(vr) )
900             { 
901                 ////// Neither ValEntry NOR BinEntry: should mean UNKOWN VR
902                 gdcmWarningMacro( std::hex << newDocEntry->GetGroup() 
903                                   << "|" << newDocEntry->GetElement()
904                                   << " : Neither Valentry, nor BinEntry." 
905                                   "Probably unknown VR.");
906             }
907
908          //////////////////// BinEntry or UNKOWN VR:
909             // When "this" is a Document the Key is simply of the
910             // form ( group, elem )...
911             if ( dynamic_cast< Document* > ( set ) )
912             {
913                newBinEntry->SetKey( newBinEntry->GetKey() );
914             }
915             // but when "this" is a SQItem, we are inserting this new
916             // valEntry in a sequence item, and the key has the
917             // generalized form (refer to \ref BaseTagKey):
918             if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) )
919             {
920                newBinEntry->SetKey(  parentSQItem->GetBaseTagKey()
921                                    + newBinEntry->GetKey() );
922             }
923
924             LoadDocEntry( newBinEntry );
925             if ( !set->AddEntry( newBinEntry ) )
926             {
927                //gdcmWarningMacro( "in ParseDES : cannot add a BinEntry "
928                //                    << newBinEntry->GetKey() );
929                used=false;
930             }
931          }
932          else
933          {
934          /////////////////////// ValEntry
935
936             // When "set" is a Document, then we are at the top of the
937             // hierarchy and the Key is simply of the form ( group, elem )...
938             if ( dynamic_cast< Document* > ( set ) )
939             {
940                newValEntry->SetKey( newValEntry->GetKey() );
941             }
942             // ...but when "set" is a SQItem, we are inserting this new
943             // valEntry in a sequence item. Hence the key has the
944             // generalized form (refer to \ref BaseTagKey):
945             if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) )
946             {
947                newValEntry->SetKey(  parentSQItem->GetBaseTagKey()
948                                    + newValEntry->GetKey() );
949             }
950              
951             LoadDocEntry( newValEntry );
952             bool delimitor=newValEntry->IsItemDelimitor();
953
954             if ( LoadMode & NO_SHADOW ) // User asked to skip, if possible, 
955                                         // shadow groups ( if possible :
956                                         // whether element 0x0000 exits)
957             {
958                if ( newValEntry->GetGroup()%2 != 0 )
959                {
960                   if ( newValEntry->GetElement() == 0x0000 )
961                   {
962                      std::string strLgrGroup = newValEntry->GetValue();
963                      int lgrGroup;
964                      if ( strLgrGroup != GDCM_UNFOUND)
965                      {
966                         lgrGroup = atoi(strLgrGroup.c_str());
967                         Fp->seekg(lgrGroup, std::ios::cur);
968                         used = false;
969                         continue;
970                      }
971                   }
972                }
973              }
974
975             if ( !set->AddEntry( newValEntry ) )
976             {
977               //gdcmWarningMacro( "in ParseDES : cannot add a ValEntry "
978               //                    << newValEntry->GetKey() );  
979               used=false;
980             }
981
982             if (delimitor)
983             {
984                if ( !used )
985                   delete newDocEntry;
986                break;
987             }
988             if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max )
989             {
990                if ( !used )
991                   delete newDocEntry;
992                break;
993             }
994          }
995
996          // Just to make sure we are at the beginning of next entry.
997          SkipToNextDocEntry(newDocEntry);
998       }
999       else
1000       {
1001          /////////////////////// SeqEntry :  VR = "SQ"
1002
1003          unsigned long l = newDocEntry->GetReadLength();          
1004          if ( l != 0 ) // don't mess the delim_mode for 'zero-length sequence'
1005          {
1006             if ( l == 0xffffffff )
1007             {
1008               delim_mode_intern = true;
1009             }
1010             else
1011             {
1012               delim_mode_intern = false;
1013             }
1014          }
1015
1016          if ( (LoadMode & NO_SHADOWSEQ) && ! delim_mode_intern )
1017          { 
1018            // User asked to skip SeQuences *only* if they belong to Shadow Group
1019             if ( newDocEntry->GetGroup()%2 != 0 )
1020             {
1021                 Fp->seekg( l, std::ios::cur);
1022                 used = false;
1023                 continue;  
1024             } 
1025          } 
1026          if ( (LoadMode & NO_SEQ) && ! delim_mode_intern ) 
1027          {
1028            // User asked to skip *any* SeQuence
1029             Fp->seekg( l, std::ios::cur);
1030             used = false;
1031             continue;
1032          }
1033          // delay the dynamic cast as late as possible
1034          newSeqEntry = dynamic_cast<SeqEntry*>(newDocEntry);
1035          
1036          // no other way to create the Delimitor ...
1037          newSeqEntry->SetDelimitorMode( delim_mode_intern );
1038
1039          // At the top of the hierarchy, stands a Document. When "set"
1040          // is a Document, then we are building the first depth level.
1041          // Hence the SeqEntry we are building simply has a depth
1042          // level of one:
1043          if ( dynamic_cast< Document* > ( set ) )
1044          {
1045             newSeqEntry->SetDepthLevel( 1 );
1046             newSeqEntry->SetKey( newSeqEntry->GetKey() );
1047          }
1048          // But when "set" is already a SQItem, we are building a nested
1049          // sequence, and hence the depth level of the new SeqEntry
1050          // we are building, is one level deeper:
1051          if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) )
1052          {
1053             newSeqEntry->SetDepthLevel( parentSQItem->GetDepthLevel() + 1 );
1054             newSeqEntry->SetKey(  parentSQItem->GetBaseTagKey()
1055                                 + newSeqEntry->GetKey() );
1056          }
1057
1058          if ( l != 0 )
1059          {  // Don't try to parse zero-length sequences
1060             ParseSQ( newSeqEntry, 
1061                      newDocEntry->GetOffset(),
1062                      l, delim_mode_intern);
1063          }
1064          if ( !set->AddEntry( newSeqEntry ) )
1065          {
1066             //gdcmWarningMacro( "in ParseDES : cannot add a SeqEntry "
1067             //                    << newSeqEntry->GetKey() );
1068             used = false;
1069          }
1070  
1071          if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max)
1072          {
1073             if ( !used )
1074                delete newDocEntry;
1075             break;
1076          }
1077       }
1078
1079       if ( !used )
1080          delete newDocEntry;
1081    }
1082 }
1083
1084 /**
1085  * \brief   Parses a Sequence ( SeqEntry after SeqEntry)
1086  * @return  parsed length for this level
1087  */ 
1088 void Document::ParseSQ( SeqEntry *seqEntry,
1089                         long offset, long l_max, bool delim_mode)
1090 {
1091    int SQItemNumber = 0;
1092    bool dlm_mod;
1093    long offsetStartCurrentSQItem = offset;
1094
1095    while (true)
1096    {
1097       // the first time, we read the fff0,e000 of the first SQItem
1098       DocEntry *newDocEntry = ReadNextDocEntry();
1099
1100       if ( !newDocEntry )
1101       {
1102          // FIXME Should warn user
1103          gdcmWarningMacro("in ParseSQ : should never get here!");
1104          break;
1105       }
1106       if ( delim_mode )
1107       {
1108          if ( newDocEntry->IsSequenceDelimitor() )
1109          {
1110             seqEntry->SetDelimitationItem( newDocEntry ); 
1111             break;
1112          }
1113       }
1114       if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max)
1115       {
1116          delete newDocEntry;
1117          break;
1118       }
1119       // create the current SQItem
1120       SQItem *itemSQ = new SQItem( seqEntry->GetDepthLevel() );
1121       std::ostringstream newBase;
1122       newBase << seqEntry->GetKey()
1123               << "/"
1124               << SQItemNumber
1125               << "#";
1126       itemSQ->SetBaseTagKey( newBase.str() );
1127       unsigned int l = newDocEntry->GetReadLength();
1128       
1129       if ( l == 0xffffffff )
1130       {
1131          dlm_mod = true;
1132       }
1133       else
1134       {
1135          dlm_mod = false;
1136       }
1137
1138       // Let's try :------------
1139       // remove fff0,e000, created out of the SQItem
1140       delete newDocEntry;
1141       Fp->seekg(offsetStartCurrentSQItem, std::ios::beg);
1142       // fill up the current SQItem, starting at the beginning of fff0,e000
1143
1144       ParseDES(itemSQ, offsetStartCurrentSQItem, l+8, dlm_mod);
1145
1146       offsetStartCurrentSQItem = Fp->tellg();
1147       // end try -----------------
1148  
1149       seqEntry->AddSQItem( itemSQ, SQItemNumber ); 
1150       SQItemNumber++;
1151       if ( !delim_mode && ((long)(Fp->tellg())-offset ) >= l_max )
1152       {
1153          break;
1154       }
1155    }
1156 }
1157
1158 /**
1159  * \brief   Loads the element content if its length doesn't exceed
1160  *          the value specified with Document::SetMaxSizeLoadEntry()
1161  * @param   entry Header Entry (Dicom Element) to be dealt with
1162  */
1163 void Document::LoadDocEntry(DocEntry *entry)
1164 {
1165    uint16_t group  = entry->GetGroup();
1166    std::string  vr = entry->GetVR();
1167    uint32_t length = entry->GetLength();
1168
1169    Fp->seekg((long)entry->GetOffset(), std::ios::beg);
1170
1171    // A SeQuence "contains" a set of Elements.  
1172    //          (fffe e000) tells us an Element is beginning
1173    //          (fffe e00d) tells us an Element just ended
1174    //          (fffe e0dd) tells us the current SeQuence just ended
1175    if ( group == 0xfffe )
1176    {
1177       // NO more value field for SQ !
1178       return;
1179    }
1180
1181    // When the length is zero things are easy:
1182    if ( length == 0 )
1183    {
1184       ((ValEntry *)entry)->SetValue("");
1185       return;
1186    }
1187
1188    // The elements whose length is bigger than the specified upper bound
1189    // are not loaded. Instead we leave a short notice on the offset of
1190    // the element content and it's length.
1191
1192    std::ostringstream s;
1193    if (length > MaxSizeLoadEntry)
1194    {
1195       if (BinEntry *binEntryPtr = dynamic_cast< BinEntry* >(entry) )
1196       {  
1197          s << GDCM_NOTLOADED;
1198          s << " Ad.:" << (long)entry->GetOffset();
1199          s << " x(" << std::hex << entry->GetOffset() << ")";
1200          s << std::dec;
1201          s << " Lgt:"  << entry->GetLength();
1202          s << " x(" << std::hex << entry->GetLength() << ")";
1203          binEntryPtr->SetValue(s.str());
1204       }
1205       else if (ValEntry *valEntryPtr = dynamic_cast< ValEntry* >(entry) )
1206       {
1207          s << GDCM_NOTLOADED;  
1208          s << " Address:" << (long)entry->GetOffset();
1209          s << " Length:"  << entry->GetLength();
1210          s << " x(" << std::hex << entry->GetLength() << ")";
1211          valEntryPtr->SetValue(s.str());
1212       }
1213       else
1214       {
1215          // fusible
1216          gdcmErrorMacro( "MaxSizeLoadEntry exceeded, neither a BinEntry "
1217                       << "nor a ValEntry ?! Should never print that !" );
1218       }
1219
1220       // to be sure we are at the end of the value ...
1221       Fp->seekg((long)entry->GetOffset()+(long)entry->GetLength(),
1222                 std::ios::beg);
1223       return;
1224    }
1225
1226    // When we find a BinEntry not very much can be done :
1227    if (BinEntry *binEntryPtr = dynamic_cast< BinEntry* >(entry) )
1228    {
1229       s << GDCM_BINLOADED;
1230       binEntryPtr->SetValue(s.str());
1231       LoadEntryBinArea(binEntryPtr); // last one, not to erase length !
1232       return;
1233    }
1234
1235    if ( IsDocEntryAnInteger(entry) )
1236    {   
1237       uint32_t NewInt;
1238       int nbInt;
1239       // When short integer(s) are expected, read and convert the following 
1240       // (n * 2) characters properly i.e. consider them as short integers as
1241       // opposed to strings.
1242       // Elements with Value Multiplicity > 1
1243       // contain a set of integers (not a single one)       
1244       if (vr == "US" || vr == "SS")
1245       {
1246          nbInt = length / 2;
1247          NewInt = ReadInt16();
1248          s << NewInt;
1249          if (nbInt > 1)
1250          {
1251             for (int i=1; i < nbInt; i++)
1252             {
1253                s << '\\';
1254                NewInt = ReadInt16();
1255                s << NewInt;
1256             }
1257          }
1258       }
1259       // See above comment on multiple integers (mutatis mutandis).
1260       else if (vr == "UL" || vr == "SL")
1261       {
1262          nbInt = length / 4;
1263          NewInt = ReadInt32();
1264          s << NewInt;
1265          if (nbInt > 1)
1266          {
1267             for (int i=1; i < nbInt; i++)
1268             {
1269                s << '\\';
1270                NewInt = ReadInt32();
1271                s << NewInt;
1272             }
1273          }
1274       }
1275 #ifdef GDCM_NO_ANSI_STRING_STREAM
1276       s << std::ends; // to avoid oddities on Solaris
1277 #endif //GDCM_NO_ANSI_STRING_STREAM
1278
1279       ((ValEntry *)entry)->SetValue(s.str());
1280       return;
1281    }
1282    
1283   // FIXME: We need an additional byte for storing \0 that is not on disk
1284    char *str = new char[length+1];
1285    Fp->read(str, (size_t)length);
1286    str[length] = '\0'; //this is only useful when length is odd
1287    // Special DicomString call to properly handle \0 and even length
1288    std::string newValue;
1289    if ( length % 2 )
1290    {
1291       newValue = Util::DicomString(str, length+1);
1292       gdcmWarningMacro("Warning: bad length: " << length <<
1293                        " For string :" <<  newValue.c_str()); 
1294       // Since we change the length of string update it length
1295       //entry->SetReadLength(length+1);
1296    }
1297    else
1298    {
1299       newValue = Util::DicomString(str, length);
1300    }
1301    delete[] str;
1302
1303    if ( ValEntry *valEntry = dynamic_cast<ValEntry* >(entry) )
1304    {
1305       if ( Fp->fail() || Fp->eof())
1306       {
1307          if ( Fp->fail() )
1308             gdcmWarningMacro("--> fail");
1309
1310          gdcmWarningMacro("Unread element value " << valEntry->GetKey() 
1311                           << " lgt : " << valEntry->GetReadLength() 
1312                           << " at " << std::hex << valEntry->GetOffset());
1313          valEntry->SetValue(GDCM_UNREAD);
1314          return;
1315       }
1316
1317       if ( vr == "UI" )
1318       {
1319          // Because of correspondance with the VR dic
1320          valEntry->SetValue(newValue);
1321       }
1322       else
1323       {
1324          valEntry->SetValue(newValue);
1325       }
1326    }
1327    else
1328    {
1329       gdcmWarningMacro("Should have a ValEntry, here ! " << valEntry->GetKey() 
1330                           << " lgt : " << valEntry->GetReadLength() 
1331                           << " at " << std::hex << valEntry->GetOffset());
1332    }
1333 }
1334
1335 /**
1336  * \brief  Find the value Length of the passed Header Entry
1337  * @param  entry Header Entry whose length of the value shall be loaded. 
1338  */
1339 void Document::FindDocEntryLength( DocEntry *entry )
1340    throw ( FormatError )
1341 {
1342    std::string  vr  = entry->GetVR();
1343    uint16_t length16;       
1344    
1345    if ( Filetype == ExplicitVR && !entry->IsImplicitVR() ) 
1346    {
1347       if ( vr == "OB" || vr == "OW" || vr == "SQ" || vr == "UT" || vr == "UN" ) 
1348       {
1349          // The following reserved two bytes (see PS 3.5-2003, section
1350          // "7.1.2 Data element structure with explicit vr", p 27) must be
1351          // skipped before proceeding on reading the length on 4 bytes.
1352          Fp->seekg( 2L, std::ios::cur);
1353          uint32_t length32 = ReadInt32();
1354
1355          if ( (vr == "OB" || vr == "OW") && length32 == 0xffffffff ) 
1356          {
1357             uint32_t lengthOB;
1358             try 
1359             {
1360                lengthOB = FindDocEntryLengthOBOrOW();
1361             }
1362             catch ( FormatUnexpected )
1363             {
1364                // Computing the length failed (this happens with broken
1365                // files like gdcm-JPEG-LossLess3a.dcm). We still have a
1366                // chance to get the pixels by deciding the element goes
1367                // until the end of the file. Hence we artificially fix the
1368                // the length and proceed.
1369                long currentPosition = Fp->tellg();
1370                Fp->seekg(0L,std::ios::end);
1371
1372                long lengthUntilEOF = (long)(Fp->tellg())-currentPosition;
1373                Fp->seekg(currentPosition, std::ios::beg);
1374
1375                entry->SetReadLength(lengthUntilEOF);
1376                entry->SetLength(lengthUntilEOF);
1377                return;
1378             }
1379             entry->SetReadLength(lengthOB);
1380             entry->SetLength(lengthOB);
1381             return;
1382          }
1383          FixDocEntryFoundLength(entry, length32); 
1384          return;
1385       }
1386
1387       // Length is encoded on 2 bytes.
1388       length16 = ReadInt16();
1389   
1390       // 0xffff means that we deal with 'No Length' Sequence 
1391       //        or 'No Length' SQItem
1392       if ( length16 == 0xffff) 
1393       {           
1394          length16 = 0;
1395       }
1396       FixDocEntryFoundLength( entry, (uint32_t)length16 );
1397       return;
1398    }
1399    else
1400    {
1401       // Either implicit VR or a non DICOM conformal (see note below) explicit
1402       // VR that ommited the VR of (at least) this element. Farts happen.
1403       // [Note: according to the part 5, PS 3.5-2001, section 7.1 p25
1404       // on Data elements "Implicit and Explicit VR Data Elements shall
1405       // not coexist in a Data Set and Data Sets nested within it".]
1406       // Length is on 4 bytes.
1407
1408      // Well ... group 0002 is always coded in 'Explicit VR Litle Endian'
1409      // even if Transfer Syntax is 'Implicit VR ...' 
1410       
1411       FixDocEntryFoundLength( entry, ReadInt32() );
1412       return;
1413    }
1414 }
1415
1416 /**
1417  * \brief  Find the Length till the next sequence delimiter
1418  * \warning NOT end user intended method !
1419  * @return 
1420  */
1421 uint32_t Document::FindDocEntryLengthOBOrOW()
1422    throw( FormatUnexpected )
1423 {
1424    // See PS 3.5-2001, section A.4 p. 49 on encapsulation of encoded pixel data.
1425    long positionOnEntry = Fp->tellg();
1426    bool foundSequenceDelimiter = false;
1427    uint32_t totalLength = 0;
1428
1429    while ( !foundSequenceDelimiter )
1430    {
1431       uint16_t group;
1432       uint16_t elem;
1433       try
1434       {
1435          group = ReadInt16();
1436          elem  = ReadInt16();   
1437       }
1438       catch ( FormatError )
1439       {
1440          throw FormatError("Unexpected end of file encountered during ",
1441                            "Document::FindDocEntryLengthOBOrOW()");
1442       }
1443       // We have to decount the group and element we just read
1444       totalLength += 4;     
1445       if ( group != 0xfffe || ( ( elem != 0xe0dd ) && ( elem != 0xe000 ) ) )
1446       {
1447          long filePosition = Fp->tellg();
1448          gdcmWarningMacro( 
1449               "Neither an Item tag nor a Sequence delimiter tag on :" 
1450            << std::hex << group << " , " << elem 
1451            << ") -before- position x(" << filePosition << ")" );
1452   
1453          Fp->seekg(positionOnEntry, std::ios::beg);
1454          throw FormatUnexpected( 
1455                "Neither an Item tag nor a Sequence delimiter tag.");
1456       }
1457       if ( elem == 0xe0dd )
1458       {
1459          foundSequenceDelimiter = true;
1460       }
1461       uint32_t itemLength = ReadInt32();
1462       // We add 4 bytes since we just read the ItemLength with ReadInt32
1463       totalLength += itemLength + 4;
1464       SkipBytes(itemLength);
1465       
1466       if ( foundSequenceDelimiter )
1467       {
1468          break;
1469       }
1470    }
1471    Fp->seekg( positionOnEntry, std::ios::beg);
1472    return totalLength;
1473 }
1474
1475 /**
1476  * \brief     Find the Value Representation of the current Dicom Element.
1477  * @return    Value Representation of the current Entry
1478  */
1479 std::string Document::FindDocEntryVR()
1480 {
1481    if ( Filetype != ExplicitVR )
1482       return GDCM_UNKNOWN;
1483
1484    long positionOnEntry = Fp->tellg();
1485    // Warning: we believe this is explicit VR (Value Representation) because
1486    // we used a heuristic that found "UL" in the first tag. Alas this
1487    // doesn't guarantee that all the tags will be in explicit VR. In some
1488    // cases (see e-film filtered files) one finds implicit VR tags mixed
1489    // within an explicit VR file. Hence we make sure the present tag
1490    // is in explicit VR and try to fix things if it happens not to be
1491    // the case.
1492
1493    char vr[3];
1494    Fp->read (vr, (size_t)2);
1495    vr[2] = 0;
1496
1497    if ( !CheckDocEntryVR(vr) )
1498    {
1499       Fp->seekg(positionOnEntry, std::ios::beg);
1500       return GDCM_UNKNOWN;
1501    }
1502    return vr;
1503 }
1504
1505 /**
1506  * \brief     Check the correspondance between the VR of the header entry
1507  *            and the taken VR. If they are different, the header entry is 
1508  *            updated with the new VR.
1509  * @param     vr    Dicom Value Representation
1510  * @return    false if the VR is incorrect of if the VR isn't referenced
1511  *            otherwise, it returns true
1512 */
1513 bool Document::CheckDocEntryVR(VRKey vr)
1514 {
1515    if ( !Global::GetVR()->IsValidVR(vr) )
1516       return false;
1517
1518    return true; 
1519 }
1520
1521 /**
1522  * \brief   Get the transformed value of the header entry. The VR value 
1523  *          is used to define the transformation to operate on the value
1524  * \warning NOT end user intended method !
1525  * @param   entry entry to tranform
1526  * @return  Transformed entry value
1527  */
1528 std::string Document::GetDocEntryValue(DocEntry *entry)
1529 {
1530    if ( IsDocEntryAnInteger(entry) && entry->IsImplicitVR() )
1531    {
1532       std::string val = ((ValEntry *)entry)->GetValue();
1533       std::string vr  = entry->GetVR();
1534       uint32_t length = entry->GetLength();
1535       std::ostringstream s;
1536       int nbInt;
1537
1538       // When short integer(s) are expected, read and convert the following 
1539       // n * 2 bytes properly i.e. as a multivaluated strings
1540       // (each single value is separated fromthe next one by '\'
1541       // as usual for standard multivaluated filels
1542       // Elements with Value Multiplicity > 1
1543       // contain a set of short integers (not a single one) 
1544    
1545       if ( vr == "US" || vr == "SS" )
1546       {
1547          uint16_t newInt16;
1548
1549          nbInt = length / 2;
1550          for (int i=0; i < nbInt; i++) 
1551          {
1552             if ( i != 0 )
1553             {
1554                s << '\\';
1555             }
1556             newInt16 = ( val[2*i+0] & 0xFF ) + ( ( val[2*i+1] & 0xFF ) << 8);
1557             newInt16 = SwapShort( newInt16 );
1558             s << newInt16;
1559          }
1560       }
1561
1562       // When integer(s) are expected, read and convert the following 
1563       // n * 4 bytes properly i.e. as a multivaluated strings
1564       // (each single value is separated fromthe next one by '\'
1565       // as usual for standard multivaluated filels
1566       // Elements with Value Multiplicity > 1
1567       // contain a set of integers (not a single one) 
1568       else if ( vr == "UL" || vr == "SL" )
1569       {
1570          uint32_t newInt32;
1571
1572          nbInt = length / 4;
1573          for (int i=0; i < nbInt; i++) 
1574          {
1575             if ( i != 0)
1576             {
1577                s << '\\';
1578             }
1579             newInt32 = ( val[4*i+0] & 0xFF )
1580                     + (( val[4*i+1] & 0xFF ) <<  8 )
1581                     + (( val[4*i+2] & 0xFF ) << 16 )
1582                     + (( val[4*i+3] & 0xFF ) << 24 );
1583             newInt32 = SwapLong( newInt32 );
1584             s << newInt32;
1585          }
1586       }
1587 #ifdef GDCM_NO_ANSI_STRING_STREAM
1588       s << std::ends; // to avoid oddities on Solaris
1589 #endif //GDCM_NO_ANSI_STRING_STREAM
1590       return s.str();
1591    }
1592    return ((ValEntry *)entry)->GetValue();
1593 }
1594
1595 /**
1596  * \brief   Get the reverse transformed value of the header entry. The VR 
1597  *          value is used to define the reverse transformation to operate on
1598  *          the value
1599  * \warning NOT end user intended method !
1600  * @param   entry Entry to reverse transform
1601  * @return  Reverse transformed entry value
1602  */
1603 std::string Document::GetDocEntryUnvalue(DocEntry *entry)
1604 {
1605    if ( IsDocEntryAnInteger(entry) && entry->IsImplicitVR() )
1606    {
1607       std::string vr = entry->GetVR();
1608       std::vector<std::string> tokens;
1609       std::ostringstream s;
1610
1611       if ( vr == "US" || vr == "SS" ) 
1612       {
1613          uint16_t newInt16;
1614
1615          tokens.erase( tokens.begin(), tokens.end()); // clean any previous value
1616          Util::Tokenize (((ValEntry *)entry)->GetValue(), tokens, "\\");
1617          for (unsigned int i=0; i<tokens.size(); i++) 
1618          {
1619             newInt16 = atoi(tokens[i].c_str());
1620             s << (  newInt16        & 0xFF ) 
1621               << (( newInt16 >> 8 ) & 0xFF );
1622          }
1623          tokens.clear();
1624       }
1625       if ( vr == "UL" || vr == "SL")
1626       {
1627          uint32_t newInt32;
1628
1629          tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
1630          Util::Tokenize (((ValEntry *)entry)->GetValue(), tokens, "\\");
1631          for (unsigned int i=0; i<tokens.size();i++) 
1632          {
1633             newInt32 = atoi(tokens[i].c_str());
1634             s << (char)(  newInt32         & 0xFF ) 
1635               << (char)(( newInt32 >>  8 ) & 0xFF )
1636               << (char)(( newInt32 >> 16 ) & 0xFF )
1637               << (char)(( newInt32 >> 24 ) & 0xFF );
1638          }
1639          tokens.clear();
1640       }
1641
1642 #ifdef GDCM_NO_ANSI_STRING_STREAM
1643       s << std::ends; // to avoid oddities on Solaris
1644 #endif //GDCM_NO_ANSI_STRING_STREAM
1645       return s.str();
1646    }
1647
1648    return ((ValEntry *)entry)->GetValue();
1649 }
1650
1651 /**
1652  * \brief   Skip a given Header Entry 
1653  * \warning NOT end user intended method !
1654  * @param   entry entry to skip
1655  */
1656 void Document::SkipDocEntry(DocEntry *entry) 
1657 {
1658    SkipBytes(entry->GetLength());
1659 }
1660
1661 /**
1662  * \brief   Skips to the beginning of the next Header Entry 
1663  * \warning NOT end user intended method !
1664  * @param   currentDocEntry entry to skip
1665  */
1666 void Document::SkipToNextDocEntry(DocEntry *currentDocEntry) 
1667 {
1668    Fp->seekg((long)(currentDocEntry->GetOffset()),     std::ios::beg);
1669    if (currentDocEntry->GetGroup() != 0xfffe)  // for fffe pb
1670       Fp->seekg( (long)(currentDocEntry->GetReadLength()),std::ios::cur);
1671 }
1672
1673 /**
1674  * \brief   When the length of an element value is obviously wrong (because
1675  *          the parser went Jabberwocky) one can hope improving things by
1676  *          applying some heuristics.
1677  * @param   entry entry to check
1678  * @param   foundLength first assumption about length    
1679  */
1680 void Document::FixDocEntryFoundLength(DocEntry *entry,
1681                                       uint32_t foundLength)
1682 {
1683    entry->SetReadLength( foundLength ); // will be updated only if a bug is found        
1684    if ( foundLength == 0xffffffff)
1685    {
1686       foundLength = 0;
1687    }
1688    
1689    uint16_t gr   = entry->GetGroup();
1690    uint16_t elem = entry->GetElement(); 
1691      
1692    if ( foundLength % 2)
1693    {
1694       gdcmWarningMacro( "Warning : Tag with uneven length " << foundLength 
1695         <<  " in x(" << std::hex << gr << "," << elem <<")");
1696    }
1697       
1698    //////// Fix for some naughty General Electric images.
1699    // Allthough not recent many such GE corrupted images are still present
1700    // on Creatis hard disks. Hence this fix shall remain when such images
1701    // are no longer in use (we are talking a few years, here)...
1702    // Note: XMedCon probably uses such a trick since it is able to read
1703    //       those pesky GE images ...
1704    if ( foundLength == 13)
1705    {
1706       // Only happens for this length !
1707       if ( gr != 0x0008 || ( elem != 0x0070 && elem != 0x0080 ) )
1708       {
1709          foundLength = 10;
1710          entry->SetReadLength(10); // a bug is to be fixed !?
1711       }
1712    }
1713
1714    //////// Fix for some brain-dead 'Leonardo' Siemens images.
1715    // Occurence of such images is quite low (unless one leaves close to a
1716    // 'Leonardo' source. Hence, one might consider commenting out the
1717    // following fix on efficiency reasons.
1718    else if ( gr   == 0x0009 && ( elem == 0x1113 || elem == 0x1114 ) )
1719    {
1720       foundLength = 4;
1721       entry->SetReadLength(4); // a bug is to be fixed !?
1722    } 
1723  
1724    else if ( entry->GetVR() == "SQ" )
1725    {
1726       foundLength = 0;      // ReadLength is unchanged 
1727    } 
1728     
1729    //////// We encountered a 'delimiter' element i.e. a tag of the form 
1730    // "fffe|xxxx" which is just a marker. Delimiters length should not be
1731    // taken into account.
1732    else if ( gr == 0xfffe )
1733    {    
1734      // According to the norm, fffe|0000 shouldn't exist. BUT the Philips
1735      // image gdcmData/gdcm-MR-PHILIPS-16-Multi-Seq.dcm happens to
1736      // causes extra troubles...
1737      if ( entry->GetElement() != 0x0000 )
1738      {
1739         foundLength = 0;
1740      }
1741    }            
1742    entry->SetLength(foundLength);
1743 }
1744
1745 /**
1746  * \brief   Apply some heuristics to predict whether the considered 
1747  *          element value contains/represents an integer or not.
1748  * @param   entry The element value on which to apply the predicate.
1749  * @return  The result of the heuristical predicate.
1750  */
1751 bool Document::IsDocEntryAnInteger(DocEntry *entry)
1752 {
1753    uint16_t elem         = entry->GetElement();
1754    uint16_t group        = entry->GetGroup();
1755    const std::string &vr = entry->GetVR();
1756    uint32_t length       = entry->GetLength();
1757
1758    // When we have some semantics on the element we just read, and if we
1759    // a priori know we are dealing with an integer, then we shall be
1760    // able to swap it's element value properly.
1761    if ( elem == 0 )  // This is the group length of the group
1762    {  
1763       if ( length == 4 )
1764       {
1765          return true;
1766       }
1767       else 
1768       {
1769          // Allthough this should never happen, still some images have a
1770          // corrupted group length [e.g. have a glance at offset x(8336) of
1771          // gdcmData/gdcm-MR-PHILIPS-16-Multi-Seq.dcm].
1772          // Since for dicom compliant and well behaved headers, the present
1773          // test is useless (and might even look a bit paranoid), when we
1774          // encounter such an ill-formed image, we simply display a warning
1775          // message and proceed on parsing (while crossing fingers).
1776          long filePosition = Fp->tellg();
1777          gdcmWarningMacro( "Erroneous Group Length element length  on : (" 
1778            << std::hex << group << " , " << elem
1779            << ") -before- position x(" << filePosition << ")"
1780            << "lgt : " << length );
1781       }
1782    }
1783
1784    if ( vr == "UL" || vr == "US" || vr == "SL" || vr == "SS" )
1785    {
1786       return true;
1787    }   
1788    return false;
1789 }
1790
1791 /**
1792  * \brief   Discover what the swap code is (among little endian, big endian,
1793  *          bad little endian, bad big endian).
1794  *          sw is set
1795  * @return false when we are absolutely sure 
1796  *               it's neither ACR-NEMA nor DICOM
1797  *         true  when we hope ours assuptions are OK
1798  */
1799 bool Document::CheckSwap()
1800 {   
1801    uint32_t  s32;
1802    uint16_t  s16;
1803        
1804    char deb[256];
1805     
1806    // First, compare HostByteOrder and NetworkByteOrder in order to
1807    // determine if we shall need to swap bytes (i.e. the Endian type).
1808    bool net2host = Util::IsCurrentProcessorBigEndian();
1809          
1810    // The easiest case is the one of a 'true' DICOM header, we just have
1811    // to look for the string "DICM" inside the file preamble.
1812    Fp->read(deb, 256);
1813    
1814    char *entCur = deb + 128;
1815    if ( memcmp(entCur, "DICM", (size_t)4) == 0 )
1816    {
1817       gdcmWarningMacro( "Looks like DICOM Version3 (preamble + DCM)" );
1818       
1819       // Group 0002 should always be VR, and the first element 0000
1820       // Let's be carefull (so many wrong headers ...)
1821       // and determine the value representation (VR) : 
1822       // Let's skip to the first element (0002,0000) and check there if we find
1823       // "UL"  - or "OB" if the 1st one is (0002,0001) -,
1824       // in which case we (almost) know it is explicit VR.
1825       // WARNING: if it happens to be implicit VR then what we will read
1826       // is the length of the group. If this ascii representation of this
1827       // length happens to be "UL" then we shall believe it is explicit VR.
1828       // We need to skip :
1829       // * the 128 bytes of File Preamble (often padded with zeroes),
1830       // * the 4 bytes of "DICM" string,
1831       // * the 4 bytes of the first tag (0002, 0000),or (0002, 0001)
1832       // i.e. a total of  136 bytes.
1833       entCur = deb + 136;
1834      
1835       // group 0x0002 *is always* Explicit VR Sometimes ,
1836       // even if elem 0002,0010 (Transfer Syntax) tells us the file is
1837       // *Implicit* VR  (see former 'gdcmData/icone.dcm')
1838       
1839       if ( memcmp(entCur, "UL", (size_t)2) == 0 ||
1840            memcmp(entCur, "OB", (size_t)2) == 0 ||
1841            memcmp(entCur, "UI", (size_t)2) == 0 ||
1842            memcmp(entCur, "CS", (size_t)2) == 0 )  // CS, to remove later
1843                                                    // when Write DCM *adds*
1844       // FIXME
1845       // Use Document::dicom_vr to test all the possibilities
1846       // instead of just checking for UL, OB and UI !? group 0000 
1847       {
1848          Filetype = ExplicitVR;
1849          gdcmWarningMacro( "Group 0002 : Explicit Value Representation");
1850       } 
1851       else 
1852       {
1853          Filetype = ImplicitVR;
1854          gdcmWarningMacro( "Group 0002 :Not an explicit Value Representation;"
1855                         << "Looks like a bugged Header!");
1856       }
1857       
1858       if ( net2host )
1859       {
1860          SwapCode = 4321;
1861          gdcmWarningMacro( "HostByteOrder != NetworkByteOrder");
1862       }
1863       else 
1864       {
1865          SwapCode = 1234;
1866          gdcmWarningMacro( "HostByteOrder = NetworkByteOrder");
1867       }
1868       
1869       // Position the file position indicator at first tag 
1870       // (i.e. after the file preamble and the "DICM" string).
1871
1872       Fp->seekg(0, std::ios::beg); // FIXME : Is it usefull?
1873
1874       Fp->seekg ( 132L, std::ios::beg);
1875       return true;
1876    } // ------------------------------- End of DicomV3 ----------------
1877
1878    // Alas, this is not a DicomV3 file and whatever happens there is no file
1879    // preamble. We can reset the file position indicator to where the data
1880    // is (i.e. the beginning of the file).
1881
1882    gdcmWarningMacro( "Not a Kosher DICOM Version3 file (no preamble)");
1883
1884    Fp->seekg(0, std::ios::beg);
1885
1886    // Let's check 'No Preamble Dicom File' :
1887    // Should start with group 0x0002
1888    // and be Explicit Value Representation
1889
1890    s16 = *((uint16_t *)(deb));
1891    SwapCode = 0;     
1892    switch ( s16 )
1893    {
1894       case 0x0002 :
1895          SwapCode = 1234;
1896          entCur = deb + 4;
1897          break;
1898       case 0x0200 :
1899          SwapCode = 4321;
1900          entCur = deb + 6;
1901     } 
1902
1903    if ( SwapCode != 0 )
1904    {
1905       if ( memcmp(entCur, "UL", (size_t)2) == 0 ||
1906            memcmp(entCur, "OB", (size_t)2) == 0 ||
1907            memcmp(entCur, "UI", (size_t)2) == 0 ||
1908            memcmp(entCur, "SH", (size_t)2) == 0 ||
1909            memcmp(entCur, "AE", (size_t)2) == 0 ||
1910            memcmp(entCur, "OB", (size_t)2) == 0 )
1911          {
1912             Filetype = ExplicitVR;
1913             gdcmWarningMacro( "Group 0002 : Explicit Value Representation");
1914             return true;
1915           }
1916     }
1917 // ------------------------------- End of 'No Preamble' DicomV3 -------------
1918
1919    // Our next best chance would be to be considering a 'clean' ACR/NEMA file.
1920    // By clean we mean that the length of the first group is written down.
1921    // If this is the case and since the length of the first group HAS to be
1922    // four (bytes), then determining the proper swap code is straightforward.
1923
1924    entCur = deb + 4;
1925    // We assume the array of char we are considering contains the binary
1926    // representation of a 32 bits integer. Hence the following dirty
1927    // trick :
1928    s32 = *((uint32_t *)(entCur));
1929    switch( s32 )
1930    {
1931       case 0x00040000 :
1932          SwapCode = 3412;
1933          Filetype = ACR;
1934          return true;
1935       case 0x04000000 :
1936          SwapCode = 4321;
1937          Filetype = ACR;
1938          return true;
1939       case 0x00000400 :
1940          SwapCode = 2143;
1941          Filetype = ACR;
1942          return true;
1943       case 0x00000004 :
1944          SwapCode = 1234;
1945          Filetype = ACR;
1946          return true;
1947       default :
1948          // We are out of luck. It is not a DicomV3 nor a 'clean' ACR/NEMA file.
1949          // It is time for despaired wild guesses. 
1950          // So, let's check if this file wouldn't happen to be 'dirty' ACR/NEMA,
1951          //  i.e. the 'group length' element is not present :     
1952          
1953          //  check the supposed-to-be 'group number'
1954          //  in ( 0x0001 .. 0x0008 )
1955          //  to determine ' SwapCode' value .
1956          //  Only 0 or 4321 will be possible 
1957          //  (no oportunity to check for the formerly well known
1958          //  ACR-NEMA 'Bad Big Endian' or 'Bad Little Endian' 
1959          //  if unsuccessfull (i.e. neither 0x0002 nor 0x0200 etc -3, 4, ..., 8-) 
1960          //  the file IS NOT ACR-NEMA nor DICOM V3
1961          //  Find a trick to tell it the caller...
1962       
1963          s16 = *((uint16_t *)(deb));
1964       
1965          switch ( s16 )
1966          {
1967             case 0x0001 :
1968             case 0x0002 :
1969             case 0x0003 :
1970             case 0x0004 :
1971             case 0x0005 :
1972             case 0x0006 :
1973             case 0x0007 :
1974             case 0x0008 :
1975                SwapCode = 1234;
1976                Filetype = ACR;
1977                return true;
1978             case 0x0100 :
1979             case 0x0200 :
1980             case 0x0300 :
1981             case 0x0400 :
1982             case 0x0500 :
1983             case 0x0600 :
1984             case 0x0700 :
1985             case 0x0800 :
1986                SwapCode = 4321;
1987                Filetype = ACR;
1988                return true;
1989             default :
1990                gdcmWarningMacro( "ACR/NEMA unfound swap info (Really hopeless !)");
1991                Filetype = Unknown;
1992                return false;
1993          }
1994    }
1995 }
1996
1997 /**
1998  * \brief Change the Byte Swap code. 
1999  */
2000 void Document::SwitchByteSwapCode() 
2001 {
2002    gdcmWarningMacro( "Switching Byte Swap code from "<< SwapCode
2003                      << " at :" <<std::hex << Fp->tellg() );
2004    if ( SwapCode == 1234 ) 
2005    {
2006       SwapCode = 4321;
2007    }
2008    else if ( SwapCode == 4321 ) 
2009    {
2010       SwapCode = 1234;
2011    }
2012    else if ( SwapCode == 3412 ) 
2013    {
2014       SwapCode = 2143;
2015    }
2016    else if ( SwapCode == 2143 )
2017    {
2018       SwapCode = 3412;
2019    }
2020 }
2021
2022 /**
2023  * \brief  during parsing, Header Elements too long are not loaded in memory 
2024  * @param newSize new size
2025  */
2026 void Document::SetMaxSizeLoadEntry(long newSize) 
2027 {
2028    if ( newSize < 0 )
2029    {
2030       return;
2031    }
2032    if ((uint32_t)newSize >= (uint32_t)0xffffffff )
2033    {
2034       MaxSizeLoadEntry = 0xffffffff;
2035       return;
2036    }
2037    MaxSizeLoadEntry = newSize;
2038 }
2039
2040 /**
2041  * \brief   Read the next tag WITHOUT loading it's value
2042  *          (read the 'Group Number', the 'Element Number',
2043  *          gets the Dict Entry
2044  *          gets the VR, gets the length, gets the offset value)
2045  * @return  On succes : the newly created DocEntry, NULL on failure.      
2046  */
2047 DocEntry *Document::ReadNextDocEntry()
2048 {
2049    uint16_t group;
2050    uint16_t elem;
2051
2052    try
2053    {
2054       group = ReadInt16();
2055       elem  = ReadInt16();
2056    }
2057    catch ( FormatError e )
2058    {
2059       // We reached the EOF (or an error occured) therefore 
2060       // header parsing has to be considered as finished.
2061       return 0;
2062    }
2063
2064    // Sometimes file contains groups of tags with reversed endianess.
2065    HandleBrokenEndian(group, elem);
2066
2067    // In 'true DICOM' files Group 0002 is always little endian
2068    if ( HasDCMPreamble )
2069       HandleOutOfGroup0002(group, elem);
2070  
2071    std::string vr = FindDocEntryVR();
2072    std::string realVR = vr;
2073
2074    if ( vr == GDCM_UNKNOWN )
2075    {
2076       if ( elem == 0x0000 ) // Group Length
2077          realVR = "UL";     // must be UL
2078       else
2079       {
2080          DictEntry *dictEntry = GetDictEntry(group,elem);
2081          if ( dictEntry )
2082             realVR = dictEntry->GetVR();
2083       }
2084    }
2085
2086    DocEntry *newEntry;
2087    if ( Global::GetVR()->IsVROfSequence(realVR) )
2088       newEntry = NewSeqEntry(group, elem);
2089    else if ( Global::GetVR()->IsVROfStringRepresentable(realVR) )
2090       newEntry = NewValEntry(group, elem,vr);
2091    else
2092       newEntry = NewBinEntry(group, elem,vr);
2093
2094    if ( vr == GDCM_UNKNOWN )
2095    {
2096       if ( Filetype == ExplicitVR )
2097       {
2098          // We thought this was explicit VR, but we end up with an
2099          // implicit VR tag. Let's backtrack.
2100          if ( newEntry->GetGroup() != 0xfffe )
2101          { 
2102             std::string msg;
2103             int offset = Fp->tellg();
2104             msg = Util::Format("Entry (%04x,%04x) at 0x(%x) should be Explicit VR\n", 
2105                           newEntry->GetGroup(), newEntry->GetElement(), offset );
2106             gdcmWarningMacro( msg.c_str() );
2107           }
2108       }
2109       newEntry->SetImplicitVR();
2110    }
2111
2112    try
2113    {
2114       FindDocEntryLength(newEntry);
2115    }
2116    catch ( FormatError e )
2117    {
2118       // Call it quits
2119       delete newEntry;
2120       return 0;
2121    }
2122
2123    newEntry->SetOffset(Fp->tellg());  
2124
2125    return newEntry;
2126 }
2127
2128 /**
2129  * \brief   Handle broken private tag from Philips NTSCAN
2130  *          where the endianess is being switched to BigEndian 
2131  *          for no apparent reason
2132  * @return  no return
2133  */
2134 void Document::HandleBrokenEndian(uint16_t &group, uint16_t &elem)
2135 {
2136    // Endian reversion. Some files contain groups of tags with reversed endianess.
2137    static int reversedEndian = 0;
2138    // try to fix endian switching in the middle of headers
2139    if ((group == 0xfeff) && (elem == 0x00e0))
2140    {
2141      // start endian swap mark for group found
2142      reversedEndian++;
2143      SwitchByteSwapCode();
2144      // fix the tag
2145      group = 0xfffe;
2146      elem  = 0xe000;
2147    } 
2148    else if (group == 0xfffe && elem == 0xe00d && reversedEndian) 
2149    {
2150      // end of reversed endian group
2151      reversedEndian--;
2152      SwitchByteSwapCode();
2153    }
2154 }
2155
2156 /**
2157  * \brief   Group 0002 is always coded Little Endian
2158  *          whatever Transfer Syntax is
2159  * @return  no return
2160  */
2161 void Document::HandleOutOfGroup0002(uint16_t &group, uint16_t &elem)
2162 {
2163    // Endian reversion. Some files contain groups of tags with reversed endianess.
2164    if ( !Group0002Parsed && group != 0x0002)
2165    {
2166       Group0002Parsed = true;
2167       // we just came out of group 0002
2168       // if Transfer syntax is Big Endian we have to change CheckSwap
2169
2170       std::string ts = GetTransferSyntax();
2171       if ( !Global::GetTS()->IsTransferSyntax(ts) )
2172       {
2173          gdcmWarningMacro("True DICOM File, with NO Tansfer Syntax: " << ts );
2174          return;
2175       }
2176
2177       // Group 0002 is always 'Explicit ...' enven when Transfer Syntax says 'Implicit ..." 
2178
2179       if ( Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRLittleEndian )
2180          {
2181             Filetype = ImplicitVR;
2182          }
2183        
2184       // FIXME Strangely, this works with 
2185       //'Implicit VR Transfer Syntax (GE Private)
2186       if ( Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRBigEndian )
2187       {
2188          gdcmWarningMacro("Transfer Syntax Name = [" 
2189                         << GetTransferSyntaxName() << "]" );
2190          SwitchByteSwapCode();
2191          group = SwapShort(group);
2192          elem  = SwapShort(elem);
2193       }
2194    }
2195 }
2196
2197 //-----------------------------------------------------------------------------
2198 // Print
2199
2200 //-----------------------------------------------------------------------------
2201 } // end namespace gdcm