X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmDocument.cxx;h=5f40b723e6d3ed4d141162ca360b947af9b3d0b0;hb=f3cc252fad08c3e8dbc395f2ca7cabf47bf95302;hp=f87337747ee26e66f5ff2c46f3f66208e3463044;hpb=be803332322436f4bc87c9b517dcfc658a9027b4;p=gdcm.git diff --git a/src/gdcmDocument.cxx b/src/gdcmDocument.cxx index f8733774..5f40b723 100644 --- a/src/gdcmDocument.cxx +++ b/src/gdcmDocument.cxx @@ -3,8 +3,8 @@ Program: gdcm Module: $RCSfile: gdcmDocument.cxx,v $ Language: C++ - Date: $Date: 2005/04/05 10:20:53 $ - Version: $Revision: 1.234 $ + Date: $Date: 2005/08/30 15:13:09 $ + Version: $Revision: 1.273 $ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de l'Image). All rights reserved. See Doc/License.txt or @@ -31,12 +31,12 @@ #include #include #include +#include // for isdigit +#include // for atoi namespace gdcm { //----------------------------------------------------------------------------- -// Refer to Document::CheckSwap() -//const unsigned int Document::HEADER_LENGTH_TO_READ = 256; // Refer to Document::SetMaxSizeLoadEntry() const unsigned int Document::MAX_SIZE_LOAD_ELEMENT_VALUE = 0xfff; // 4096 @@ -59,15 +59,19 @@ Document::Document() Initialize(); SwapCode = 1234; Filetype = ExplicitVR; + // Load will set it to true if sucessfull Group0002Parsed = false; - LoadMode = 0x00000000; // default : load everything, later + IsDocumentAlreadyLoaded = false; + IsDocumentModified = true; + LoadMode = LD_ALL; // default : load everything, later + SetFileName(""); } /** - * \brief Constructor (not to break the API) - * @param filename 'Document' (File or DicomDir) to be opened for parsing + * \brief Constructor (DEPRECATED : not to break the API) + * @param fileName 'Document' (File or DicomDir) to be open for parsing */ -Document::Document( std::string const &filename ) +Document::Document( std::string const &fileName ) :ElementSet(-1) { Fp = 0; @@ -77,9 +81,14 @@ Document::Document( std::string const &filename ) SwapCode = 1234; Filetype = ExplicitVR; Group0002Parsed = false; - LoadMode = 0x00000000; // Load everything + LoadMode = LD_ALL; // Load everything, later - Load(filename); + // Load will set it to true if sucessfull + IsDocumentAlreadyLoaded = false; + IsDocumentModified = true; + + SetFileName(fileName); + Load( ); } /** * \brief Canonical destructor. @@ -94,19 +103,66 @@ Document::~Document () // Public /** - * \brief Loader - * @param filename 'Document' (File or DicomDir) to be opened for parsing + * \brief Loader. use SetLoadMode(), SetFileName() before ! + * @return false if file cannot be open or no swap info was found, + * or no tag was found. */ -void Document::Load( std::string const &filename ) +bool Document::Load( ) { - Filename = filename; + if ( GetFileName() == "" ) + { + gdcmWarningMacro( "Use SetFileName, before !" ); + return false; + } + return DoTheLoadingDocumentJob( ); +} +/** + * \brief Loader. (DEPRECATED : not to break the API) + * @param fileName 'Document' (File or DicomDir) to be open for parsing + * @return false if file cannot be open or no swap info was found, + * or no tag was found. + */ +bool Document::Load( std::string const &fileName ) +{ + Filename = fileName; + return DoTheLoadingDocumentJob( ); +} - // We should clean out anything that already exists. +/** + * \brief Performs the Loading Job (internal use only) + * @return false if file cannot be open or no swap info was found, + * or no tag was found. + */ +bool Document::DoTheLoadingDocumentJob( ) +{ + if ( ! IsDocumentModified ) // Nothing to do ! + return true; + + // if ( Filename == fileName ) + // { + // gdcmWarningMacro( "The file was already parsed inside this " + // << "gdcm::Document (its name is: " + // << Filename.c_str() ); + // return true; + // } + + //gdcmWarningMacro( "A file was already parsed inside this " + // << "gdcm::Document (previous name was: " + // << Filename.c_str() << ". New name is :" + // << fileName ); + // clean out the Entries, if already parsed + // (probabely a mistake from the user) + + ClearEntry(); Fp = 0; if ( !OpenFile() ) { - return; + // warning already performed in OpenFile() + //gdcmWarningMacro( "Unable to open as an ACR/DICOM file: " + // << Filename.c_str() ); + Filetype = Unknown; + return false; } Group0002Parsed = false; @@ -118,22 +174,46 @@ void Document::Load( std::string const &filename ) Fp->seekg(0, std::ios::beg); - CheckSwap(); + // CheckSwap returns a boolean + // (false if no swap info of any kind was found) + if (! CheckSwap() ) + { + gdcmWarningMacro( "Neither a DICOM V3 nor an ACR-NEMA file: " + << Filename.c_str()); + CloseFile(); + return false; + } + long beg = Fp->tellg(); // just after DICOM preamble (if any) lgt -= beg; // remaining length to parse - ParseDES( this, beg, lgt, false); // Loading is done during parsing + // Recursive call. + // Loading is done during parsing + ParseDES( this, beg, lgt, false); // delim_mode is first defaulted to false + + if ( IsEmpty() ) + { + gdcmWarningMacro( "No tag in internal hash table for: " + << Filename.c_str()); + CloseFile(); + return false; + } + IsDocumentAlreadyLoaded = true; Fp->seekg( 0, std::ios::beg); // Load 'non string' values std::string PhotometricInterpretation = GetEntryValue(0x0028,0x0004); - if( PhotometricInterpretation == "PALETTE COLOR " ) + if ( PhotometricInterpretation == "PALETTE COLOR " ) { - LoadEntryBinArea(0x0028,0x1200); // gray LUT - /// FIXME FIXME FIXME + // FIXME + // Probabely this line should be outside the 'if' + // Try to find an image sample holding a 'gray LUT' + LoadEntryBinArea(0x0028,0x1200); // gray LUT + + /// FIXME /// The tags refered by the three following lines used to be CORRECTLY /// defined as having an US Value Representation in the public /// dictionary. BUT the semantics implied by the three following @@ -143,7 +223,7 @@ void Document::Load( std::string const &filename ) /// altered on PURPOSE but now contains a WRONG value. /// In order to fix things and restore the dictionary to its /// correct value, one needs to decided of the semantics by deciding - /// whether the following tags are either: + /// whether the following tags are either : /// - multivaluated US, and hence loaded as ValEntry, but afterwards /// also used as BinEntry, which requires the proper conversion, /// - OW, and hence loaded as BinEntry, but afterwards also used @@ -158,16 +238,63 @@ void Document::Load( std::string const &filename ) LoadEntryBinArea(0x0028,0x1222); // Segmented Blue Palette Color LUT Data LoadEntryBinArea(0x0028,0x1223); - } + } + //FIXME later : how to use it? - LoadEntryBinArea(0x0028,0x3006); //LUT Data (CTX dependent) + SeqEntry *modLutSeq = GetSeqEntry(0x0028,0x3000); + if ( modLutSeq !=0 ) + { + SQItem *sqi= modLutSeq->GetFirstSQItem(); + if ( sqi != 0 ) + { + BinEntry *b = sqi->GetBinEntry(0x0028,0x3006); + if ( b != 0 ) + { + if ( b->GetLength() != 0 ) + { + LoadEntryBinArea(b); //LUT Data (CTX dependent) + } + } + } + } + + // Force Loading some more elements if user asked to. + + gdcm::DocEntry *d; + for (ListElements::iterator it = UserForceLoadList.begin(); + it != UserForceLoadList.end(); + ++it) + { + d = GetDocEntry( (*it).Group, (*it).Elem); + + if ( d == NULL) + continue; + + if ( dynamic_cast(d) ) + { + LoadDocEntry(d, true); + continue; + } + + if ( dynamic_cast(d) ) + { + LoadEntryBinArea((*it).Group, (*it).Elem); + continue; + } + + if ( dynamic_cast(d) ) + { + gdcmWarningMacro( "You cannot 'ForceLoad' a SeqEntry "); + continue; + } + } CloseFile(); // ---------------------------- // Specific code to allow gdcm to read ACR-LibIDO formated images // Note: ACR-LibIDO is an extension of the ACR standard that was - // used at CREATIS. For the time being (say a couple years) + // used at CREATIS. For the time being (say a couple of years) // we keep this kludge to allow CREATIS users // reading their old images. // @@ -187,8 +314,22 @@ void Document::Load( std::string const &filename ) SetValEntry(rows , 0x0028, 0x0011); } // --- End of ACR-LibIDO kludge --- + return true; } + +/** + * \brief Adds a new element we want to load anyway + * @param group Group number of the target tag. + * @param elem Element number of the target tag. + */ +void Document::AddForceLoadElement (uint16_t group, uint16_t elem) +{ + Element el; + el.Group = group; + el.Elem = elem; + UserForceLoadList.push_back(el); +} /** * \brief Get the public dictionary used */ @@ -226,16 +367,15 @@ bool Document::SetShaDict(DictKey const &dictName) } /** - * \brief This predicate, based on hopefully reasonable heuristics, - * decides whether or not the current Document was properly parsed - * and contains the mandatory information for being considered as - * a well formed and usable Dicom/Acr File. - * @return true when Document is the one of a reasonable Dicom/Acr file, - * false otherwise. + * \brief This predicate tells us whether or not the current Document + * was properly parsed and contains at least *one* Dicom Element + * (and nothing more, sorry). + * @return false when we're 150 % sure it's NOT a Dicom/Acr file, + * true otherwise. */ bool Document::IsReadable() { - if( Filetype == Unknown) + if ( Filetype == Unknown ) { gdcmWarningMacro( "Wrong filetype"); return false; @@ -257,7 +397,7 @@ bool Document::IsReadable() bool Document::IsDicomV3() { // Checking if Transfer Syntax exists is enough - // Anyway, it's to late check if the 'Preamble' was found ... + // Anyway, it's too late check if the 'Preamble' was found ... // And ... would it be a rich idea to check ? // (some 'no Preamble' DICOM images exist !) return GetDocEntry(0x0002, 0x0010) != NULL; @@ -418,60 +558,67 @@ std::ifstream *Document::OpenFile() return 0; } - if(Fp) + if ( Fp ) { gdcmWarningMacro( "File already open: " << Filename.c_str()); CloseFile(); } Fp = new std::ifstream(Filename.c_str(), std::ios::in | std::ios::binary); - if( ! *Fp ) + if ( ! *Fp ) { - gdcmDebugMacro( "Cannot open file: " << Filename.c_str()); + // Don't user gdcmErrorMacro : + // a spurious message will appear when you use, for instance + // gdcm::FileHelper *fh = new gdcm::FileHelper( outputFileName ); + // to create outputFileName. + gdcmWarningMacro( "Cannot open file: " << Filename.c_str()); delete Fp; Fp = 0; return 0; + //exit(1); // No function is allowed to leave the application instead + // of warning the caller } uint16_t zero = 0; Fp->read((char*)&zero, (size_t)2); - if( Fp->eof() ) + if ( Fp->eof() ) { CloseFile(); return 0; } - //ACR -- or DICOM with no Preamble; may start with a Shadow Group -- - if( + //-- ACR or DICOM with no Preamble; may start with a Shadow Group -- + if ( zero == 0x0001 || zero == 0x0100 || zero == 0x0002 || zero == 0x0200 || zero == 0x0003 || zero == 0x0300 || zero == 0x0004 || zero == 0x0400 || zero == 0x0005 || zero == 0x0500 || zero == 0x0006 || zero == 0x0600 || zero == 0x0007 || zero == 0x0700 || zero == 0x0008 || zero == 0x0800 ) { - std::string msg - = Util::Format("ACR/DICOM with no preamble: (%04x)\n", zero); + std::string msg = Util::Format( + "ACR/DICOM starting at the begining of the file:(%04x)\n", zero); gdcmWarningMacro( msg.c_str() ); return Fp; } - //DICOM + //-- DICOM -- Fp->seekg(126L, std::ios::cur); char dicm[4] = {' ',' ',' ',' '}; Fp->read(dicm, (size_t)4); - if( Fp->eof() ) + if ( Fp->eof() ) { CloseFile(); return 0; } - if( memcmp(dicm, "DICM", 4) == 0 ) + if ( memcmp(dicm, "DICM", 4) == 0 ) { HasDCMPreamble = true; return Fp; } - + + // -- Neither ACR/No Preamble Dicom nor DICOMV3 file CloseFile(); - gdcmWarningMacro( "Not DICOM/ACR (missing preamble)" << Filename.c_str()); - + gdcmWarningMacro( "Neither ACR/No Preamble Dicom nor DICOMV3 file: " + << Filename.c_str()); return 0; } @@ -481,7 +628,7 @@ std::ifstream *Document::OpenFile() */ bool Document::CloseFile() { - if( Fp ) + if ( Fp ) { Fp->close(); delete Fp; @@ -545,7 +692,7 @@ void Document::LoadEntryBinArea(uint16_t group, uint16_t elem) return; BinEntry *binElement = dynamic_cast(docElement); - if( !binElement ) + if ( !binElement ) return; LoadEntryBinArea(binElement); @@ -558,11 +705,11 @@ void Document::LoadEntryBinArea(uint16_t group, uint16_t elem) */ void Document::LoadEntryBinArea(BinEntry *elem) { - if(elem->GetBinArea()) + if (elem->GetBinArea() ) return; bool openFile = !Fp; - if(openFile) + if ( openFile ) OpenFile(); size_t o =(size_t)elem->GetOffset(); @@ -570,14 +717,16 @@ void Document::LoadEntryBinArea(BinEntry *elem) size_t l = elem->GetLength(); uint8_t *a = new uint8_t[l]; - if( !a ) + if ( !a ) { - gdcmWarningMacro( "Cannot allocate BinEntry content"); + gdcmWarningMacro( "Cannot allocate BinEntry content for : " + << std::hex << elem->GetGroup() + << "|" << elem->GetElement() ); return; } Fp->read((char*)a, l); - if( Fp->fail() || Fp->eof()) + if ( Fp->fail() || Fp->eof() ) { delete[] a; return; @@ -585,7 +734,7 @@ void Document::LoadEntryBinArea(BinEntry *elem) elem->SetBinArea(a); - if(openFile) + if ( openFile ) CloseFile(); } @@ -597,7 +746,7 @@ void Document::LoadEntryBinArea(BinEntry *elem) */ void Document::LoadDocEntrySafe(DocEntry *entry) { - if(Fp) + if ( Fp ) { long PositionOnEntry = Fp->tellg(); LoadDocEntry(entry); @@ -617,11 +766,11 @@ bool Document::operator<(Document &document) // Patient Name std::string s1 = GetEntryValue(0x0010,0x0010); std::string s2 = document.GetEntryValue(0x0010,0x0010); - if(s1 < s2) + if (s1 < s2) { return true; } - else if( s1 > s2 ) + else if ( s1 > s2 ) { return false; } @@ -647,7 +796,7 @@ bool Document::operator<(Document &document) { return true; } - else if( s1 > s2 ) + else if ( s1 > s2 ) { return false; } @@ -660,7 +809,7 @@ bool Document::operator<(Document &document) { return true; } - else if( s1 > s2 ) + else if ( s1 > s2 ) { return false; } @@ -686,7 +835,7 @@ uint16_t Document::ReadInt16() { throw FormatError( "Document::ReadInt16()", " file error." ); } - if( Fp->eof() ) + if ( Fp->eof() ) { throw FormatError( "Document::ReadInt16()", "EOF." ); } @@ -708,7 +857,7 @@ uint32_t Document::ReadInt32() { throw FormatError( "Document::ReadInt32()", " file error." ); } - if( Fp->eof() ) + if ( Fp->eof() ) { throw FormatError( "Document::ReadInt32()", "EOF." ); } @@ -745,19 +894,19 @@ int Document::ComputeGroup0002Length( FileType filetype ) { gr = entry->GetGroup(); - if( gr == 0x0002 ) + if ( gr == 0x0002 ) { found0002 = true; - if( entry->GetElement() != 0x0000 ) + if ( entry->GetElement() != 0x0000 ) { vr = entry->GetVR(); - if( filetype == ExplicitVR ) + if ( filetype == ExplicitVR ) { - if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") ) + if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") || (vr == "UT") ) { - // explicit VR AND OB, OW, SQ : 4 more bytes + // explicit VR AND OB, OW, SQ, UT : 4 more bytes groupLength += 4; } } @@ -787,9 +936,9 @@ void Document::Initialize() /** * \brief Parses a DocEntrySet (Zero-level DocEntries or SQ Item DocEntries) - * @param set DocEntrySet we are going to parse ('zero level' or a SQItem) + * @param set DocEntrySet we are going to parse ('zero level' or a SQItem) * @param offset start of parsing - * @param l_max length to parse + * @param l_max length to parse (meaningless when we are in 'delimitor mode') * @param delim_mode : whether we are in 'delimitor mode' (l=0xffffff) or not */ void Document::ParseDES(DocEntrySet *set, long offset, @@ -801,7 +950,8 @@ void Document::ParseDES(DocEntrySet *set, long offset, SeqEntry *newSeqEntry; VRKey vr; bool used; - + bool delim_mode_intern = delim_mode; + bool first = true; while (true) { if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) @@ -809,23 +959,43 @@ void Document::ParseDES(DocEntrySet *set, long offset, break; } - used = true; newDocEntry = ReadNextDocEntry( ); + // Uncoment this printf line to be able to 'follow' the DocEntries + // when something *very* strange happens + + //printf( "%04x|%04x %s\n",newDocEntry->GetGroup(), + // newDocEntry->GetElement(), + // newDocEntry->GetVR().c_str() ); + if ( !newDocEntry ) { break; } - vr = newDocEntry->GetVR(); + // an Item Starter found elsewhere but the first postition + // of a SeqEntry means previous entry was a Sequence + // but we didn't get it (private Sequence + Implicit VR) + // we have to backtrack. + if ( !first && newDocEntry->IsItemStarter() ) + { + newDocEntry = Backtrack(newDocEntry); + } + else + { + PreviousDocEntry = newDocEntry; + } + + used = true; newValEntry = dynamic_cast(newDocEntry); newBinEntry = dynamic_cast(newDocEntry); - newSeqEntry = dynamic_cast(newDocEntry); - if ( newValEntry || newBinEntry ) + if ( newValEntry || newBinEntry ) { + //////////////////////////// ContentEntry if ( newBinEntry ) { + vr = newDocEntry->GetVR(); if ( Filetype == ExplicitVR && !Global::GetVR()->IsVROfBinaryRepresentable(vr) ) { @@ -837,88 +1007,100 @@ void Document::ParseDES(DocEntrySet *set, long offset, } //////////////////// BinEntry or UNKOWN VR: + // When "this" is a Document the Key is simply of the // form ( group, elem )... - if ( dynamic_cast< Document* > ( set ) ) - { - newBinEntry->SetKey( newBinEntry->GetKey() ); - } + //if ( set == this ) // ( dynamic_cast< Document* > ( set ) ) + //{ + // newBinEntry->SetKey( newBinEntry->GetKey() ); + //} // but when "this" is a SQItem, we are inserting this new // valEntry in a sequence item, and the key has the // generalized form (refer to \ref BaseTagKey): - if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) ) + + // time waste hunting + //if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) ) + //{ + // newBinEntry->SetKey( parentSQItem->GetBaseTagKey() + // + newBinEntry->GetKey() ); + //} + + if ( !set->AddEntry( newBinEntry ) ) { - newBinEntry->SetKey( parentSQItem->GetBaseTagKey() - + newBinEntry->GetKey() ); + gdcmWarningMacro( "in ParseDES : cannot add a BinEntry " + << newBinEntry->GetKey() + << " (at offset : " + << newBinEntry->GetOffset() << " )" ); + used=false; } - - LoadDocEntry( newBinEntry ); - if( !set->AddEntry( newBinEntry ) ) + else { - //Expect big troubles if here - //delete newBinEntry; - used=false; + // Load only if we can add (not a duplicate key) + LoadDocEntry( newBinEntry ); } - } + } // end BinEntry else { /////////////////////// ValEntry // When "set" is a Document, then we are at the top of the // hierarchy and the Key is simply of the form ( group, elem )... - if ( dynamic_cast< Document* > ( set ) ) - { - newValEntry->SetKey( newValEntry->GetKey() ); - } + //if ( set == this ) // ( dynamic_cast< Document* > ( set ) ) + //{ + // newValEntry->SetKey( newValEntry->GetKey() ); + //} // ...but when "set" is a SQItem, we are inserting this new // valEntry in a sequence item. Hence the key has the // generalized form (refer to \ref BaseTagKey): - if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) ) + + // time waste hunting + //if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) ) + //{ + // newValEntry->SetKey( parentSQItem->GetBaseTagKey() + // + newValEntry->GetKey() ); + //} + + if ( !set->AddEntry( newValEntry ) ) { - newValEntry->SetKey( parentSQItem->GetBaseTagKey() - + newValEntry->GetKey() ); + gdcmWarningMacro( "in ParseDES : cannot add a ValEntry " + << newValEntry->GetKey() + << " (at offset : " + << newValEntry->GetOffset() << " )" ); + used=false; + } + else + { + // Load only if we can add (not a duplicate key) + LoadDocEntry( newValEntry ); } - - LoadDocEntry( newValEntry ); - bool delimitor=newValEntry->IsItemDelimitor(); - if ( LoadMode & NO_SHADOW ) // User asked to skip, if possible, - // shadow groups ( if possible : - // whether element 0x0000 exits) + if ( newValEntry->GetElement() == 0x0000 ) // if on group length { - if ( newValEntry->GetGroup()%2 != 0 ) + if ( newValEntry->GetGroup()%2 != 0 ) // if Shadow Group { - if ( newValEntry->GetElement() == 0x0000 ) + if ( LoadMode & LD_NOSHADOW ) // if user asked to skip shad.gr { std::string strLgrGroup = newValEntry->GetValue(); int lgrGroup; if ( strLgrGroup != GDCM_UNFOUND) { lgrGroup = atoi(strLgrGroup.c_str()); - Fp->seekg(lgrGroup , std::ios::cur); + Fp->seekg(lgrGroup, std::ios::cur); used = false; + RemoveEntry( newDocEntry ); + newDocEntry = 0; continue; } } } - } - - if( !set->AddEntry( newValEntry ) ) - { - // If here expect big troubles - // delete newValEntry; //otherwise mem leak - used=false; } - if (delimitor) - { - if(!used) - delete newDocEntry; - break; - } - if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) + bool delimitor=newValEntry->IsItemDelimitor(); + + if ( (delimitor) || + (!delim_mode && ((long)(Fp->tellg())-offset) >= l_max) ) { - if(!used) + if ( !used ) delete newDocEntry; break; } @@ -929,71 +1111,96 @@ void Document::ParseDES(DocEntrySet *set, long offset, } else { - // VR = "SQ" + /////////////////////// SeqEntry : VR = "SQ" + unsigned long l = newDocEntry->GetReadLength(); - if ( l != 0 ) // don't mess the delim_mode for zero-length sequence + if ( l != 0 ) // don't mess the delim_mode for 'zero-length sequence' { if ( l == 0xffffffff ) { - delim_mode = true; + delim_mode_intern = true; } else { - delim_mode = false; + delim_mode_intern = false; } } - - if ( (LoadMode & NO_SEQ) && ! delim_mode ) // User asked to skip SQ + + if ( (LoadMode & LD_NOSHADOWSEQ) && ! delim_mode_intern ) + { + // User asked to skip SeQuences *only* if they belong to Shadow Group + if ( newDocEntry->GetGroup()%2 != 0 ) + { + Fp->seekg( l, std::ios::cur); + used = false; + continue; + } + } + if ( (LoadMode & LD_NOSEQ) && ! delim_mode_intern ) { + // User asked to skip *any* SeQuence Fp->seekg( l, std::ios::cur); used = false; continue; - } + } + // delay the dynamic cast as late as possible + newSeqEntry = dynamic_cast(newDocEntry); - // no other way to create it ... - newSeqEntry->SetDelimitorMode( delim_mode ); + // no other way to create the Delimitor ... + newSeqEntry->SetDelimitorMode( delim_mode_intern ); // At the top of the hierarchy, stands a Document. When "set" // is a Document, then we are building the first depth level. // Hence the SeqEntry we are building simply has a depth // level of one: - if ( dynamic_cast< Document* > ( set ) ) +// SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ); + if ( set == this ) // ( dynamic_cast< Document* > ( set ) ) { newSeqEntry->SetDepthLevel( 1 ); - newSeqEntry->SetKey( newSeqEntry->GetKey() ); + // newSeqEntry->SetKey( newSeqEntry->GetKey() ); } // But when "set" is already a SQItem, we are building a nested // sequence, and hence the depth level of the new SeqEntry // we are building, is one level deeper: - if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) ) + + // time waste hunting + else if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) ) { newSeqEntry->SetDepthLevel( parentSQItem->GetDepthLevel() + 1 ); - newSeqEntry->SetKey( parentSQItem->GetBaseTagKey() - + newSeqEntry->GetKey() ); + + // newSeqEntry->SetKey( parentSQItem->GetBaseTagKey() + // + newSeqEntry->GetKey() ); } if ( l != 0 ) { // Don't try to parse zero-length sequences ParseSQ( newSeqEntry, newDocEntry->GetOffset(), - l, delim_mode); + l, delim_mode_intern); } - if( !set->AddEntry( newSeqEntry ) ) + if ( !set->AddEntry( newSeqEntry ) ) { + gdcmWarningMacro( "in ParseDES : cannot add a SeqEntry " + << newSeqEntry->GetKey() + << " (at offset : " + << newSeqEntry->GetOffset() << " )" ); used = false; } - - if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) + + if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) { - if( !used ) - delete newDocEntry; - break; + if ( !used ) + delete newDocEntry; + break; } - } + } // end SeqEntry : VR = "SQ" - if( !used ) + if ( !used ) + { delete newDocEntry; - } + } + first = false; + } // end While } /** @@ -1015,9 +1222,10 @@ void Document::ParseSQ( SeqEntry *seqEntry, if ( !newDocEntry ) { // FIXME Should warn user + gdcmWarningMacro("in ParseSQ : should never get here!"); break; } - if( delim_mode ) + if ( delim_mode ) { if ( newDocEntry->IsSequenceDelimitor() ) { @@ -1032,12 +1240,14 @@ void Document::ParseSQ( SeqEntry *seqEntry, } // create the current SQItem SQItem *itemSQ = new SQItem( seqEntry->GetDepthLevel() ); +/* std::ostringstream newBase; newBase << seqEntry->GetKey() << "/" << SQItemNumber << "#"; itemSQ->SetBaseTagKey( newBase.str() ); +*/ unsigned int l = newDocEntry->GetReadLength(); if ( l == 0xffffffff ) @@ -1054,7 +1264,9 @@ void Document::ParseSQ( SeqEntry *seqEntry, delete newDocEntry; Fp->seekg(offsetStartCurrentSQItem, std::ios::beg); // fill up the current SQItem, starting at the beginning of fff0,e000 + ParseDES(itemSQ, offsetStartCurrentSQItem, l+8, dlm_mod); + offsetStartCurrentSQItem = Fp->tellg(); // end try ----------------- @@ -1068,11 +1280,48 @@ void Document::ParseSQ( SeqEntry *seqEntry, } /** - * \brief Loads the element content if its length doesn't exceed - * the value specified with Document::SetMaxSizeLoadEntry() + * \brief When a private Sequence + Implicit VR is encountered + * we cannot guess it's a Sequence till we find the first + * Item Starter. We then backtrack to do the job. + * @param docEntry Item Starter that warned us + */ +DocEntry *Document::Backtrack(DocEntry *docEntry) +{ + // delete the Item Starter, built erroneously out of any Sequence + // it's not yet in the HTable/chained list + delete docEntry; + + // Get all info we can from PreviousDocEntry + uint16_t group = PreviousDocEntry->GetGroup(); + uint16_t elem = PreviousDocEntry->GetElement(); + uint32_t lgt = PreviousDocEntry->GetLength(); + long offset = PreviousDocEntry->GetOffset(); + + gdcmWarningMacro( "Backtrack :" << std::hex << group + << "|" << elem + << " at offset " << offset ); + RemoveEntry( PreviousDocEntry ); + + // forge the Seq Entry + DocEntry *newEntry = NewSeqEntry(group, elem); + newEntry->SetLength(lgt); + newEntry->SetOffset(offset); + + // Move back to the beginning of the Sequence + Fp->seekg( 0, std::ios::beg); + Fp->seekg(offset, std::ios::cur); + +return newEntry; +} + +/** + * \brief Loads (or not) the element content depending if its length exceeds + * or not the value specified with Document::SetMaxSizeLoadEntry() * @param entry Header Entry (Dicom Element) to be dealt with + * @param forceLoad wheter we want to load its content even if its length + * exceeds the value specified with Document::SetMaxSizeLoadEntry() */ -void Document::LoadDocEntry(DocEntry *entry) +void Document::LoadDocEntry(DocEntry *entry, bool forceLoad) { uint16_t group = entry->GetGroup(); std::string vr = entry->GetVR(); @@ -1084,7 +1333,7 @@ void Document::LoadDocEntry(DocEntry *entry) // (fffe e000) tells us an Element is beginning // (fffe e00d) tells us an Element just ended // (fffe e0dd) tells us the current SeQuence just ended - if( group == 0xfffe ) + if ( group == 0xfffe ) { // NO more value field for SQ ! return; @@ -1098,42 +1347,45 @@ void Document::LoadDocEntry(DocEntry *entry) } // The elements whose length is bigger than the specified upper bound - // are not loaded. Instead we leave a short notice of the offset of + // are not loaded. Instead we leave a short notice on the offset of // the element content and it's length. std::ostringstream s; - if (length > MaxSizeLoadEntry) - { - if (BinEntry *binEntryPtr = dynamic_cast< BinEntry* >(entry) ) - { - //s << "gdcm::NotLoaded (BinEntry)"; - s << GDCM_NOTLOADED; - s << " Address:" << (long)entry->GetOffset(); - s << " Length:" << entry->GetLength(); - s << " x(" << std::hex << entry->GetLength() << ")"; - binEntryPtr->SetValue(s.str()); - } - // Be carefull : a BinEntry IS_A ValEntry ... - else if (ValEntry *valEntryPtr = dynamic_cast< ValEntry* >(entry) ) - { - // s << "gdcm::NotLoaded. (ValEntry)"; - s << GDCM_NOTLOADED; - s << " Address:" << (long)entry->GetOffset(); - s << " Length:" << entry->GetLength(); - s << " x(" << std::hex << entry->GetLength() << ")"; - valEntryPtr->SetValue(s.str()); - } - else + + if (!forceLoad) + { + if (length > MaxSizeLoadEntry) { - // fusible - gdcmErrorMacro( "MaxSizeLoadEntry exceeded, neither a BinEntry " - << "nor a ValEntry ?! Should never print that !" ); - } + if (BinEntry *binEntryPtr = dynamic_cast< BinEntry* >(entry) ) + { + s << GDCM_NOTLOADED; + s << " Ad.:" << (long)entry->GetOffset(); + s << " x(" << std::hex << entry->GetOffset() << ")"; + s << std::dec; + s << " Lgt:" << entry->GetLength(); + s << " x(" << std::hex << entry->GetLength() << ")"; + binEntryPtr->SetValue(s.str()); + } + else if (ValEntry *valEntryPtr = dynamic_cast< ValEntry* >(entry) ) + { + s << GDCM_NOTLOADED; + s << " Address:" << (long)entry->GetOffset(); + s << " Length:" << entry->GetLength(); + s << " x(" << std::hex << entry->GetLength() << ")"; + valEntryPtr->SetValue(s.str()); + } + else + { + // fusible + gdcmErrorMacro( "MaxSizeLoadEntry exceeded, neither a BinEntry " + << "nor a ValEntry ?! Should never print that !" ); + } - // to be sure we are at the end of the value ... - Fp->seekg((long)entry->GetOffset()+(long)entry->GetLength(), - std::ios::beg); - return; + // to be sure we are at the end of the value ... + Fp->seekg((long)entry->GetOffset()+(long)entry->GetLength(), + std::ios::beg); + return; + } } // When we find a BinEntry not very much can be done : @@ -1150,7 +1402,7 @@ void Document::LoadDocEntry(DocEntry *entry) uint32_t NewInt; int nbInt; // When short integer(s) are expected, read and convert the following - // n *two characters properly i.e. consider them as short integers as + // (n * 2) characters properly i.e. consider them as short integers as // opposed to strings. // Elements with Value Multiplicity > 1 // contain a set of integers (not a single one) @@ -1199,11 +1451,11 @@ void Document::LoadDocEntry(DocEntry *entry) str[length] = '\0'; //this is only useful when length is odd // Special DicomString call to properly handle \0 and even length std::string newValue; - if( length % 2 ) + if ( length % 2 ) { newValue = Util::DicomString(str, length+1); gdcmWarningMacro("Warning: bad length: " << length << - ",For string :" << newValue.c_str()); + " For string :" << newValue.c_str()); // Since we change the length of string update it length //entry->SetReadLength(length+1); } @@ -1217,12 +1469,17 @@ void Document::LoadDocEntry(DocEntry *entry) { if ( Fp->fail() || Fp->eof()) { - gdcmWarningMacro("Unread element value"); + if ( Fp->fail() ) + gdcmWarningMacro("--> fail"); + + gdcmWarningMacro("Unread element value " << valEntry->GetKey() + << " lgt : " << valEntry->GetReadLength() + << " at " << std::hex << valEntry->GetOffset()); valEntry->SetValue(GDCM_UNREAD); return; } - if( vr == "UI" ) + if ( vr == "UI" ) { // Because of correspondance with the VR dic valEntry->SetValue(newValue); @@ -1234,7 +1491,9 @@ void Document::LoadDocEntry(DocEntry *entry) } else { - gdcmErrorMacro( "Should have a ValEntry, here !"); + gdcmWarningMacro("Should have a ValEntry, here ! " << valEntry->GetKey() + << " lgt : " << valEntry->GetReadLength() + << " at " << std::hex << valEntry->GetOffset()); } } @@ -1250,7 +1509,7 @@ void Document::FindDocEntryLength( DocEntry *entry ) if ( Filetype == ExplicitVR && !entry->IsImplicitVR() ) { - if ( vr == "OB" || vr == "OW" || vr == "SQ" || vr == "UN" ) + if ( vr == "OB" || vr == "OW" || vr == "SQ" || vr == "UT" || vr == "UN" ) { // The following reserved two bytes (see PS 3.5-2003, section // "7.1.2 Data element structure with explicit vr", p 27) must be @@ -1400,7 +1659,7 @@ std::string Document::FindDocEntryVR() Fp->read (vr, (size_t)2); vr[2] = 0; - if( !CheckDocEntryVR(vr) ) + if ( !CheckDocEntryVR(vr) ) { Fp->seekg(positionOnEntry, std::ios::beg); return GDCM_UNKNOWN; @@ -1448,14 +1707,14 @@ std::string Document::GetDocEntryValue(DocEntry *entry) // Elements with Value Multiplicity > 1 // contain a set of short integers (not a single one) - if( vr == "US" || vr == "SS" ) + if ( vr == "US" || vr == "SS" ) { uint16_t newInt16; nbInt = length / 2; for (int i=0; i < nbInt; i++) { - if( i != 0 ) + if ( i != 0 ) { s << '\\'; } @@ -1471,14 +1730,14 @@ std::string Document::GetDocEntryValue(DocEntry *entry) // as usual for standard multivaluated filels // Elements with Value Multiplicity > 1 // contain a set of integers (not a single one) - else if( vr == "UL" || vr == "SL" ) + else if ( vr == "UL" || vr == "SL" ) { uint32_t newInt32; nbInt = length / 4; for (int i=0; i < nbInt; i++) { - if( i != 0) + if ( i != 0) { s << '\\'; } @@ -1571,9 +1830,15 @@ void Document::SkipDocEntry(DocEntry *entry) */ void Document::SkipToNextDocEntry(DocEntry *currentDocEntry) { - Fp->seekg((long)(currentDocEntry->GetOffset()), std::ios::beg); + int l = currentDocEntry->GetReadLength(); + if ( l == -1 ) // length = 0xffff shouldn't appear here ... + // ... but PMS imagers happen ! + return; + Fp->seekg((long)(currentDocEntry->GetOffset()), std::ios::beg); if (currentDocEntry->GetGroup() != 0xfffe) // for fffe pb + { Fp->seekg( (long)(currentDocEntry->GetReadLength()),std::ios::cur); + } } /** @@ -1605,7 +1870,7 @@ void Document::FixDocEntryFoundLength(DocEntry *entry, // Allthough not recent many such GE corrupted images are still present // on Creatis hard disks. Hence this fix shall remain when such images // are no longer in use (we are talking a few years, here)... - // Note: XMedCom probably uses such a trick since it is able to read + // Note: XMedCon probably uses such a trick since it is able to read // those pesky GE images ... if ( foundLength == 13) { @@ -1635,12 +1900,12 @@ void Document::FixDocEntryFoundLength(DocEntry *entry, //////// We encountered a 'delimiter' element i.e. a tag of the form // "fffe|xxxx" which is just a marker. Delimiters length should not be // taken into account. - else if( gr == 0xfffe ) + else if ( gr == 0xfffe ) { // According to the norm, fffe|0000 shouldn't exist. BUT the Philips // image gdcmData/gdcm-MR-PHILIPS-16-Multi-Seq.dcm happens to // causes extra troubles... - if( entry->GetElement() != 0x0000 ) + if ( entry->GetElement() != 0x0000 ) { foundLength = 0; } @@ -1703,12 +1968,7 @@ bool Document::IsDocEntryAnInteger(DocEntry *entry) * true when we hope ours assuptions are OK */ bool Document::CheckSwap() -{ - // The only guaranted way of finding the swap code is to find a - // group tag since we know it's length has to be of four bytes i.e. - // 0x00000004. Finding the swap code in then straigthforward. Trouble - // occurs when we can't find such group... - +{ uint32_t s32; uint16_t s16; @@ -1723,7 +1983,7 @@ bool Document::CheckSwap() Fp->read(deb, 256); char *entCur = deb + 128; - if( memcmp(entCur, "DICM", (size_t)4) == 0 ) + if ( memcmp(entCur, "DICM", (size_t)4) == 0 ) { gdcmWarningMacro( "Looks like DICOM Version3 (preamble + DCM)" ); @@ -1747,11 +2007,11 @@ bool Document::CheckSwap() // even if elem 0002,0010 (Transfer Syntax) tells us the file is // *Implicit* VR (see former 'gdcmData/icone.dcm') - if( memcmp(entCur, "UL", (size_t)2) == 0 || - memcmp(entCur, "OB", (size_t)2) == 0 || - memcmp(entCur, "UI", (size_t)2) == 0 || - memcmp(entCur, "CS", (size_t)2) == 0 ) // CS, to remove later - // when Write DCM *adds* + if ( memcmp(entCur, "UL", (size_t)2) == 0 || + memcmp(entCur, "OB", (size_t)2) == 0 || + memcmp(entCur, "UI", (size_t)2) == 0 || + memcmp(entCur, "CS", (size_t)2) == 0 ) // CS, to remove later + // when Write DCM *adds* // FIXME // Use Document::dicom_vr to test all the possibilities // instead of just checking for UL, OB and UI !? group 0000 @@ -1779,19 +2039,56 @@ bool Document::CheckSwap() // Position the file position indicator at first tag // (i.e. after the file preamble and the "DICM" string). - Fp->seekg(0, std::ios::beg); + + Fp->seekg(0, std::ios::beg); // FIXME : Is it usefull? + Fp->seekg ( 132L, std::ios::beg); return true; - } // End of DicomV3 + } // ------------------------------- End of DicomV3 ---------------- // Alas, this is not a DicomV3 file and whatever happens there is no file // preamble. We can reset the file position indicator to where the data // is (i.e. the beginning of the file). - gdcmWarningMacro( "Not a DICOM Version3 file"); + + gdcmWarningMacro( "Not a Kosher DICOM Version3 file (no preamble)"); + Fp->seekg(0, std::ios::beg); + // Let's check 'No Preamble Dicom File' : + // Should start with group 0x0002 + // and be Explicit Value Representation + + s16 = *((uint16_t *)(deb)); + SwapCode = 0; + switch ( s16 ) + { + case 0x0002 : + SwapCode = 1234; + entCur = deb + 4; + break; + case 0x0200 : + SwapCode = 4321; + entCur = deb + 6; + } + + if ( SwapCode != 0 ) + { + if ( memcmp(entCur, "UL", (size_t)2) == 0 || + memcmp(entCur, "OB", (size_t)2) == 0 || + memcmp(entCur, "UI", (size_t)2) == 0 || + memcmp(entCur, "SH", (size_t)2) == 0 || + memcmp(entCur, "AE", (size_t)2) == 0 || + memcmp(entCur, "OB", (size_t)2) == 0 ) + { + Filetype = ExplicitVR; + gdcmWarningMacro( "Group 0002 : Explicit Value Representation"); + return true; + } + } +// ------------------------------- End of 'No Preamble' DicomV3 ------------- + // Our next best chance would be to be considering a 'clean' ACR/NEMA file. - // By clean we mean that the length of the first tag is written down. + // By clean we mean that the length of the first group is written down. // If this is the case and since the length of the first group HAS to be // four (bytes), then determining the proper swap code is straightforward. @@ -1800,7 +2097,6 @@ bool Document::CheckSwap() // representation of a 32 bits integer. Hence the following dirty // trick : s32 = *((uint32_t *)(entCur)); - switch( s32 ) { case 0x00040000 : @@ -1874,7 +2170,8 @@ bool Document::CheckSwap() */ void Document::SwitchByteSwapCode() { - gdcmWarningMacro( "Switching Byte Swap code from "<< SwapCode); + gdcmWarningMacro( "Switching Byte Swap code from "<< SwapCode + << " at :" <tellg() ); if ( SwapCode == 1234 ) { SwapCode = 4321; @@ -1912,11 +2209,11 @@ void Document::SetMaxSizeLoadEntry(long newSize) } /** - * \brief Read the next tag but WITHOUT loading it's value + * \brief Read the next tag WITHOUT loading it's value * (read the 'Group Number', the 'Element Number', * gets the Dict Entry * gets the VR, gets the length, gets the offset value) - * @return On succes the newly created DocEntry, NULL on failure. + * @return On succes : the newly created DocEntry, NULL on failure. */ DocEntry *Document::ReadNextDocEntry() { @@ -1945,37 +2242,40 @@ DocEntry *Document::ReadNextDocEntry() std::string vr = FindDocEntryVR(); std::string realVR = vr; - if( vr == GDCM_UNKNOWN) + if ( vr == GDCM_UNKNOWN ) { if ( elem == 0x0000 ) // Group Length realVR = "UL"; // must be UL else { DictEntry *dictEntry = GetDictEntry(group,elem); - if( dictEntry ) + if ( dictEntry ) + { realVR = dictEntry->GetVR(); + } } } DocEntry *newEntry; - if( Global::GetVR()->IsVROfSequence(realVR) ) + if ( Global::GetVR()->IsVROfSequence(realVR) ) newEntry = NewSeqEntry(group, elem); - else if( Global::GetVR()->IsVROfStringRepresentable(realVR) ) + else if ( Global::GetVR()->IsVROfStringRepresentable(realVR) ) newEntry = NewValEntry(group, elem,vr); else newEntry = NewBinEntry(group, elem,vr); - if( vr == GDCM_UNKNOWN ) + if ( vr == GDCM_UNKNOWN ) { - if( Filetype == ExplicitVR ) + if ( Filetype == ExplicitVR ) { // We thought this was explicit VR, but we end up with an // implicit VR tag. Let's backtrack. if ( newEntry->GetGroup() != 0xfffe ) { std::string msg; - msg = Util::Format("Entry (%04x,%04x) should be Explicit VR\n", - newEntry->GetGroup(), newEntry->GetElement()); + int offset = Fp->tellg(); + msg = Util::Format("Entry (%04x,%04x) at 0x(%x) should be Explicit VR\n", + newEntry->GetGroup(), newEntry->GetElement(), offset ); gdcmWarningMacro( msg.c_str() ); } } @@ -1994,14 +2294,14 @@ DocEntry *Document::ReadNextDocEntry() } newEntry->SetOffset(Fp->tellg()); - + return newEntry; } /** * \brief Handle broken private tag from Philips NTSCAN - * where the endianess is being switch to BigEndian for no - * apparent reason + * where the endianess is being switched to BigEndian + * for no apparent reason * @return no return */ void Document::HandleBrokenEndian(uint16_t &group, uint16_t &elem)