X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmDocument.cxx;h=0b3445753fc65c5e055d1b5ed3d52cab90280966;hb=9c9ce3a986149341c8203e9473b3714bdeb1ab39;hp=6bf0b28121803837925df0f63985cd1e33e17869;hpb=5632bd68b349f72ddae6d5676193d9b03d50adb2;p=gdcm.git diff --git a/src/gdcmDocument.cxx b/src/gdcmDocument.cxx index 6bf0b281..0b344575 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/07/07 13:11:38 $ - Version: $Revision: 1.260 $ + Date: $Date: 2005/08/29 14:02:03 $ + Version: $Revision: 1.271 $ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de l'Image). All rights reserved. See Doc/License.txt or @@ -62,11 +62,13 @@ Document::Document() // Load will set it to true if sucessfull Group0002Parsed = false; IsDocumentAlreadyLoaded = false; + IsDocumentModified = true; LoadMode = 0x00000000; // default : load everything, later + SetFileName(""); } /** - * \brief Constructor (not to break the API) + * \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 ) @@ -83,8 +85,10 @@ Document::Document( std::string const &fileName ) // Load will set it to true if sucessfull IsDocumentAlreadyLoaded = false; + IsDocumentModified = true; - Load(fileName); + SetFileName(fileName); + Load( ); } /** * \brief Canonical destructor. @@ -99,35 +103,57 @@ Document::~Document () // Public /** - * \brief Loader + * \brief Loader. use SetLoadMode(), SetFileName() before ! + * @return false if file cannot be open or no swap info was found, + * or no tag was found. + */ +bool Document::Load( ) +{ + 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 ) { - if ( IsDocumentAlreadyLoaded ) - { - /* - 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 ); + Filename = fileName; + return DoTheLoadingDocumentJob( ); +} + +/** + * \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(); - } - - Filename = fileName; + ClearEntry(); Fp = 0; if ( !OpenFile() ) @@ -232,6 +258,37 @@ bool Document::Load( std::string const &fileName ) } } + // 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(); // ---------------------------- @@ -257,10 +314,22 @@ bool 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 */ @@ -650,7 +719,9 @@ void Document::LoadEntryBinArea(BinEntry *elem) uint8_t *a = new uint8_t[l]; if ( !a ) { - gdcmWarningMacro( "Cannot allocate BinEntry content"); + gdcmWarningMacro( "Cannot allocate BinEntry content for : " + << std::hex << elem->GetGroup() + << "|" << elem->GetElement() ); return; } @@ -880,7 +951,7 @@ void Document::ParseDES(DocEntrySet *set, long offset, VRKey vr; bool used; bool delim_mode_intern = delim_mode; - + bool first = true; while (true) { if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) @@ -890,11 +961,31 @@ void Document::ParseDES(DocEntrySet *set, long offset, 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; } + // 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); @@ -919,23 +1010,27 @@ void Document::ParseDES(DocEntrySet *set, long offset, // 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 ) ) - { - newBinEntry->SetKey( parentSQItem->GetBaseTagKey() - + newBinEntry->GetKey() ); - } + // time waste hunting + //if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) ) + //{ + // newBinEntry->SetKey( parentSQItem->GetBaseTagKey() + // + newBinEntry->GetKey() ); + //} + if ( !set->AddEntry( newBinEntry ) ) { gdcmWarningMacro( "in ParseDES : cannot add a BinEntry " - << newBinEntry->GetKey() ); + << newBinEntry->GetKey() + << " (at offset : " + << newBinEntry->GetOffset() << " )" ); used=false; } else @@ -950,26 +1045,40 @@ void Document::ParseDES(DocEntrySet *set, long offset, // 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 ); } - 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 & NO_SHADOW ) // if user asked to skip shad.gr { std::string strLgrGroup = newValEntry->GetValue(); int lgrGroup; @@ -978,27 +1087,17 @@ void Document::ParseDES(DocEntrySet *set, long offset, lgrGroup = atoi(strLgrGroup.c_str()); Fp->seekg(lgrGroup, std::ios::cur); used = false; + RemoveEntry( newDocEntry ); + newDocEntry = 0; continue; } } } - } - - if ( !set->AddEntry( newValEntry ) ) - { - gdcmWarningMacro( "in ParseDES : cannot add a ValEntry " - << newValEntry->GetKey() ); - used=false; - } - else - { - // Load only if we can add (not a duplicate key) - LoadDocEntry( newValEntry ); } bool delimitor=newValEntry->IsItemDelimitor(); - if ( delimitor || + if ( (delimitor) || (!delim_mode && ((long)(Fp->tellg())-offset) >= l_max) ) { if ( !used ) @@ -1054,19 +1153,23 @@ void Document::ParseDES(DocEntrySet *set, long offset, // 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 ) @@ -1078,20 +1181,25 @@ void Document::ParseDES(DocEntrySet *set, long offset, if ( !set->AddEntry( newSeqEntry ) ) { gdcmWarningMacro( "in ParseDES : cannot add a SeqEntry " - << newSeqEntry->GetKey() ); + << 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; + delete newDocEntry; + break; } } // end SeqEntry : VR = "SQ" if ( !used ) + { delete newDocEntry; + } + first = false; } // end While } @@ -1132,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 ) @@ -1170,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(); @@ -1204,37 +1351,41 @@ void Document::LoadDocEntry(DocEntry *entry) // the element content and it's length. std::ostringstream s; - if (length > MaxSizeLoadEntry) - { - 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 + + 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 : @@ -1679,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); + } } /** @@ -2093,7 +2250,9 @@ DocEntry *Document::ReadNextDocEntry() { DictEntry *dictEntry = GetDictEntry(group,elem); if ( dictEntry ) + { realVR = dictEntry->GetVR(); + } } } @@ -2135,7 +2294,7 @@ DocEntry *Document::ReadNextDocEntry() } newEntry->SetOffset(Fp->tellg()); - + return newEntry; }