X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=src%2FgdcmDocument.cxx;h=e5e627e436fe4b9390379491fc5f5c4a84e05339;hb=922095a0dd56f24d651b36f62256690020937d9a;hp=f2c4fb9585f8350f347c00480f1800ccf41e05c9;hpb=a0fbf995c51ba9e31cca7f14ba1deffdf188f3b9;p=gdcm.git diff --git a/src/gdcmDocument.cxx b/src/gdcmDocument.cxx index f2c4fb95..e5e627e4 100644 --- a/src/gdcmDocument.cxx +++ b/src/gdcmDocument.cxx @@ -3,8 +3,8 @@ Program: gdcm Module: $RCSfile: gdcmDocument.cxx,v $ Language: C++ - Date: $Date: 2004/11/10 16:13:18 $ - Version: $Revision: 1.120 $ + Date: $Date: 2004/12/10 13:49:07 $ + Version: $Revision: 1.150 $ Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de l'Image). All rights reserved. See Doc/License.txt or @@ -23,6 +23,13 @@ #include "gdcmGlobal.h" #include "gdcmUtil.h" #include "gdcmDebug.h" +#include "gdcmTS.h" +#include "gdcmException.h" +#include "gdcmDictSet.h" +#include "gdcmRLEFramesInfo.h" +#include "gdcmJPEGFragmentsInfo.h" +#include "gdcmDocEntrySet.h" +#include "gdcmSQItem.h" #include #include @@ -36,9 +43,12 @@ namespace gdcm { +//----------------------------------------------------------------------------- static const char *TransferSyntaxStrings[] = { // Implicit VR Little Endian "1.2.840.10008.1.2", + // Implicit VR Little Endian DLX G.E? + "1.2.840.113619.5.2", // Explicit VR Little Endian "1.2.840.10008.1.2.1", // Deflated Explicit VR Little Endian @@ -68,10 +78,10 @@ static const char *TransferSyntaxStrings[] = { // Unknown "Unknown Transfer Syntax" }; - + //----------------------------------------------------------------------------- // Refer to Document::CheckSwap() -const unsigned int Document::HEADER_LENGTH_TO_READ = 256; +//const unsigned int Document::HEADER_LENGTH_TO_READ = 256; // Refer to Document::SetMaxSizeLoadEntry() const unsigned int Document::MAX_SIZE_LOAD_ELEMENT_VALUE = 0xfff; // 4096 @@ -98,19 +108,19 @@ Document::Document( std::string const & filename ) : ElementSet(-1) dbg.Verbose(0, "Document::Document: starting parsing of file: ", Filename.c_str()); - Fp->seekg( 0, std::ios_base::beg); + Fp->seekg( 0, std::ios::beg); - Fp->seekg(0, std::ios_base::end); + Fp->seekg(0, std::ios::end); long lgt = Fp->tellg(); - Fp->seekg( 0, std::ios_base::beg); + Fp->seekg( 0, std::ios::beg); CheckSwap(); long beg = Fp->tellg(); lgt -= beg; ParseDES( this, beg, lgt, false); // le Load sera fait a la volee - Fp->seekg( 0, std::ios_base::beg); + Fp->seekg( 0, std::ios::beg); // Load 'non string' values @@ -186,6 +196,8 @@ Document::Document() : ElementSet(-1) SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE); Initialise(); + SwapCode = 0; + Filetype = ExplicitVR; PrintLevel = 1; // 'Medium' print level by default } @@ -197,13 +209,6 @@ Document::~Document () RefPubDict = NULL; RefShaDict = NULL; - // Recursive clean up of sequences - for (TagDocEntryHT::const_iterator it = TagHT.begin(); - it != TagHT.end(); ++it ) - { - //delete it->second; //temp remove - } - TagHT.clear(); delete RLEInfo; delete JPEGInfo; } @@ -293,14 +298,11 @@ bool Document::IsReadable() return true; } - /** - * \brief Internal function that checks whether the Transfer Syntax given - * as argument is the one present in the current document. - * @param syntaxToCheck The transfert syntax we need to check against. - * @return True when SyntaxToCheck corresponds to the Transfer Syntax of - * the current document. False either when the document contains - * no Transfer Syntax, or when the Tranfer Syntaxes doesn't match. + * \brief Accessor to the Transfer Syntax (when present) of the + * current document (it internally handles reading the + * value from disk when only parsing occured). + * @return The encountered Transfer Syntax of the current document. */ TransferSyntaxType Document::GetTransferSyntax() { @@ -324,7 +326,7 @@ TransferSyntaxType Document::GetTransferSyntax() // for brain damaged headers return UnknownTS; } - while ( !isdigit(transfer[transfer.length()-1]) ) + while ( !isdigit((unsigned char)transfer[transfer.length()-1]) ) { transfer.erase(transfer.length()-1, 1); } @@ -416,6 +418,11 @@ FileType Document::GetFileType() */ std::ifstream* Document::OpenFile() { + if (Filename.length() == 0) + { + return 0; + } + if(Fp) { dbg.Verbose( 0, @@ -424,28 +431,43 @@ std::ifstream* Document::OpenFile() } Fp = new std::ifstream(Filename.c_str(), std::ios::in | std::ios::binary); - - if(!Fp) + if( ! *Fp ) { dbg.Verbose( 0, "Document::OpenFile cannot open file: ", Filename.c_str()); + delete Fp; + Fp = 0; return 0; } uint16_t zero; - Fp->read((char*)&zero, (size_t)2 ); + Fp->read((char*)&zero, (size_t)2); + if( Fp->eof() ) + { + CloseFile(); + return 0; + } - //ACR -- or DICOM with no Preamble -- - if( zero == 0x0008 || zero == 0x0800 || zero == 0x0002 || zero == 0x0200 ) + //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 ) { return Fp; } //DICOM - Fp->seekg(126L, std::ios_base::cur); + Fp->seekg(126L, std::ios::cur); char dicm[4]; Fp->read(dicm, (size_t)4); + if( Fp->eof() ) + { + CloseFile(); + return 0; + } if( memcmp(dicm, "DICM", 4) == 0 ) { return Fp; @@ -482,41 +504,22 @@ bool Document::CloseFile() * (ACR-NEMA, ExplicitVR, ImplicitVR) * \return Always true. */ -void Document::Write(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 /// (necessary if user wants to write a DICOM V3 file /// starting from an ACR-NEMA (V2) Header - if (filetype == ImplicitVR) - { - std::string ts = - Util::DicomString( TransferSyntaxStrings[ImplicitVRLittleEndian] ); - ReplaceOrCreateByNumber(ts, 0x0002, 0x0010); - - /// \todo Refer to standards on page 21, chapter 6.2 - /// "Value representation": values with a VR of UI shall be - /// padded with a single trailing null - /// in the following case we have to padd manually with a 0 - - SetEntryLengthByNumber(18, 0x0002, 0x0010); - } - - if (filetype == ExplicitVR) + if ( filetype == ImplicitVR || filetype == ExplicitVR ) { - std::string ts = - Util::DicomString( TransferSyntaxStrings[ExplicitVRLittleEndian] ); - ReplaceOrCreateByNumber(ts, 0x0002, 0x0010); //LEAK - - /// \todo Refer to standards on page 21, chapter 6.2 - /// "Value representation": values with a VR of UI shall be - /// padded with a single trailing null - /// Dans le cas suivant on doit pader manuellement avec un 0 - - SetEntryLengthByNumber(20, 0x0002, 0x0010); + // writing Dicom File Preamble + char filePreamble[128]; + memset(filePreamble, 0, 128); + fp->write(filePreamble, 128); + fp->write("DICM", 4); } - + /** * \todo rewrite later, if really usefull * - 'Group Length' element is optional in DICOM @@ -529,8 +532,7 @@ void Document::Write(std::ofstream* fp, FileType filetype) * UpdateGroupLength(true,ACR); */ - ElementSet::Write(fp, filetype); // This one is recursive - + ElementSet::WriteContent(fp, filetype); // This one is recursive } /** @@ -539,7 +541,7 @@ void Document::Write(std::ofstream* fp, FileType filetype) * @param value (string) 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- + * @param vr V(alue) R(epresentation) of the Entry -if private Entry- * \return pointer to the modified/created Header Entry (NULL when creation * failed). */ @@ -576,16 +578,17 @@ ValEntry* Document::ReplaceOrCreateByNumber( " NewDocEntryByNumber failed."); return NULL; } + valEntry = new ValEntry(currentEntry); + delete currentEntry; + if ( !AddEntry(valEntry)) { delete valEntry; dbg.Verbose(0, "Document::ReplaceOrCreateByNumber: AddEntry" " failed allthough this is a creation."); + return NULL; } - // This is the reason why NewDocEntryByNumber are a real - // bad habit !!! FIXME - delete currentEntry; } else { @@ -621,6 +624,7 @@ ValEntry* Document::ReplaceOrCreateByNumber( /* * \brief Modifies the value of a given Header Entry (Dicom Element) * when it exists. Create it with the given value when unexistant. + * A copy of the binArea is made to be kept in the Document. * @param binArea (binary) value to be set * @param Group Group number of the Entry * @param Elem Element number of the Entry @@ -667,6 +671,7 @@ BinEntry* Document::ReplaceOrCreateByNumber( dbg.Verbose(0, "Document::ReplaceOrCreateByNumber: AddEntry" " failed allthough this is a creation."); } + delete currentEntry; } else { @@ -692,7 +697,23 @@ BinEntry* Document::ReplaceOrCreateByNumber( } } - SetEntryByNumber(binArea, lgth, group, elem); + uint8_t *tmpArea; + if (lgth>0 && binArea) + { + tmpArea = new uint8_t[lgth]; + memcpy(tmpArea,binArea,lgth); + } + else + { + tmpArea = 0; + } + if (!SetEntryByNumber(tmpArea, lgth, group, elem)) + { + if (tmpArea) + { + delete[] tmpArea; + } + } return binEntry; } @@ -740,6 +761,11 @@ bool Document::ReplaceIfExistByNumber(std::string const & value, return true; } +std::string Document::GetTransferSyntaxValue(TransferSyntaxType type) +{ + return TransferSyntaxStrings[type]; +} + //----------------------------------------------------------------------------- // Protected @@ -813,7 +839,6 @@ std::string Document::GetEntryVRByName(TagName const& tagName) std::string Document::GetEntryByNumber(uint16_t group, uint16_t element) { TagKey key = DictEntry::TranslateToKey(group, element); - /// \todo use map methods, instead of multimap JPR if ( !TagHT.count(key)) { return GDCM_UNFOUND; @@ -869,8 +894,8 @@ int Document::GetEntryLengthByNumber(uint16_t group, uint16_t element) * @param tagName name of the searched Dicom Element. * @return true when found */ -bool Document::SetEntryByName(std::string const & content, - TagName const & tagName) +bool Document::SetEntryByName( std::string const & content, + TagName const & tagName) { DictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName); if( !dictEntry ) @@ -893,9 +918,6 @@ bool Document::SetEntryByName(std::string const & content, bool Document::SetEntryByNumber(std::string const& content, uint16_t group, uint16_t element) { - int c; - int l; - ValEntry* valEntry = GetValEntryByNumber(group, element); if (!valEntry ) { @@ -904,30 +926,7 @@ bool Document::SetEntryByNumber(std::string const& content, return false; } // Non even content must be padded with a space (020H)... - std::string finalContent = Util::DicomString( content.c_str() ); - assert( !(finalContent.size() % 2) ); - valEntry->SetValue(finalContent); - - // Integers have a special treatement for their length: - - l = finalContent.length(); - if ( l != 0) // To avoid to be cheated by 'zero length' integers - { - VRKey vr = valEntry->GetVR(); - if( vr == "US" || vr == "SS" ) - { - // for multivaluated items - c = Util::CountSubstring(content, "\\") + 1; - l = c*2; - } - else if( vr == "UL" || vr == "SL" ) - { - // for multivaluated items - c = Util::CountSubstring(content, "\\") + 1; - l = c*4;; - } - } - valEntry->SetLength(l); + valEntry->SetValue(content); return true; } @@ -957,61 +956,14 @@ bool Document::SetEntryByNumber(uint8_t*content, int lgth, //content = content + '\0'; // fing a trick to enlarge a binary field? } */ - BinEntry* a = (BinEntry *)TagHT[key]; - a->SetBinArea(content); - a->SetLength(lgth); - a->SetValue(GDCM_BINLOADED); + BinEntry* entry = (BinEntry *)TagHT[key]; + entry->SetBinArea(content); + entry->SetLength(lgth); + entry->SetValue(GDCM_BINLOADED); return true; } -/** - * \brief Accesses an existing DocEntry (i.e. a Dicom Element) - * in the PubDocEntrySet of this instance - * through it's (group, element) and modifies it's length with - * the given value. - * \warning Use with extreme caution. - * @param l new length to substitute with - * @param group group number of the Entry to modify - * @param element element number of the Entry to modify - * @return true on success, false otherwise. - */ -bool Document::SetEntryLengthByNumber(uint32_t l, - uint16_t group, uint16_t element) -{ - /// \todo use map methods, instead of multimap JPR - TagKey key = DictEntry::TranslateToKey(group, element); - if ( !TagHT.count(key) ) - { - return false; - } - if ( l % 2 ) - { - l++; // length must be even - } - ( ((TagHT.equal_range(key)).first)->second )->SetLength(l); - - return true ; -} - -/** - * \brief Gets (from Header) the offset of a 'non string' element value - * (LoadElementValues has already be executed) - * @param group group number of the Entry - * @param elem element number of the Entry - * @return File Offset of the Element Value - */ -size_t Document::GetEntryOffsetByNumber(uint16_t group, uint16_t elem) -{ - DocEntry* entry = GetDocEntryByNumber(group, elem); - if (!entry) - { - dbg.Verbose(1, "Document::GetDocEntryByNumber: no entry present."); - return 0; - } - return entry->GetOffset(); -} - /** * \brief Gets (from Header) a 'non string' element value * (LoadElementValues has already be executed) @@ -1041,61 +993,57 @@ void* Document::GetEntryBinAreaByNumber(uint16_t group, uint16_t elem) * @param group group number of the Entry * @param elem element number of the Entry */ -void* Document::LoadEntryBinArea(uint16_t group, uint16_t elem) +void Document::LoadEntryBinArea(uint16_t group, uint16_t elem) { + // Search the corresponding DocEntry DocEntry *docElement = GetDocEntryByNumber(group, elem); if ( !docElement ) - { - return NULL; - } - size_t o =(size_t)docElement->GetOffset(); - Fp->seekg( o, std::ios_base::beg); - size_t l = docElement->GetLength(); - uint8_t* a = new uint8_t[l]; - if(!a) - { - dbg.Verbose(0, "Document::LoadEntryBinArea cannot allocate a"); - return NULL; - } - Fp->read((char*)a, l); - if( Fp->fail() || Fp->eof() )//Fp->gcount() == 1 - { - delete[] a; - return NULL; - } - /// \todo Drop any already existing void area! JPR - if( !SetEntryBinAreaByNumber( a, group, elem ) ) - { - dbg.Verbose(0, "Document::LoadEntryBinArea setting failed."); - } - return a; + return; + + BinEntry *binElement = dynamic_cast(docElement); + if( !binElement ) + return; + + LoadEntryBinArea(binElement); } + /** * \brief Loads (from disk) the element content * 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; + + bool openFile = !Fp; + if(openFile) + OpenFile(); + size_t o =(size_t)element->GetOffset(); - Fp->seekg(o, std::ios_base::beg); + Fp->seekg(o, std::ios::beg); + size_t l = element->GetLength(); uint8_t* a = new uint8_t[l]; if( !a ) { dbg.Verbose(0, "Document::LoadEntryBinArea cannot allocate a"); - return NULL; + return; } - element->SetBinArea((uint8_t*)a); + /// \todo check the result Fp->read((char*)a, l); if( Fp->fail() || Fp->eof()) //Fp->gcount() == 1 { delete[] a; - return NULL; + return; } - return a; + element->SetBinArea(a); + + if(openFile) + CloseFile(); } /** @@ -1105,7 +1053,7 @@ 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); @@ -1113,13 +1061,15 @@ bool Document::SetEntryBinAreaByNumber(uint8_t* area, { return false; } + if ( BinEntry* binEntry = dynamic_cast(currentEntry) ) { binEntry->SetBinArea( area ); return true; } - return true; -} + + return false; +}*/ /** * \brief Update the entries with the shadow dictionary. @@ -1238,9 +1188,12 @@ ValEntry* Document::GetValEntryByNumber(uint16_t group, uint16_t element) */ void Document::LoadDocEntrySafe(DocEntry * entry) { - long PositionOnEntry = Fp->tellg(); - LoadDocEntry(entry); - Fp->seekg(PositionOnEntry, std::ios_base::beg); + if(Fp) + { + long PositionOnEntry = Fp->tellg(); + LoadDocEntry(entry); + Fp->seekg(PositionOnEntry, std::ios::beg); + } } /** @@ -1317,10 +1270,10 @@ void Document::ParseDES(DocEntrySet *set, long offset, long l_max, bool delim_mode) { DocEntry *newDocEntry = 0; - + while (true) - { - if ( !delim_mode && (Fp->tellg()-offset) >= l_max) + { + if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) { break; } @@ -1338,7 +1291,7 @@ void Document::ParseDES(DocEntrySet *set, long offset, { /////////////////////// ValEntry ValEntry* newValEntry = - new ValEntry( newDocEntry->GetDictEntry() ); + new ValEntry( newDocEntry->GetDictEntry() ); //LEAK newValEntry->Copy( newDocEntry ); // When "set" is a Document, then we are at the top of the @@ -1357,14 +1310,22 @@ void Document::ParseDES(DocEntrySet *set, long offset, + newValEntry->GetKey() ); } - set->AddEntry( newValEntry ); LoadDocEntry( newValEntry ); - if (newValEntry->IsItemDelimitor()) + bool delimitor=newValEntry->IsItemDelimitor(); + if( !set->AddEntry( newValEntry ) ) + { + // If here expect big troubles + delete newValEntry; //otherwise mem leak + } + + if (delimitor) { + delete newDocEntry; break; } - if ( !delim_mode && (Fp->tellg()-offset) >= l_max) + if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) { + delete newDocEntry; break; } } @@ -1378,9 +1339,7 @@ void Document::ParseDES(DocEntrySet *set, long offset, } //////////////////// BinEntry or UNKOWN VR: - BinEntry* newBinEntry = - new BinEntry( newDocEntry->GetDictEntry() ); //LEAK - newBinEntry->Copy( newDocEntry ); + BinEntry* newBinEntry = new BinEntry( newDocEntry ); //LEAK // When "this" is a Document the Key is simply of the // form ( group, elem )... @@ -1398,8 +1357,12 @@ void Document::ParseDES(DocEntrySet *set, long offset, + newBinEntry->GetKey() ); } - set->AddEntry( newBinEntry ); LoadDocEntry( newBinEntry ); + if( !set->AddEntry( newBinEntry ) ) + { + //Expect big troubles if here + delete newBinEntry; + } } if ( ( newDocEntry->GetGroup() == 0x7fe0 ) @@ -1409,21 +1372,22 @@ void Document::ParseDES(DocEntrySet *set, long offset, if ( ts == RLELossless ) { long PositionOnEntry = Fp->tellg(); - Fp->seekg( newDocEntry->GetOffset(), std::ios_base::beg ); + Fp->seekg( newDocEntry->GetOffset(), std::ios::beg ); ComputeRLEInfo(); - Fp->seekg( PositionOnEntry, std::ios_base::beg ); + Fp->seekg( PositionOnEntry, std::ios::beg ); } else if ( IsJPEG() ) { long PositionOnEntry = Fp->tellg(); - Fp->seekg( newDocEntry->GetOffset(), std::ios_base::beg ); + Fp->seekg( newDocEntry->GetOffset(), std::ios::beg ); ComputeJPEGFragmentInfo(); - Fp->seekg( PositionOnEntry, std::ios_base::beg ); + Fp->seekg( PositionOnEntry, std::ios::beg ); } } // Just to make sure we are at the beginning of next entry. SkipToNextDocEntry(newDocEntry); + //delete newDocEntry; } else { @@ -1473,8 +1437,9 @@ void Document::ParseDES(DocEntrySet *set, long offset, l, delim_mode); } set->AddEntry( newSeqEntry ); - if ( !delim_mode && (Fp->tellg()-offset) >= l_max) + if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) { + delete newDocEntry; break; } } @@ -1504,13 +1469,14 @@ void Document::ParseSQ( SeqEntry* seqEntry, { if ( newDocEntry->IsSequenceDelimitor() ) { - seqEntry->SetSequenceDelimitationItem( newDocEntry ); + seqEntry->SetSequenceDelimitationItem( newDocEntry ); break; } } - if ( !delim_mode && (Fp->tellg()-offset) >= l_max) + if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max) { - break; + delete newDocEntry; + break; } SQItem *itemSQ = new SQItem( seqEntry->GetDepthLevel() ); @@ -1532,10 +1498,11 @@ void Document::ParseSQ( SeqEntry* seqEntry, } ParseDES(itemSQ, newDocEntry->GetOffset(), l, dlm_mod); + delete newDocEntry; seqEntry->AddEntry( itemSQ, SQItemNumber ); SQItemNumber++; - if ( !delim_mode && ( Fp->tellg() - offset ) >= l_max ) + if ( !delim_mode && ((long)(Fp->tellg())-offset ) >= l_max ) { break; } @@ -1553,7 +1520,7 @@ void Document::LoadDocEntry(DocEntry* entry) std::string vr = entry->GetVR(); uint32_t length = entry->GetLength(); - Fp->seekg((long)entry->GetOffset(), std::ios_base::beg); + Fp->seekg((long)entry->GetOffset(), std::ios::beg); // A SeQuence "contains" a set of Elements. // (fffe e000) tells us an Element is beginning @@ -1588,7 +1555,7 @@ void Document::LoadDocEntry(DocEntry* entry) s << " x(" << std::hex << entry->GetLength() << ")"; binEntryPtr->SetValue(s.str()); } - // Be carefull : a BinEntry IS_A ValEntry ... + // Be carefull : a BinEntry IS_A ValEntry ... else if (ValEntry* valEntryPtr = dynamic_cast< ValEntry* >(entry) ) { // s << "gdcm::NotLoaded. (ValEntry)"; @@ -1607,7 +1574,7 @@ void Document::LoadDocEntry(DocEntry* entry) // to be sure we are at the end of the value ... Fp->seekg((long)entry->GetOffset()+(long)entry->GetLength(), - std::ios_base::beg); + std::ios::beg); return; } @@ -1735,7 +1702,7 @@ void Document::FindDocEntryLength( DocEntry *entry ) // The following reserved two bytes (see PS 3.5-2003, section // "7.1.2 Data element structure with explicit vr", p 27) must be // skipped before proceeding on reading the length on 4 bytes. - Fp->seekg( 2L, std::ios_base::cur); + Fp->seekg( 2L, std::ios::cur); uint32_t length32 = ReadInt32(); if ( (vr == "OB" || vr == "OW") && length32 == 0xffffffff ) @@ -1755,9 +1722,9 @@ void Document::FindDocEntryLength( DocEntry *entry ) // until the end of the file. Hence we artificially fix the // the length and proceed. long currentPosition = Fp->tellg(); - Fp->seekg(0L,std::ios_base::end); - long lengthUntilEOF = Fp->tellg() - currentPosition; - Fp->seekg(currentPosition, std::ios_base::beg); + Fp->seekg(0L,std::ios::end); + long lengthUntilEOF = (long)(Fp->tellg())-currentPosition; + Fp->seekg(currentPosition, std::ios::beg); entry->SetLength(lengthUntilEOF); return; } @@ -1869,13 +1836,12 @@ 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. - Fp->read (vr, (size_t)2); vr[2] = 0; if( !CheckDocEntryVR(entry, vr) ) { - Fp->seekg(positionOnEntry, std::ios_base::beg); + 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 @@ -1911,7 +1877,7 @@ bool Document::CheckDocEntryVR(DocEntry *entry, VRKey vr) // expected VR read happens to be non-ascii characters we consider // we hit falsely explicit VR tag. - if ( !isalpha(vr[0]) && !isalpha(vr[1]) ) + if ( !isalpha((unsigned char)vr[0]) && !isalpha((unsigned char)vr[1]) ) { realExplicit = false; } @@ -2120,8 +2086,8 @@ void Document::SkipDocEntry(DocEntry *entry) */ void Document::SkipToNextDocEntry(DocEntry *entry) { - Fp->seekg((long)(entry->GetOffset()), std::ios_base::beg); - Fp->seekg( (long)(entry->GetReadLength()), std::ios_base::cur); + Fp->seekg((long)(entry->GetOffset()), std::ios::beg); + Fp->seekg( (long)(entry->GetReadLength()), std::ios::cur); } /** @@ -2289,7 +2255,7 @@ uint32_t Document::FindDocEntryLengthOB() { dbg.Verbose(1, "Document::FindDocEntryLengthOB: neither an Item " "tag nor a Sequence delimiter tag."); - Fp->seekg(positionOnEntry, std::ios_base::beg); + Fp->seekg(positionOnEntry, std::ios::beg); throw FormatUnexpected("Document::FindDocEntryLengthOB()", "Neither an Item tag nor a Sequence " "delimiter tag."); @@ -2310,7 +2276,7 @@ uint32_t Document::FindDocEntryLengthOB() break; } } - Fp->seekg( positionOnEntry, std::ios_base::beg); + Fp->seekg( positionOnEntry, std::ios::beg); return totalLength; } @@ -2366,7 +2332,7 @@ uint32_t Document::ReadInt32() void Document::SkipBytes(uint32_t nBytes) { //FIXME don't dump the returned value - Fp->seekg((long)nBytes, std::ios_base::cur); + Fp->seekg((long)nBytes, std::ios::cur); } /** @@ -2379,6 +2345,7 @@ void Document::Initialise() RefShaDict = NULL; RLEInfo = new RLEFramesInfo; JPEGInfo = new JPEGFragmentsInfo; + Filetype = Unknown; } /** @@ -2401,7 +2368,7 @@ bool Document::CheckSwap() uint32_t s32; uint16_t s16; - char deb[256]; //HEADER_LENGTH_TO_READ]; + char deb[256]; // First, compare HostByteOrder and NetworkByteOrder in order to // determine if we shall need to swap bytes (i.e. the Endian type). @@ -2416,7 +2383,7 @@ bool Document::CheckSwap() // The easiest case is the one of a DICOM header, since it possesses a // file preamble where it suffice to look for the string "DICM". - Fp->read(deb, HEADER_LENGTH_TO_READ); + Fp->read(deb, 256); char *entCur = deb + 128; if( memcmp(entCur, "DICM", (size_t)4) == 0 ) @@ -2480,8 +2447,8 @@ 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_base::beg); - Fp->seekg ( 132L, std::ios_base::beg); + Fp->seekg(0, std::ios::beg); + Fp->seekg ( 132L, std::ios::beg); return true; } // End of DicomV3 @@ -2489,7 +2456,7 @@ bool Document::CheckSwap() // preamble. We can reset the file position indicator to where the data // is (i.e. the beginning of the file). dbg.Verbose(1, "Document::CheckSwap:", "not a DICOM Version3 file"); - Fp->seekg(0, std::ios_base::beg); + Fp->seekg(0, std::ios::beg); // 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. @@ -2501,7 +2468,7 @@ bool Document::CheckSwap() // representation of a 32 bits integer. Hence the following dirty // trick : s32 = *((uint32_t *)(entCur)); - + switch( s32 ) { case 0x00040000 : @@ -2526,13 +2493,13 @@ bool Document::CheckSwap() // So, let's check if this file wouldn't happen to be 'dirty' ACR/NEMA, // i.e. the 'group length' element is not present : - // check the supposed to be 'group number' - // 0x0002 or 0x0004 or 0x0008 + // check the supposed-to-be 'group number' + // in ( 0x0001 .. 0x0008 ) // to determine ' SwapCode' value . // Only 0 or 4321 will be possible // (no oportunity to check for the formerly well known // ACR-NEMA 'Bad Big Endian' or 'Bad Little Endian' - // if unsuccessfull (i.e. neither 0x0002 nor 0x0200 etc -4, 8-) + // if unsuccessfull (i.e. neither 0x0002 nor 0x0200 etc -3, 4, ..., 8-) // the file IS NOT ACR-NEMA nor DICOM V3 // Find a trick to tell it the caller... @@ -2540,22 +2507,32 @@ bool Document::CheckSwap() switch ( s16 ) { + case 0x0001 : case 0x0002 : + case 0x0003 : case 0x0004 : - case 0x0008 : + case 0x0005 : + case 0x0006 : + case 0x0007 : + case 0x0008 : SwapCode = 0; Filetype = ACR; return true; + case 0x0100 : case 0x0200 : + case 0x0300 : case 0x0400 : - case 0x0800 : + case 0x0500 : + case 0x0600 : + case 0x0700 : + case 0x0800 : SwapCode = 4321; Filetype = ACR; return true; default : dbg.Verbose(0, "Document::CheckSwap:", - "ACR/NEMA unfound swap info (Really hopeless !)"); - Filetype = Unknown; + "ACR/NEMA unfound swap info (Really hopeless !)"); + Filetype = Unknown; return false; } // Then the only info we have is the net2host one. @@ -2567,6 +2544,8 @@ bool Document::CheckSwap() } } + + /** * \brief Restore the unproperly loaded values i.e. the group, the element * and the dictionary entry depending on them. @@ -2634,6 +2613,34 @@ void Document::SetMaxSizePrintEntry(long newSize) +/** + * \brief Handle broken private tag from Philips NTSCAN + * where the endianess is being switch to BigEndian for no + * apparent reason + * @return no return + */ +void Document::HandleBrokenEndian(uint16_t group, uint16_t elem) +{ + // Endian reversion. Some files contain groups of tags with reversed endianess. + static int reversedEndian = 0; + // try to fix endian switching in the middle of headers + if ((group == 0xfeff) && (elem == 0x00e0)) + { + // start endian swap mark for group found + reversedEndian++; + SwitchSwapToBigEndian(); + // fix the tag + group = 0xfffe; + elem = 0xe000; + } + else if ((group == 0xfffe) && (elem == 0xe00d) && reversedEndian) + { + // end of reversed endian group + reversedEndian--; + SwitchSwapToBigEndian(); + } +} + /** * \brief Read the next tag but WITHOUT loading it's value * (read the 'Group Number', the 'Element Number', @@ -2659,6 +2666,7 @@ DocEntry* Document::ReadNextDocEntry() return 0; } + HandleBrokenEndian(group, elem); DocEntry *newEntry = NewDocEntryByNumber(group, elem); FindDocEntryVR(newEntry); @@ -2742,7 +2750,7 @@ bool Document::ReadTag(uint16_t testGroup, uint16_t testElement) s << " at address: " << (unsigned)currentPosition << std::endl; dbg.Verbose(0, "Document::ReadItemTagLength: wrong Item Tag found:"); dbg.Verbose(0, s.str().c_str()); - Fp->seekg(positionOnEntry, std::ios_base::beg); + Fp->seekg(positionOnEntry, std::ios::beg); return false; } @@ -2876,7 +2884,7 @@ void Document::ComputeRLEInfo() dbg.Verbose(0, "Document::ComputeRLEInfo: too many segments."); } - uint32_t rleSegmentOffsetTable[15]; + uint32_t rleSegmentOffsetTable[16]; for( int k = 1; k <= 15; k++ ) { rleSegmentOffsetTable[k] = ReadInt32(); @@ -3028,7 +3036,7 @@ void Document::BuildFlatHashTableRecurse( TagDocEntryHT& builtHT, * Document. * * The structure used by a Document (through \ref ElementSet), - * in order to old the parsed entries of a Dicom header, is a recursive + * in order to hold the parsed entries of a Dicom header, is a recursive * one. This is due to the fact that the sequences (when present) * can be nested. Additionaly, the sequence items (represented in * gdcm as \ref SQItem) add an extra complexity to the data