X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmDocument.cxx;h=d10b222857a8bf2b6c160b1a999d403117d2e990;hb=03acf3c119c6657129b8aeae8cb2205e481a105b;hp=2d595c5b09afee99f3d017256e957c8f8bb03e7b;hpb=684a3fbcd85dd433f02b9bb873a9c0a7af759d02;p=gdcm.git diff --git a/src/gdcmDocument.cxx b/src/gdcmDocument.cxx index 2d595c5b..d10b2228 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/01/06 09:34:58 $ - Version: $Revision: 1.153 $ + Date: $Date: 2005/01/07 08:46:18 $ + Version: $Revision: 1.162 $ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de l'Image). All rights reserved. See Doc/License.txt or @@ -47,7 +47,7 @@ namespace gdcm static const char *TransferSyntaxStrings[] = { // Implicit VR Little Endian "1.2.840.10008.1.2", - // Implicit VR Little Endian DLX G.E? + // Implicit VR Big Endian DLX G.E? "1.2.840.113619.5.2", // Explicit VR Little Endian "1.2.840.10008.1.2.1", @@ -78,7 +78,7 @@ static const char *TransferSyntaxStrings[] = { // Unknown "Unknown Transfer Syntax" }; - + //----------------------------------------------------------------------------- // Refer to Document::CheckSwap() //const unsigned int Document::HEADER_LENGTH_TO_READ = 256; @@ -94,7 +94,7 @@ const unsigned int Document::MAX_SIZE_PRINT_ELEMENT_VALUE = 0x7fffffff; * \brief constructor * @param filename file to be opened for parsing */ -Document::Document( std::string const & filename ) : ElementSet(-1) +Document::Document( std::string const &filename ) : ElementSet(-1) { SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE); Filename = filename; @@ -217,7 +217,7 @@ Document::~Document () * \brief Prints The Dict Entries of THE public Dicom Dictionary * @return */ -void Document::PrintPubDict(std::ostream & os) +void Document::PrintPubDict(std::ostream &os) { RefPubDict->SetPrintLevel(PrintLevel); RefPubDict->Print(os); @@ -227,7 +227,7 @@ void Document::PrintPubDict(std::ostream & os) * \brief Prints The Dict Entries of THE shadow Dicom Dictionary * @return */ -void Document::PrintShaDict(std::ostream & os) +void Document::PrintShaDict(std::ostream &os) { RefShaDict->SetPrintLevel(PrintLevel); RefShaDict->Print(os); @@ -238,7 +238,7 @@ void Document::PrintShaDict(std::ostream & os) /** * \brief Get the public dictionary used */ -Dict* Document::GetPubDict() +Dict *Document::GetPubDict() { return RefPubDict; } @@ -246,14 +246,14 @@ Dict* Document::GetPubDict() /** * \brief Get the shadow dictionary used */ -Dict* Document::GetShaDict() +Dict *Document::GetShaDict() { return RefShaDict; } /** * \brief Set the shadow dictionary used - * \param dict dictionary to use in shadow + * @param dict dictionary to use in shadow */ bool Document::SetShaDict(Dict *dict) { @@ -263,9 +263,9 @@ bool Document::SetShaDict(Dict *dict) /** * \brief Set the shadow dictionary used - * \param dictName name of the dictionary to use in shadow + * @param dictName name of the dictionary to use in shadow */ -bool Document::SetShaDict(DictKey const & dictName) +bool Document::SetShaDict(DictKey const &dictName) { RefShaDict = Global::GetDicts()->GetDict(dictName); return !RefShaDict; @@ -314,7 +314,7 @@ TransferSyntaxType Document::GetTransferSyntax() // The entry might be present but not loaded (parsing and loading // happen at different stages): try loading and proceed with check... LoadDocEntrySafe(entry); - if (ValEntry* valEntry = dynamic_cast< ValEntry* >(entry) ) + if (ValEntry *valEntry = dynamic_cast< ValEntry* >(entry) ) { std::string transfer = valEntry->GetValue(); // The actual transfer (as read from disk) might be padded. We @@ -415,7 +415,7 @@ FileType Document::GetFileType() * checks the preamble when existing. * @return The FILE pointer on success. */ -std::ifstream* Document::OpenFile() +std::ifstream *Document::OpenFile() { if (Filename.length() == 0) { @@ -503,7 +503,7 @@ bool Document::CloseFile() * (ACR-NEMA, ExplicitVR, ImplicitVR) * \return Always true. */ -void Document::WriteContent(std::ofstream* fp, FileType filetype) +void Document::WriteContent(std::ofstream *fp, FileType filetype) { /// \todo move the following lines (and a lot of others, to be written) /// to a future function CheckAndCorrectHeader @@ -535,7 +535,7 @@ void Document::WriteContent(std::ofstream* fp, FileType filetype) } /** - * \brief Modifies the value of a given Header Entry (Dicom Element) + * \brief Modifies the value of a given Doc Entry (Dicom Element) * when it exists. Create it with the given value when unexistant. * @param value (string) Value to be set * @param group Group number of the Entry @@ -544,79 +544,53 @@ void Document::WriteContent(std::ofstream* fp, FileType filetype) * \return pointer to the modified/created Header Entry (NULL when creation * failed). */ -ValEntry* Document::ReplaceOrCreateByNumber( - std::string const & value, - uint16_t group, - uint16_t elem, - TagName const & vr ) -{ - ValEntry* valEntry = 0; - DocEntry* currentEntry = GetDocEntryByNumber( group, elem); +ValEntry *Document::ReplaceOrCreateByNumber(std::string const &value, + uint16_t group, + uint16_t elem, + TagName const &vr ) +{ + ValEntry *valEntry = 0; + DocEntry *currentEntry = GetDocEntryByNumber( group, elem); - if (!currentEntry) + if (currentEntry) { - // check if (group,element) DictEntry exists - // if it doesn't, create an entry in DictSet::VirtualEntry - // and use it + valEntry = dynamic_cast< ValEntry* >(currentEntry); - // Find out if the tag we received is in the dictionaries: - Dict *pubDict = Global::GetDicts()->GetDefaultPubDict(); - DictEntry* dictEntry = pubDict->GetDictEntryByNumber(group, elem); - if (!dictEntry) - { - currentEntry = NewDocEntryByNumber(group, elem, vr); - } - else - { - currentEntry = NewDocEntryByNumber(group, elem); - } + // Verify the VR + if( valEntry ) + if( valEntry->GetVR()!=vr ) + valEntry=NULL; - if (!currentEntry) + // if currentEntry doesn't correspond to the requested valEntry + if( !valEntry) { - dbg.Verbose(0, "Document::ReplaceOrCreateByNumber: call to" - " NewDocEntryByNumber failed."); - return NULL; + if (!RemoveEntry(currentEntry)) + { + dbg.Verbose(0, "Document::ReplaceOrCreateByNumber: removal" + " of previous DocEntry failed."); + + return NULL; + } } + } - valEntry = new ValEntry(currentEntry); - delete currentEntry; + // Create a new valEntry if necessary + if (!valEntry) + { + valEntry = NewValEntryByNumber(group, elem, vr); if ( !AddEntry(valEntry)) { - delete valEntry; dbg.Verbose(0, "Document::ReplaceOrCreateByNumber: AddEntry" " failed allthough this is a creation."); + + delete valEntry; return NULL; } } - else - { - valEntry = dynamic_cast< ValEntry* >(currentEntry); - if ( !valEntry ) // Euuuuh? It wasn't a ValEntry - // then we change it to a ValEntry ? - // Shouldn't it be considered as an error ? - { - // We need to promote the DocEntry to a ValEntry: - valEntry = new ValEntry(currentEntry); - if (!RemoveEntry(currentEntry)) - { - delete valEntry; - dbg.Verbose(0, "Document::ReplaceOrCreateByNumber: removal" - " of previous DocEntry failed."); - return NULL; - } - if ( !AddEntry(valEntry)) - { - delete valEntry; - dbg.Verbose(0, "Document::ReplaceOrCreateByNumber: adding" - " promoted ValEntry failed."); - return NULL; - } - } - } - - SetEntryByNumber(value, group, elem); + // Set the binEntry value + SetEntry(value, valEntry); return valEntry; } @@ -627,75 +601,58 @@ ValEntry* Document::ReplaceOrCreateByNumber( * @param binArea (binary) value to be set * @param Group Group number of the Entry * @param Elem Element number of the Entry + * @param vr V(alue) R(epresentation) of the Entry -if private Entry- * \return pointer to the modified/created Header Entry (NULL when creation * failed). */ -BinEntry* Document::ReplaceOrCreateByNumber( - uint8_t* binArea, - int lgth, - uint16_t group, - uint16_t elem, - TagName const & vr ) +BinEntry *Document::ReplaceOrCreateByNumber(uint8_t *binArea, + int lgth, + uint16_t group, + uint16_t elem, + TagName const &vr ) { - BinEntry* binEntry = 0; - DocEntry* currentEntry = GetDocEntryByNumber( group, elem); - if (!currentEntry) - { + BinEntry *binEntry = 0; + DocEntry *currentEntry = GetDocEntryByNumber( group, elem); - // check if (group,element) DictEntry exists - // if it doesn't, create an entry in DictSet::VirtualEntry - // and use it - - // Find out if the tag we received is in the dictionaries: - Dict *pubDict = Global::GetDicts()->GetDefaultPubDict(); - DictEntry *dictEntry = pubDict->GetDictEntryByNumber(group, elem); - - if (!dictEntry) - { - currentEntry = NewDocEntryByNumber(group, elem, vr); - } - else - { - currentEntry = NewDocEntryByNumber(group, elem); - } - if (!currentEntry) - { - dbg.Verbose(0, "Document::ReplaceOrCreateByNumber: call to" - " NewDocEntryByNumber failed."); - return NULL; - } - binEntry = new BinEntry(currentEntry); - if ( !AddEntry(binEntry)) - { - dbg.Verbose(0, "Document::ReplaceOrCreateByNumber: AddEntry" - " failed allthough this is a creation."); - } - delete currentEntry; - } - else + // Verify the currentEntry + if (currentEntry) { binEntry = dynamic_cast< BinEntry* >(currentEntry); - if ( !binEntry ) // Euuuuh? It wasn't a BinEntry - // then we change it to a BinEntry ? - // Shouldn't it be considered as an error ? + + // Verify the VR + if( binEntry ) + if( binEntry->GetVR()!=vr ) + binEntry=NULL; + + // if currentEntry doesn't correspond to the requested valEntry + if( !binEntry) { - // We need to promote the DocEntry to a BinEntry: - binEntry = new BinEntry(currentEntry); if (!RemoveEntry(currentEntry)) { dbg.Verbose(0, "Document::ReplaceOrCreateByNumber: removal" " of previous DocEntry failed."); + return NULL; } - if ( !AddEntry(binEntry)) - { - dbg.Verbose(0, "Document::ReplaceOrCreateByNumber: adding" - " promoted BinEntry failed."); - return NULL; - } } } + // Create a new binEntry if necessary + if (!binEntry) + { + binEntry = NewBinEntryByNumber(group, elem, vr); + + if ( !AddEntry(binEntry)) + { + dbg.Verbose(0, "Document::ReplaceOrCreateByNumber: AddEntry" + " failed allthough this is a creation."); + + delete binEntry; + return NULL; + } + } + + // Set the binEntry value uint8_t *tmpArea; if (lgth>0 && binArea) { @@ -706,7 +663,7 @@ BinEntry* Document::ReplaceOrCreateByNumber( { tmpArea = 0; } - if (!SetEntryByNumber(tmpArea, lgth, group, elem)) + if (!SetEntry(tmpArea,lgth,binEntry)) { if (tmpArea) { @@ -717,7 +674,6 @@ BinEntry* Document::ReplaceOrCreateByNumber( return binEntry; } - /* * \brief Modifies the value of a given Header Entry (Dicom Element) * when it exists. Create it when unexistant. @@ -726,22 +682,50 @@ BinEntry* Document::ReplaceOrCreateByNumber( * \return pointer to the modified/created SeqEntry (NULL when creation * failed). */ -SeqEntry* Document::ReplaceOrCreateByNumber( uint16_t group, uint16_t elem) +SeqEntry *Document::ReplaceOrCreateByNumber( uint16_t group, uint16_t elem) { - SeqEntry* b = 0; - DocEntry* a = GetDocEntryByNumber( group, elem); - if (!a) + SeqEntry *seqEntry = 0; + DocEntry *currentEntry = GetDocEntryByNumber( group, elem); + + // Verify the currentEntry + if (currentEntry) + { + seqEntry = dynamic_cast< SeqEntry* >(currentEntry); + + // Verify the VR + if( seqEntry ) + if( seqEntry->GetVR()!="SQ" ) + seqEntry=NULL; + + // if currentEntry doesn't correspond to the requested valEntry + if( !seqEntry) + { + if (!RemoveEntry(currentEntry)) + { + dbg.Verbose(0, "Document::ReplaceOrCreateByNumber: removal" + " of previous DocEntry failed."); + + return NULL; + } + } + } + + // Create a new seqEntry if necessary + if (!seqEntry) { - a = NewSeqEntryByNumber(group, elem); - if (!a) + seqEntry = NewSeqEntryByNumber(group, elem); + + if ( !AddEntry(seqEntry)) { - return 0; + dbg.Verbose(0, "Document::ReplaceOrCreateByNumber: AddEntry" + " failed allthough this is a creation."); + + delete seqEntry; + return NULL; } + } - b = new SeqEntry(a, 1); // FIXME : 1 (Depth) - AddEntry(b); - } - return b; + return seqEntry; } /** @@ -752,7 +736,7 @@ SeqEntry* Document::ReplaceOrCreateByNumber( uint16_t group, uint16_t elem) * @param elem element number of the Entry * \return boolean */ -bool Document::ReplaceIfExistByNumber(std::string const & value, +bool Document::ReplaceIfExistByNumber(std::string const &value, uint16_t group, uint16_t elem ) { SetEntryByNumber(value, group, elem); @@ -780,51 +764,6 @@ bool Document::CheckIfEntryExistByNumber(uint16_t group, uint16_t element ) return TagHT.count(key) != 0; } -/** - * \brief Searches within Header Entries (Dicom Elements) parsed with - * the public and private dictionaries - * for the element value of a given tag. - * \warning Don't use any longer : use GetPubEntryByName - * @param tagName name of the searched element. - * @return Corresponding element value when it exists, - * and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise. - */ -std::string Document::GetEntryByName(TagName const & tagName) -{ - DictEntry* dictEntry = RefPubDict->GetDictEntryByName(tagName); - if( !dictEntry ) - { - return GDCM_UNFOUND; - } - - return GetEntryByNumber(dictEntry->GetGroup(),dictEntry->GetElement()); -} - -/** - * \brief Searches within Header Entries (Dicom Elements) parsed with - * the public and private dictionaries - * for the element value representation of a given tag. - * - * Obtaining the VR (Value Representation) might be needed by caller - * to convert the string typed content to caller's native type - * (think of C++ vs Python). The VR is actually of a higher level - * of semantics than just the native C++ type. - * @param tagName name of the searched element. - * @return Corresponding element value representation when it exists, - * and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise. - */ -std::string Document::GetEntryVRByName(TagName const& tagName) -{ - DictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName); - if( dictEntry == NULL) - { - return GDCM_UNFOUND; - } - - DocEntry* elem = GetDocEntryByNumber(dictEntry->GetGroup(), - dictEntry->GetElement()); - return elem->GetVR(); -} /** * \brief Searches within Header Entries (Dicom Elements) parsed with @@ -862,7 +801,7 @@ std::string Document::GetEntryByNumber(uint16_t group, uint16_t element) */ std::string Document::GetEntryVRByNumber(uint16_t group, uint16_t element) { - DocEntry* elem = GetDocEntryByNumber(group, element); + DocEntry *elem = GetDocEntryByNumber(group, element); if ( !elem ) { return GDCM_UNFOUND; @@ -880,31 +819,13 @@ std::string Document::GetEntryVRByNumber(uint16_t group, uint16_t element) */ int Document::GetEntryLengthByNumber(uint16_t group, uint16_t element) { - DocEntry* elem = GetDocEntryByNumber(group, element); + DocEntry *elem = GetDocEntryByNumber(group, element); if ( !elem ) { return -2; //magic number } return elem->GetLength(); } -/** - * \brief Sets the value (string) of the Header Entry (Dicom Element) - * @param content string value of the Dicom Element - * @param tagName name of the searched Dicom Element. - * @return true when found - */ -bool Document::SetEntryByName( std::string const & content, - TagName const & tagName) -{ - DictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName); - if( !dictEntry ) - { - return false; - } - - return SetEntryByNumber(content,dictEntry->GetGroup(), - dictEntry->GetElement()); -} /** * \brief Accesses an existing DocEntry (i.e. a Dicom Element) @@ -917,16 +838,14 @@ bool Document::SetEntryByName( std::string const & content, bool Document::SetEntryByNumber(std::string const& content, uint16_t group, uint16_t element) { - ValEntry* valEntry = GetValEntryByNumber(group, element); - if (!valEntry ) + ValEntry *entry = GetValEntryByNumber(group, element); + if (!entry ) { dbg.Verbose(0, "Document::SetEntryByNumber: no corresponding", " ValEntry (try promotion first)."); return false; } - // Non even content must be padded with a space (020H)... - valEntry->SetValue(content); - return true; + return SetEntry(content,entry); } /** @@ -941,27 +860,58 @@ bool Document::SetEntryByNumber(std::string const& content, bool Document::SetEntryByNumber(uint8_t*content, int lgth, uint16_t group, uint16_t element) { - (void)lgth; //not used - TagKey key = DictEntry::TranslateToKey(group, element); - if ( !TagHT.count(key)) + BinEntry *entry = GetBinEntryByNumber(group, element); + if (!entry ) { + dbg.Verbose(0, "Document::SetEntryByNumber: no corresponding", + " ValEntry (try promotion first)."); return false; } -/* Hope Binary field length is *never* wrong - if(lgth%2) // Non even length are padded with a space (020H). - { - lgth++; - //content = content + '\0'; // fing a trick to enlarge a binary field? + return SetEntry(content,lgth,entry); +} + +/** + * \brief Accesses an existing DocEntry (i.e. a Dicom Element) + * and modifies it's content with the given value. + * @param content new value (string) to substitute with + * @param entry Entry to be modified + */ +bool Document::SetEntry(std::string const &content,ValEntry *entry) +{ + if(entry) + { + entry->SetValue(content); + return true; } -*/ - BinEntry* entry = (BinEntry *)TagHT[key]; - entry->SetBinArea(content); - entry->SetLength(lgth); - entry->SetValue(GDCM_BINLOADED); + return false; +} - return true; -} +/** + * \brief Accesses an existing BinEntry (i.e. a Dicom Element) + * and modifies it's content with the given value. + * @param content new value (void* -> uint8_t*) to substitute with + * @param entry Entry to be modified + * @param lgth new value length + */ +bool Document::SetEntry(uint8_t *content, int lgth, BinEntry *entry) +{ + if(entry) + { + // Hope Binary field length is *never* wrong + /*if(lgth%2) // Non even length are padded with a space (020H). + { + lgth++; + //content = content + '\0'; // fing a trick to enlarge a binary field? + }*/ + + entry->SetBinArea(content); + entry->SetLength(lgth); + entry->SetValue(GDCM_BINLOADED); + return true; + } + return false; +} /** * \brief Gets (from Header) a 'non string' element value @@ -970,15 +920,15 @@ bool Document::SetEntryByNumber(uint8_t*content, int lgth, * @param elem element number of the Entry * @return Pointer to the 'non string' area */ -void* Document::GetEntryBinAreaByNumber(uint16_t group, uint16_t elem) +void *Document::GetEntryBinAreaByNumber(uint16_t group, uint16_t elem) { - DocEntry* entry = GetDocEntryByNumber(group, elem); + DocEntry *entry = GetDocEntryByNumber(group, elem); if (!entry) { dbg.Verbose(1, "Document::GetDocEntryByNumber: no entry"); return 0; } - if ( BinEntry* binEntry = dynamic_cast(entry) ) + if ( BinEntry *binEntry = dynamic_cast(entry) ) { return binEntry->GetBinArea(); } @@ -1011,7 +961,7 @@ void Document::LoadEntryBinArea(uint16_t group, uint16_t elem) * when a string is not suitable * @param element Entry whose binArea is going to be loaded */ -void Document::LoadEntryBinArea(BinEntry* element) +void Document::LoadEntryBinArea(BinEntry *element) { if(element->GetBinArea()) return; @@ -1024,7 +974,7 @@ void Document::LoadEntryBinArea(BinEntry* element) Fp->seekg(o, std::ios::beg); size_t l = element->GetLength(); - uint8_t* a = new uint8_t[l]; + uint8_t *a = new uint8_t[l]; if( !a ) { dbg.Verbose(0, "Document::LoadEntryBinArea cannot allocate a"); @@ -1052,16 +1002,16 @@ void Document::LoadEntryBinArea(BinEntry* element) * @param element Element number of the searched Dicom Element * @return */ -/*bool Document::SetEntryBinAreaByNumber(uint8_t* area, +/*bool Document::SetEntryBinAreaByNumber(uint8_t *area, uint16_t group, uint16_t element) { - DocEntry* currentEntry = GetDocEntryByNumber(group, element); + DocEntry *currentEntry = GetDocEntryByNumber(group, element); if ( !currentEntry ) { return false; } - if ( BinEntry* binEntry = dynamic_cast(currentEntry) ) + if ( BinEntry *binEntry = dynamic_cast(currentEntry) ) { binEntry->SetBinArea( area ); return true; @@ -1070,72 +1020,6 @@ void Document::LoadEntryBinArea(BinEntry* element) return false; }*/ -/** - * \brief Update the entries with the shadow dictionary. - * Only non even entries are analyzed - */ -void Document::UpdateShaEntries() -{ - //DictEntry *entry; - std::string vr; - - /// \todo TODO : still any use to explore recursively the whole structure? -/* - for(ListTag::iterator it=listEntries.begin(); - it!=listEntries.end(); - ++it) - { - // Odd group => from public dictionary - if((*it)->GetGroup()%2==0) - continue; - - // Peer group => search the corresponding dict entry - if(RefShaDict) - entry=RefShaDict->GetDictEntryByNumber((*it)->GetGroup(),(*it)->GetElement()); - else - entry=NULL; - - if((*it)->IsImplicitVR()) - vr="Implicit"; - else - vr=(*it)->GetVR(); - - (*it)->SetValue(GetDocEntryUnvalue(*it)); // to go on compiling - if(entry){ - // Set the new entry and the new value - (*it)->SetDictEntry(entry); - CheckDocEntryVR(*it,vr); - - (*it)->SetValue(GetDocEntryValue(*it)); // to go on compiling - - } - else - { - // Remove precedent value transformation - (*it)->SetDictEntry(NewVirtualDictEntry((*it)->GetGroup(),(*it)->GetElement(),vr)); - } - } -*/ -} - -/** - * \brief Searches within the Header Entries for a Dicom Element of - * a given tag. - * @param tagName name of the searched Dicom Element. - * @return Corresponding Dicom Element when it exists, and NULL - * otherwise. - */ -DocEntry* Document::GetDocEntryByName(TagName const & tagName) -{ - DictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName); - if( !dictEntry ) - { - return NULL; - } - - return GetDocEntryByNumber(dictEntry->GetGroup(),dictEntry->GetElement()); -} - /** * \brief retrieves a Dicom Element (the first one) using (group, element) * \warning (group, element) IS NOT an identifier inside the Dicom Header @@ -1146,7 +1030,7 @@ DocEntry* Document::GetDocEntryByName(TagName const & tagName) * @param element Element number of the searched Dicom Element * @return */ -DocEntry* Document::GetDocEntryByNumber(uint16_t group, uint16_t element) +DocEntry *Document::GetDocEntryByNumber(uint16_t group, uint16_t element) { TagKey key = DictEntry::TranslateToKey(group, element); if ( !TagHT.count(key)) @@ -1162,30 +1046,52 @@ DocEntry* Document::GetDocEntryByNumber(uint16_t group, uint16_t element) * ValEntry. * @return When present, the corresponding ValEntry. */ -ValEntry* Document::GetValEntryByNumber(uint16_t group, uint16_t element) +ValEntry *Document::GetValEntryByNumber(uint16_t group, uint16_t element) { - DocEntry* currentEntry = GetDocEntryByNumber(group, element); + DocEntry *currentEntry = GetDocEntryByNumber(group, element); if ( !currentEntry ) { return 0; } - if ( ValEntry* valEntry = dynamic_cast(currentEntry) ) + if ( ValEntry *entry = dynamic_cast(currentEntry) ) { - return valEntry; + return entry; } dbg.Verbose(0, "Document::GetValEntryByNumber: unfound ValEntry."); return 0; } +/** + * \brief Same as \ref Document::GetDocEntryByNumber except it only + * returns a result when the corresponding entry is of type + * BinEntry. + * @return When present, the corresponding BinEntry. + */ +BinEntry *Document::GetBinEntryByNumber(uint16_t group, uint16_t element) +{ + DocEntry *currentEntry = GetDocEntryByNumber(group, element); + if ( !currentEntry ) + { + return 0; + } + if ( BinEntry *entry = dynamic_cast(currentEntry) ) + { + return entry; + } + dbg.Verbose(0, "Document::GetBinEntryByNumber: unfound BinEntry."); + + return 0; +} + /** * \brief Loads the element while preserving the current - * underlying file position indicator as opposed to + * underlying file position indicator as opposed to * to LoadDocEntry that modifies it. * @param entry Header Entry whose value shall be loaded. * @return */ -void Document::LoadDocEntrySafe(DocEntry * entry) +void Document::LoadDocEntrySafe(DocEntry *entry) { if(Fp) { @@ -1269,6 +1175,12 @@ void Document::ParseDES(DocEntrySet *set, long offset, long l_max, bool delim_mode) { DocEntry *newDocEntry = 0; + ValEntry *newValEntry; + BinEntry *newBinEntry; + SeqEntry *newSeqEntry; + VRKey vr; + bool used=false; + long offsetEntry,readEntry; while (true) { @@ -1276,26 +1188,64 @@ void Document::ParseDES(DocEntrySet *set, long offset, { break; } + + used=true; newDocEntry = ReadNextDocEntry( ); if ( !newDocEntry ) { break; } - VRKey vr = newDocEntry->GetVR(); - if ( vr != "SQ" ) + vr = newDocEntry->GetVR(); + newValEntry = dynamic_cast(newDocEntry); + newBinEntry = dynamic_cast(newDocEntry); + newSeqEntry = dynamic_cast(newDocEntry); + + if ( newValEntry || newBinEntry ) { + offsetEntry=newDocEntry->GetOffset(); + readEntry=newDocEntry->GetReadLength(); - if ( Global::GetVR()->IsVROfGdcmStringRepresentable(vr) ) + if ( newBinEntry ) + { + if ( ! Global::GetVR()->IsVROfBinaryRepresentable(vr) ) + { + ////// Neither ValEntry NOR BinEntry: should mean UNKOWN VR + dbg.Verbose(0, "Document::ParseDES: neither Valentry, " + "nor BinEntry. Probably unknown VR."); + } + + //////////////////// BinEntry or UNKOWN VR: + // When "this" is a Document the Key is simply of the + // form ( group, elem )... + if (Document *dummy = dynamic_cast< Document* > ( set ) ) + { + (void)dummy; + newBinEntry->SetKey( newBinEntry->GetKey() ); + } + // but when "this" is a SQItem, we are inserting this new + // valEntry in a sequence item, and the kay has the + // generalized form (refer to \ref BaseTagKey): + if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) ) + { + newBinEntry->SetKey( parentSQItem->GetBaseTagKey() + + newBinEntry->GetKey() ); + } + + LoadDocEntry( newBinEntry ); + if( !set->AddEntry( newBinEntry ) ) + { + //Expect big troubles if here + //delete newBinEntry; + used=false; + } + } + else { /////////////////////// ValEntry - ValEntry* newValEntry = - new ValEntry( newDocEntry->GetDictEntry() ); //LEAK - newValEntry->Copy( newDocEntry ); - // 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 (Document* dummy = dynamic_cast< Document* > ( set ) ) + if (Document *dummy = dynamic_cast< Document* > ( set ) ) { (void)dummy; newValEntry->SetKey( newValEntry->GetKey() ); @@ -1303,7 +1253,7 @@ void Document::ParseDES(DocEntrySet *set, long offset, // ...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 ) ) + if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) ) { newValEntry->SetKey( parentSQItem->GetBaseTagKey() + newValEntry->GetKey() ); @@ -1314,55 +1264,23 @@ void Document::ParseDES(DocEntrySet *set, long offset, if( !set->AddEntry( newValEntry ) ) { // If here expect big troubles - delete newValEntry; //otherwise mem leak + //delete newValEntry; //otherwise mem leak + used=false; } if (delimitor) { - delete newDocEntry; + if(!used) + delete newDocEntry; break; } if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) { - delete newDocEntry; + if(!used) + delete newDocEntry; break; } } - else - { - if ( ! Global::GetVR()->IsVROfGdcmBinaryRepresentable(vr) ) - { - ////// Neither ValEntry NOR BinEntry: should mean UNKOWN VR - dbg.Verbose(0, "Document::ParseDES: neither Valentry, " - "nor BinEntry. Probably unknown VR."); - } - - //////////////////// BinEntry or UNKOWN VR: - BinEntry* newBinEntry = new BinEntry( newDocEntry ); //LEAK - - // When "this" is a Document the Key is simply of the - // form ( group, elem )... - if (Document* dummy = dynamic_cast< Document* > ( set ) ) - { - (void)dummy; - newBinEntry->SetKey( newBinEntry->GetKey() ); - } - // but when "this" is a SQItem, we are inserting this new - // valEntry in a sequence item, and the kay has the - // generalized form (refer to \ref BaseTagKey): - if (SQItem* parentSQItem = dynamic_cast< SQItem* > ( set ) ) - { - newBinEntry->SetKey( parentSQItem->GetBaseTagKey() - + newBinEntry->GetKey() ); - } - - LoadDocEntry( newBinEntry ); - if( !set->AddEntry( newBinEntry ) ) - { - //Expect big troubles if here - delete newBinEntry; - } - } if ( ( newDocEntry->GetGroup() == 0x7fe0 ) && ( newDocEntry->GetElement() == 0x0010 ) ) @@ -1370,23 +1288,22 @@ void Document::ParseDES(DocEntrySet *set, long offset, TransferSyntaxType ts = GetTransferSyntax(); if ( ts == RLELossless ) { - long PositionOnEntry = Fp->tellg(); + long positionOnEntry = Fp->tellg(); Fp->seekg( newDocEntry->GetOffset(), std::ios::beg ); ComputeRLEInfo(); - Fp->seekg( PositionOnEntry, std::ios::beg ); + Fp->seekg( positionOnEntry, std::ios::beg ); } else if ( IsJPEG() ) { - long PositionOnEntry = Fp->tellg(); + long positionOnEntry = Fp->tellg(); Fp->seekg( newDocEntry->GetOffset(), std::ios::beg ); ComputeJPEGFragmentInfo(); - Fp->seekg( PositionOnEntry, std::ios::beg ); + Fp->seekg( positionOnEntry, std::ios::beg ); } } // Just to make sure we are at the beginning of next entry. - SkipToNextDocEntry(newDocEntry); - //delete newDocEntry; + SkipToNextDocEntry(offsetEntry,readEntry); } else { @@ -1404,16 +1321,13 @@ void Document::ParseDES(DocEntrySet *set, long offset, } } // no other way to create it ... - SeqEntry* newSeqEntry = - new SeqEntry( newDocEntry->GetDictEntry() ); - newSeqEntry->Copy( newDocEntry ); newSeqEntry->SetDelimitorMode( delim_mode ); // 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 (Document* dummy = dynamic_cast< Document* > ( set ) ) + if (Document *dummy = dynamic_cast< Document* > ( set ) ) { (void)dummy; newSeqEntry->SetDepthLevel( 1 ); @@ -1422,7 +1336,7 @@ void Document::ParseDES(DocEntrySet *set, long offset, // But when "set" is allready 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 ) ) + if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) ) { newSeqEntry->SetDepthLevel( parentSQItem->GetDepthLevel() + 1 ); newSeqEntry->SetKey( parentSQItem->GetBaseTagKey() @@ -1438,11 +1352,12 @@ void Document::ParseDES(DocEntrySet *set, long offset, set->AddEntry( newSeqEntry ); if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) { - delete newDocEntry; break; } } - delete newDocEntry; + + if(!used) + delete newDocEntry; } } @@ -1450,7 +1365,7 @@ void Document::ParseDES(DocEntrySet *set, long offset, * \brief Parses a Sequence ( SeqEntry after SeqEntry) * @return parsed length for this level */ -void Document::ParseSQ( SeqEntry* seqEntry, +void Document::ParseSQ( SeqEntry *seqEntry, long offset, long l_max, bool delim_mode) { int SQItemNumber = 0; @@ -1458,7 +1373,7 @@ void Document::ParseSQ( SeqEntry* seqEntry, while (true) { - DocEntry* newDocEntry = ReadNextDocEntry(); + DocEntry *newDocEntry = ReadNextDocEntry(); if ( !newDocEntry ) { // FIXME Should warn user @@ -1513,7 +1428,7 @@ void Document::ParseSQ( SeqEntry* seqEntry, * the value specified with Document::SetMaxSizeLoadEntry() * @param entry Header Entry (Dicom Element) to be dealt with */ -void Document::LoadDocEntry(DocEntry* entry) +void Document::LoadDocEntry(DocEntry *entry) { uint16_t group = entry->GetGroup(); std::string vr = entry->GetVR(); @@ -1545,7 +1460,7 @@ void Document::LoadDocEntry(DocEntry* entry) std::ostringstream s; if (length > MaxSizeLoadEntry) { - if (BinEntry* binEntryPtr = dynamic_cast< BinEntry* >(entry) ) + if (BinEntry *binEntryPtr = dynamic_cast< BinEntry* >(entry) ) { //s << "gdcm::NotLoaded (BinEntry)"; s << GDCM_NOTLOADED; @@ -1555,7 +1470,7 @@ void Document::LoadDocEntry(DocEntry* entry) binEntryPtr->SetValue(s.str()); } // Be carefull : a BinEntry IS_A ValEntry ... - else if (ValEntry* valEntryPtr = dynamic_cast< ValEntry* >(entry) ) + else if (ValEntry *valEntryPtr = dynamic_cast< ValEntry* >(entry) ) { // s << "gdcm::NotLoaded. (ValEntry)"; s << GDCM_NOTLOADED; @@ -1578,7 +1493,7 @@ void Document::LoadDocEntry(DocEntry* entry) } // When we find a BinEntry not very much can be done : - if (BinEntry* binEntryPtr = dynamic_cast< BinEntry* >(entry) ) + if (BinEntry *binEntryPtr = dynamic_cast< BinEntry* >(entry) ) { s << GDCM_BINLOADED; binEntryPtr->SetValue(s.str()); @@ -1655,7 +1570,7 @@ void Document::LoadDocEntry(DocEntry* entry) } delete[] str; - if ( ValEntry* valEntry = dynamic_cast(entry) ) + if ( ValEntry *valEntry = dynamic_cast(entry) ) { if ( Fp->fail() || Fp->eof())//Fp->gcount() == 1 { @@ -1779,7 +1694,7 @@ void Document::FindDocEntryLength( DocEntry *entry ) // and the dictionary entry depending on them. uint16_t correctGroup = SwapShort( entry->GetGroup() ); uint16_t correctElem = SwapShort( entry->GetElement() ); - DictEntry* newTag = GetDictEntryByNumber( correctGroup, + DictEntry *newTag = GetDictEntryByNumber( correctGroup, correctElem ); if ( !newTag ) { @@ -1816,16 +1731,12 @@ void Document::FindDocEntryLength( DocEntry *entry ) /** * \brief Find the Value Representation of the current Dicom Element. - * @param entry + * @return Value Representation of the current Entry */ -void Document::FindDocEntryVR( DocEntry *entry ) +std::string Document::FindDocEntryVR() { if ( Filetype != ExplicitVR ) - { - return; - } - - char vr[3]; + return(GDCM_UNKNOWN); long positionOnEntry = Fp->tellg(); // Warning: we believe this is explicit VR (Value Representation) because @@ -1835,104 +1746,34 @@ void Document::FindDocEntryVR( DocEntry *entry ) // within an explicit VR file. Hence we make sure the present tag // is in explicit VR and try to fix things if it happens not to be // the case. + + char vr[3]; Fp->read (vr, (size_t)2); vr[2] = 0; - if( !CheckDocEntryVR(entry, vr) ) + if( !CheckDocEntryVR(vr) ) { Fp->seekg(positionOnEntry, std::ios::beg); - // When this element is known in the dictionary we shall use, e.g. for - // the semantics (see the usage of IsAnInteger), the VR proposed by the - // dictionary entry. Still we have to flag the element as implicit since - // we know now our assumption on expliciteness is not furfilled. - // avoid . - if ( entry->IsVRUnknown() ) - { - entry->SetVR("Implicit"); - } - entry->SetImplicitVR(); + return(GDCM_UNKNOWN); } + return(vr); } /** * \brief Check the correspondance between the VR of the header entry * and the taken VR. If they are different, the header entry is * updated with the new VR. - * @param entry Header Entry to check * @param vr Dicom Value Representation * @return false if the VR is incorrect of if the VR isn't referenced * otherwise, it returns true */ -bool Document::CheckDocEntryVR(DocEntry *entry, VRKey vr) +bool Document::CheckDocEntryVR(VRKey vr) { - std::string msg; - bool realExplicit = true; - - // Assume we are reading a falsely explicit VR file i.e. we reached - // a tag where we expect reading a VR but are in fact we read the - // first to bytes of the length. Then we will interogate (through find) - // the dicom_vr dictionary with oddities like "\004\0" which crashes - // both GCC and VC++ implementations of the STL map. Hence when the - // expected VR read happens to be non-ascii characters we consider - // we hit falsely explicit VR tag. - - if ( !isalpha((unsigned char)vr[0]) && !isalpha((unsigned char)vr[1]) ) - { - realExplicit = false; - } - // CLEANME searching the dicom_vr at each occurence is expensive. // PostPone this test in an optional integrity check at the end // of parsing or only in debug mode. - if ( realExplicit && !Global::GetVR()->Count(vr) ) - { - realExplicit = false; - } - - if ( !realExplicit ) - { - // We thought this was explicit VR, but we end up with an - // implicit VR tag. Let's backtrack. - msg = Util::Format("Falsely explicit vr file (%04x,%04x)\n", - entry->GetGroup(), entry->GetElement()); - dbg.Verbose(1, "Document::FindVR: ", msg.c_str()); - - if( entry->GetGroup() % 2 && entry->GetElement() == 0x0000) - { - // Group length is UL ! - DictEntry* newEntry = NewVirtualDictEntry( - entry->GetGroup(), entry->GetElement(), - "UL", "FIXME", "Group Length"); - entry->SetDictEntry( newEntry ); - } + if ( !Global::GetVR()->IsValidVR(vr) ) return false; - } - - if ( entry->IsVRUnknown() ) - { - // When not a dictionary entry, we can safely overwrite the VR. - if( entry->GetElement() == 0x0000 ) - { - // Group length is UL ! - entry->SetVR("UL"); - } - else - { - entry->SetVR(vr); - } - } - else if ( entry->GetVR() != vr ) - { - // The VR present in the file and the dictionary disagree. We assume - // the file writer knew best and use the VR of the file. Since it would - // be unwise to overwrite the VR of a dictionary (since it would - // compromise it's next user), we need to clone the actual DictEntry - // and change the VR for the read one. - DictEntry* newEntry = NewVirtualDictEntry( - entry->GetGroup(), entry->GetElement(), - vr, "FIXME", entry->GetName()); - entry->SetDictEntry(newEntry); - } return true; } @@ -2020,7 +1861,7 @@ std::string Document::GetDocEntryValue(DocEntry *entry) * @param entry Entry to reverse transform * @return Reverse transformed entry value */ -std::string Document::GetDocEntryUnvalue(DocEntry* entry) +std::string Document::GetDocEntryUnvalue(DocEntry *entry) { if ( IsDocEntryAnInteger(entry) && entry->IsImplicitVR() ) { @@ -2081,12 +1922,14 @@ void Document::SkipDocEntry(DocEntry *entry) /** * \brief Skips to the begining of the next Header Entry * \warning NOT end user intended method ! - * @param entry entry to skip + * @param offset start of skipping + * @param readLgth length to skip + */ -void Document::SkipToNextDocEntry(DocEntry *entry) +void Document::SkipToNextDocEntry(long offset,long readLgth) { - Fp->seekg((long)(entry->GetOffset()), std::ios::beg); - Fp->seekg( (long)(entry->GetReadLength()), std::ios::cur); + Fp->seekg((long)(offset), std::ios::beg); + Fp->seekg( (long)(readLgth), std::ios::cur); } /** @@ -2179,7 +2022,7 @@ bool Document::IsDocEntryAnInteger(DocEntry *entry) { uint16_t element = entry->GetElement(); uint16_t group = entry->GetGroup(); - const std::string & vr = entry->GetVR(); + const std::string &vr = entry->GetVR(); uint32_t length = entry->GetLength(); // When we have some semantics on the element we just read, and if we @@ -2646,7 +2489,7 @@ void Document::HandleBrokenEndian(uint16_t group, uint16_t elem) * gets the VR, gets the length, gets the offset value) * @return On succes the newly created DocEntry, NULL on failure. */ -DocEntry* Document::ReadNextDocEntry() +DocEntry *Document::ReadNextDocEntry() { uint16_t group; uint16_t elem; @@ -2665,8 +2508,37 @@ DocEntry* Document::ReadNextDocEntry() } HandleBrokenEndian(group, elem); - DocEntry *newEntry = NewDocEntryByNumber(group, elem); - FindDocEntryVR(newEntry); + std::string vr = FindDocEntryVR(); + std::string realVR = vr; + + if( vr == GDCM_UNKNOWN) + { + DictEntry *dictEntry = GetDictEntryByNumber(group,elem); + if( dictEntry ) + realVR = dictEntry->GetVR(); + } + + DocEntry *newEntry; + if( Global::GetVR()->IsVROfSequence(realVR) ) + newEntry = NewSeqEntryByNumber(group, elem); + else if( Global::GetVR()->IsVROfStringRepresentable(realVR) ) + newEntry = NewValEntryByNumber(group, elem,vr); + else + newEntry = NewBinEntryByNumber(group, elem,vr); + + if( vr == GDCM_UNKNOWN ) + { + if( Filetype == ExplicitVR ) + { + // We thought this was explicit VR, but we end up with an + // implicit VR tag. Let's backtrack. + std::string msg; + msg = Util::Format("Falsely explicit vr file (%04x,%04x)\n", + newEntry->GetGroup(), newEntry->GetElement()); + dbg.Verbose(1, "Document::FindVR: ", msg.c_str()); + } + newEntry->SetImplicitVR(); + } try { @@ -2809,7 +2681,7 @@ void Document::ReadAndSkipEncapsulatedBasicOffsetTable() // lengths, but we won't bother with such fuses for the time being. if ( itemLength != 0 ) { - char* basicOffsetTableItemValue = new char[itemLength + 1]; + char *basicOffsetTableItemValue = new char[itemLength + 1]; Fp->read(basicOffsetTableItemValue, itemLength); #ifdef GDCM_DEBUG @@ -2908,7 +2780,7 @@ void Document::ComputeRLEInfo() SkipBytes(rleSegmentLength[nbRleSegments]); // Store the collected info - RLEFrame* newFrameInfo = new RLEFrame; + RLEFrame *newFrameInfo = new RLEFrame; newFrameInfo->NumberFragments = nbRleSegments; for( unsigned int uk = 1; uk <= nbRleSegments; uk++ ) { @@ -2951,7 +2823,7 @@ void Document::ComputeJPEGFragmentInfo() long fragmentOffset = Fp->tellg(); // Store the collected info - JPEGFragment* newFragment = new JPEGFragment; + JPEGFragment *newFragment = new JPEGFragment; newFragment->Offset = fragmentOffset; newFragment->Length = fragmentLength; JPEGInfo->Fragments.push_back( newFragment ); @@ -2977,18 +2849,18 @@ void Document::ComputeJPEGFragmentInfo() * when recursively walking the given set. * @param set The structure to be traversed (recursively). */ -void Document::BuildFlatHashTableRecurse( TagDocEntryHT& builtHT, - DocEntrySet* set ) +void Document::BuildFlatHashTableRecurse( TagDocEntryHT &builtHT, + DocEntrySet *set ) { - if (ElementSet* elementSet = dynamic_cast< ElementSet* > ( set ) ) + if (ElementSet *elementSet = dynamic_cast< ElementSet* > ( set ) ) { - TagDocEntryHT const & currentHT = elementSet->GetTagHT(); + TagDocEntryHT const ¤tHT = elementSet->GetTagHT(); for( TagDocEntryHT::const_iterator i = currentHT.begin(); i != currentHT.end(); ++i) { - DocEntry* entry = i->second; - if ( SeqEntry* seqEntry = dynamic_cast(entry) ) + DocEntry *entry = i->second; + if ( SeqEntry *seqEntry = dynamic_cast(entry) ) { const ListSQItem& items = seqEntry->GetSQItems(); for( ListSQItem::const_iterator item = items.begin(); @@ -3004,15 +2876,15 @@ void Document::BuildFlatHashTableRecurse( TagDocEntryHT& builtHT, return; } - if (SQItem* SQItemSet = dynamic_cast< SQItem* > ( set ) ) + if (SQItem *SQItemSet = dynamic_cast< SQItem* > ( set ) ) { const ListDocEntry& currentList = SQItemSet->GetDocEntries(); for (ListDocEntry::const_iterator i = currentList.begin(); i != currentList.end(); ++i) { - DocEntry* entry = *i; - if ( SeqEntry* seqEntry = dynamic_cast(entry) ) + DocEntry *entry = *i; + if ( SeqEntry *seqEntry = dynamic_cast(entry) ) { const ListSQItem& items = seqEntry->GetSQItems(); for( ListSQItem::const_iterator item = items.begin(); @@ -3052,9 +2924,9 @@ void Document::BuildFlatHashTableRecurse( TagDocEntryHT& builtHT, * \ref BuildFlatHashTable again... * @return The flat std::map<> we juste build. */ -TagDocEntryHT* Document::BuildFlatHashTable() +TagDocEntryHT *Document::BuildFlatHashTable() { - TagDocEntryHT* FlatHT = new TagDocEntryHT; + TagDocEntryHT *FlatHT = new TagDocEntryHT; BuildFlatHashTableRecurse( *FlatHT, this ); return FlatHT; } @@ -3149,24 +3021,23 @@ int Document::ComputeGroup0002Length( FileType filetype ) gr = entry->GetGroup(); if (gr == 0x0002) + { found0002 = true; - else - if (found0002 ) - break; - else - continue; - el = entry->GetElement(); - vr = entry->GetVR(); + el = entry->GetElement(); + vr = entry->GetVR(); - if (filetype == ExplicitVR) - { - if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") ) + if (filetype == ExplicitVR) { - groupLength += 4; // explicit VR AND OB, OW, SQ : 4 more bytes + if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") ) + { + groupLength += 4; // explicit VR AND OB, OW, SQ : 4 more bytes + } } + groupLength += 2 + 2 + 4 + entry->GetLength(); } - groupLength += 2 + 2 + 4 + entry->GetLength(); + else if (found0002 ) + break; entry = GetNextEntry(); }