Program: gdcm
Module: $RCSfile: gdcmDocument.cxx,v $
Language: C++
- Date: $Date: 2004/10/22 13:56:45 $
- Version: $Revision: 1.110 $
+ Date: $Date: 2004/11/30 16:59:32 $
+ Version: $Revision: 1.144 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
#include <iomanip>
// For nthos:
-#ifdef _MSC_VER
+#if defined(_MSC_VER) || defined(__BORLANDC__)
#include <winsock.h>
#else
#include <netinet/in.h>
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
// 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
* \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;
Initialise();
+ Fp = 0;
if ( !OpenFile() )
{
return;
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
* \brief This default constructor doesn't parse the file. You should
* then invoke \ref Document::SetFileName and then the parsing.
*/
-Document::Document()
- :ElementSet(-1)
+Document::Document() : ElementSet(-1)
{
+ Fp = 0;
+
SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
Initialise();
+ SwapCode = 0;
+ Filetype = ExplicitVR;
PrintLevel = 1; // 'Medium' print level by default
}
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;
}
//-----------------------------------------------------------------------------
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()
{
// 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);
}
*/
std::ifstream* Document::OpenFile()
{
+ if (Filename.length() == 0) return 0;
+ if(Fp)
+ {
+ dbg.Verbose( 0,
+ "Document::OpenFile is already opened when opening: ",
+ Filename.c_str());
+ }
+
Fp = new std::ifstream(Filename.c_str(), std::ios::in | std::ios::binary);
if(!Fp)
uint16_t zero;
Fp->read((char*)&zero, (size_t)2 );
- //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( memcmp(dicm, "DICM", 4) == 0 )
return Fp;
}
- Fp->close();
+ CloseFile();
dbg.Verbose( 0,
"Document::OpenFile not DICOM/ACR (missing preamble)",
Filename.c_str());
*/
bool Document::CloseFile()
{
- Fp->close();
- delete Fp;
- Fp = 0;
+ if( Fp )
+ {
+ Fp->close();
+ delete Fp;
+ Fp = 0;
+ }
- return true; //FIXME how do we detect a non-close ifstream ?
+ return true; //FIXME how do we detect a non-close ifstream ?
}
/**
* (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)
+ if ( filetype == ImplicitVR || filetype == ExplicitVR )
{
- std::string ts = 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)
- {
- std::string ts = TransferSyntaxStrings[ExplicitVRLittleEndian];
- 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
- /// 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
* UpdateGroupLength(true,ACR);
*/
- ElementSet::Write(fp, filetype); // This one is recursive
-
+ ElementSet::WriteContent(fp, filetype); // This one is recursive
}
/**
* @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).
*/
std::string const & value,
uint16_t group,
uint16_t elem,
- std::string const & VR )
+ TagName const & vr )
{
ValEntry* valEntry = 0;
DocEntry* currentEntry = GetDocEntryByNumber( group, elem);
DictEntry* dictEntry = pubDict->GetDictEntryByNumber(group, elem);
if (!dictEntry)
{
- currentEntry = NewDocEntryByNumber(group, elem,VR);
+ currentEntry = NewDocEntryByNumber(group, elem, vr);
}
else
{
" 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;
}
}
else
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;
/*
* \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
int lgth,
uint16_t group,
uint16_t elem,
- std::string const& VR )
+ TagName const & vr )
{
BinEntry* binEntry = 0;
DocEntry* currentEntry = GetDocEntryByNumber( group, elem);
if (!dictEntry)
{
- currentEntry = NewDocEntryByNumber(group, elem, VR);
+ currentEntry = NewDocEntryByNumber(group, elem, vr);
}
else
{
}
}
- 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;
}
* \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);
* \return boolean
*/
bool Document::ReplaceIfExistByNumber(std::string const & value,
- uint16_t group, uint16_t elem )
+ uint16_t group, uint16_t elem )
{
SetEntryByNumber(value, group, elem);
return true;
}
+std::string Document::GetTransferSyntaxValue(TransferSyntaxType type)
+{
+ return TransferSyntaxStrings[type];
+}
+
//-----------------------------------------------------------------------------
// Protected
bool Document::CheckIfEntryExistByNumber(uint16_t group, uint16_t element )
{
const std::string &key = DictEntry::TranslateToKey(group, element );
- return TagHT.count(key);
+ return TagHT.count(key) != 0;
}
/**
* @return Corresponding element value when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-std::string Document::GetEntryByName(TagName const& tagName)
+std::string Document::GetEntryByName(TagName const & tagName)
{
DictEntry* dictEntry = RefPubDict->GetDictEntryByName(tagName);
if( !dictEntry )
}
DocEntry* elem = GetDocEntryByNumber(dictEntry->GetGroup(),
- dictEntry->GetElement());
+ dictEntry->GetElement());
return elem->GetVR();
}
* @param tagName name of the searched Dicom Element.
* @return true when found
*/
-bool Document::SetEntryByName(std::string const & content,std::string const & tagName)
+bool Document::SetEntryByName( std::string const & content,
+ TagName const & tagName)
{
DictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName);
if( !dictEntry )
* @param element element number of the Dicom Element to modify
*/
bool Document::SetEntryByNumber(std::string const& content,
- uint16_t group,
- uint16_t element)
+ uint16_t group, uint16_t element)
{
int c;
int l;
return false;
}
// Non even content must be padded with a space (020H)...
- std::string finalContent = content;
- if( finalContent.length() % 2 )
- {
- finalContent += '\0'; // ... therefore we padd with (000H) .!?!
- }
+ 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();
* @param group group number of the Dicom Element to modify
* @param element element number of the Dicom Element to modify
*/
-bool Document::SetEntryByNumber(uint8_t*content,
- int lgth,
- uint16_t group,
- uint16_t element)
+bool Document::SetEntryByNumber(uint8_t*content, int lgth,
+ uint16_t group, uint16_t element)
{
(void)lgth; //not used
TagKey key = DictEntry::TranslateToKey(group, element);
//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;
}
* @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)
+/*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);
( ((TagHT.equal_range(key)).first)->second )->SetLength(l);
return true ;
-}
+}*/
/**
* \brief Gets (from Header) the offset of a 'non string' element value
* @param elem element number of the Entry
* @return File Offset of the Element Value
*/
-size_t Document::GetEntryOffsetByNumber(uint16_t group, uint16_t elem)
+/*size_t Document::GetEntryOffsetByNumber(uint16_t group, uint16_t elem)
{
DocEntry* entry = GetDocEntryByNumber(group, elem);
if (!entry)
return 0;
}
return entry->GetOffset();
-}
+}*/
/**
* \brief Gets (from Header) a 'non string' element value
* @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<BinEntry *>(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();
}
/**
* @param element Element number of the searched Dicom Element
* @return
*/
-bool Document::SetEntryBinAreaByNumber(uint8_t* area,
- uint16_t group,
- uint16_t element)
+/*bool Document::SetEntryBinAreaByNumber(uint8_t* area,
+ uint16_t group, uint16_t element)
{
DocEntry* currentEntry = GetDocEntryByNumber(group, element);
if ( !currentEntry )
{
return false;
}
+
if ( BinEntry* binEntry = dynamic_cast<BinEntry*>(currentEntry) )
{
binEntry->SetBinArea( area );
return true;
}
- return true;
-}
+
+ return false;
+}*/
/**
* \brief Update the entries with the shadow dictionary.
* @return Corresponding Dicom Element when it exists, and NULL
* otherwise.
*/
-DocEntry* Document::GetDocEntryByName(std::string const & tagName)
+DocEntry* Document::GetDocEntryByName(TagName const & tagName)
{
DictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName);
if( !dictEntry )
* @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))
* 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);
if ( !currentEntry )
*/
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);
+ }
}
/**
* \brief Parses a DocEntrySet (Zero-level DocEntries or SQ Item DocEntries)
* @return length of the parsed set.
*/
-void Document::ParseDES(DocEntrySet *set,
- long offset,
- long l_max,
- bool delim_mode)
+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;
}
{
/////////////////////// 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
+ 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;
}
}
}
//////////////////// BinEntry or UNKOWN VR:
- BinEntry* newBinEntry =
- new BinEntry( newDocEntry->GetDictEntry() );
- newBinEntry->Copy( newDocEntry );
+ BinEntry* newBinEntry = new BinEntry( newDocEntry ); //LEAK
// When "this" is a Document the Key is simply of the
// form ( group, elem )...
+ newBinEntry->GetKey() );
}
- set->AddEntry( newBinEntry );
LoadDocEntry( newBinEntry );
+ if( !set->AddEntry( newBinEntry ) )
+ {
+ //Expect big troubles if here
+ delete newBinEntry;
+ }
}
if ( ( newDocEntry->GetGroup() == 0x7fe0 )
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
{
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;
}
}
* @return parsed length for this level
*/
void Document::ParseSQ( SeqEntry* seqEntry,
- long offset, long l_max, bool delim_mode)
+ long offset, long l_max, bool delim_mode)
{
int SQItemNumber = 0;
bool dlm_mod;
{
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() );
}
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;
}
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
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)";
}
// to be sure we are at the end of the value ...
- Fp->seekg((long)entry->GetOffset()+(long)entry->GetLength(),std::ios_base::beg);
+ Fp->seekg((long)entry->GetOffset()+(long)entry->GetLength(),
+ std::ios::beg);
return;
}
return;
}
- // We need an additional byte for storing \0 that is not on disk
+ // FIXME: We need an additional byte for storing \0 that is not on disk
char *str = new char[length+1];
Fp->read(str, (size_t)length);
- str[length] = '\0';
- std::string newValue = str;
+ 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 )
+ {
+ newValue = Util::DicomString(str, length+1);
+ //dbg.Verbose(0, "Warning: bad length: ", length );
+ dbg.Verbose(0, "For string :", newValue.c_str());
+ // Since we change the length of string update it length
+ entry->SetReadLength(length+1);
+ }
+ else
+ {
+ newValue = Util::DicomString(str, length);
+ }
delete[] str;
if ( ValEntry* valEntry = dynamic_cast<ValEntry* >(entry) )
- {
+ {
if ( Fp->fail() || Fp->eof())//Fp->gcount() == 1
{
dbg.Verbose(1, "Document::LoadDocEntry",
// 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 )
// 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;
}
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
// 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;
}
*/
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);
}
/**
* @param foundLength fist assumption about length
*/
void Document::FixDocEntryFoundLength(DocEntry *entry,
- uint32_t foundLength)
+ uint32_t foundLength)
{
entry->SetReadLength( foundLength ); // will be updated only if a bug is found
if ( foundLength == 0xffffffff)
{
uint16_t element = entry->GetElement();
uint16_t group = entry->GetGroup();
- 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
{
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.");
break;
}
}
- Fp->seekg( positionOnEntry, std::ios_base::beg);
+ Fp->seekg( positionOnEntry, std::ios::beg);
return totalLength;
}
Fp->read ((char*)&g, (size_t)2);
if ( Fp->fail() )
{
- throw FormatError( "Document::ReadInt16()", " file error." );
+ throw FormatError( "Document::ReadInt16()", " file error." );
}
if( Fp->eof() )
{
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);
}
/**
uint32_t s32;
uint16_t s16;
- char deb[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).
// 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 )
// 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
// 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.
// representation of a 32 bits integer. Hence the following dirty
// trick :
s32 = *((uint32_t *)(entCur));
-
+
switch( s32 )
{
case 0x00040000 :
// 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...
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.
}
}
+
+
/**
* \brief Restore the unproperly loaded values i.e. the group, the element
* and the dictionary entry depending on them.
+/**
+ * \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',
return 0;
}
+ HandleBrokenEndian(group, elem);
DocEntry *newEntry = NewDocEntryByNumber(group, elem);
FindDocEntryVR(newEntry);
//// Read the Item Tag group and element, and make
// sure they are what we expected:
- uint16_t itemTagGroup = ReadInt16();
- uint16_t itemTagElement = ReadInt16();
+ uint16_t itemTagGroup;
+ uint16_t itemTagElement;
+ try
+ {
+ itemTagGroup = ReadInt16();
+ itemTagElement = ReadInt16();
+ }
+ catch ( FormatError e )
+ {
+ //std::cerr << e << std::endl;
+ return false;
+ }
if ( itemTagGroup != testGroup || itemTagElement != testElement )
{
std::ostringstream s;
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;
}
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();
* @param set The structure to be traversed (recursively).
*/
void Document::BuildFlatHashTableRecurse( TagDocEntryHT& builtHT,
- DocEntrySet* set )
+ DocEntrySet* set )
{
if (ElementSet* elementSet = dynamic_cast< ElementSet* > ( set ) )
{
- TagDocEntryHT* currentHT = elementSet->GetTagHT();
- for( TagDocEntryHT::const_iterator i = currentHT->begin();
- i != currentHT->end();
+ TagDocEntryHT const & currentHT = elementSet->GetTagHT();
+ for( TagDocEntryHT::const_iterator i = currentHT.begin();
+ i != currentHT.end();
++i)
{
DocEntry* entry = i->second;
if ( SeqEntry* seqEntry = dynamic_cast<SeqEntry*>(entry) )
{
- ListSQItem& items = seqEntry->GetSQItems();
+ const ListSQItem& items = seqEntry->GetSQItems();
for( ListSQItem::const_iterator item = items.begin();
item != items.end();
++item)
if (SQItem* SQItemSet = dynamic_cast< SQItem* > ( set ) )
{
- ListDocEntry& currentList = SQItemSet->GetDocEntries();
- for (ListDocEntry::iterator i = currentList.begin();
- i != currentList.end();
- ++i)
+ const ListDocEntry& currentList = SQItemSet->GetDocEntries();
+ for (ListDocEntry::const_iterator i = currentList.begin();
+ i != currentList.end();
+ ++i)
{
DocEntry* entry = *i;
if ( SeqEntry* seqEntry = dynamic_cast<SeqEntry*>(entry) )
{
- ListSQItem& items = seqEntry->GetSQItems();
+ const ListSQItem& items = seqEntry->GetSQItems();
for( ListSQItem::const_iterator item = items.begin();
item != items.end();
++item)
* 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
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff