Program: gdcm
Module: $RCSfile: gdcmDocument.cxx,v $
Language: C++
- Date: $Date: 2005/07/02 16:51:16 $
- Version: $Revision: 1.253 $
+ Date: $Date: 2005/08/24 12:09:13 $
+ Version: $Revision: 1.267 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
// Load will set it to true if sucessfull
Group0002Parsed = false;
IsDocumentAlreadyLoaded = false;
+ IsDocumentModified = true;
LoadMode = 0x00000000; // default : load everything, later
+ SetFileName("");
}
/**
- * \brief Constructor (not to break the API)
+ * \brief Constructor (DEPRECATED : not to break the API)
* @param fileName 'Document' (File or DicomDir) to be open for parsing
*/
Document::Document( std::string const &fileName )
SwapCode = 1234;
Filetype = ExplicitVR;
Group0002Parsed = false;
- LoadMode = 0x00000000; // Load everything
+ LoadMode = 0x00000000; // Load everything, later
// Load will set it to true if sucessfull
IsDocumentAlreadyLoaded = false;
+ IsDocumentModified = true;
- Load(fileName);
+ SetFileName(fileName);
+ Load( );
}
/**
* \brief Canonical destructor.
// Public
/**
- * \brief Loader
- * @param fileName 'Document' (File or DicomDir) to be open for parsing
+ * \brief Loader. use SetLoadMode(), SetFileName() before !
* @return false if file cannot be open or no swap info was found,
* or no tag was found.
*/
-bool Document::Load( std::string const &fileName )
+bool Document::Load( )
{
- // We should clean out anything that already exists.
- // Check IsDocumentAlreadyLoaded to be sure.
- if ( IsDocumentAlreadyLoaded )
+ if ( GetFileName() == "" )
{
- gdcmWarningMacro( "A file was already parsed inside this "
- << "gdcm::Document (previous name was: "
- << Filename.c_str() << ". New name is :"
- << fileName );
- // todo : clean out the 'Document'
- // Should we call ClearEntry() on the parent object ?!?
+ gdcmWarningMacro( "Use SetFileName, before !" );
+ return false;
}
-
+ return DoTheLoadingDocumentJob( );
+}
+/**
+ * \brief Loader. (DEPRECATED : not to break the API)
+ * @param fileName 'Document' (File or DicomDir) to be open for parsing
+ * @return false if file cannot be open or no swap info was found,
+ * or no tag was found.
+ */
+bool Document::Load( std::string const &fileName )
+{
Filename = fileName;
+ return DoTheLoadingDocumentJob( );
+}
+
+/**
+ * \brief Performs the Loading Job (internal use only)
+ * @return false if file cannot be open or no swap info was found,
+ * or no tag was found.
+ */
+bool Document::DoTheLoadingDocumentJob( )
+{
+ if ( ! IsDocumentModified ) // Nothing to do !
+ return true;
+
+ // if ( Filename == fileName )
+ // {
+ // gdcmWarningMacro( "The file was already parsed inside this "
+ // << "gdcm::Document (its name is: "
+ // << Filename.c_str() );
+ // return true;
+ // }
+
+ //gdcmWarningMacro( "A file was already parsed inside this "
+ // << "gdcm::Document (previous name was: "
+ // << Filename.c_str() << ". New name is :"
+ // << fileName );
+ // clean out the Entries, if already parsed
+ // (probabely a mistake from the user)
+
+ ClearEntry();
Fp = 0;
if ( !OpenFile() )
lgt -= beg; // remaining length to parse
- ParseDES( this, beg, lgt, false); // Loading is done during parsing
+ // Recursive call.
+ // Loading is done during parsing
+ ParseDES( this, beg, lgt, false); // delim_mode is first defaulted to false
if ( IsEmpty() )
{
/// altered on PURPOSE but now contains a WRONG value.
/// In order to fix things and restore the dictionary to its
/// correct value, one needs to decided of the semantics by deciding
- /// whether the following tags are either:
+ /// whether the following tags are either :
/// - multivaluated US, and hence loaded as ValEntry, but afterwards
/// also used as BinEntry, which requires the proper conversion,
/// - OW, and hence loaded as BinEntry, but afterwards also used
// ----------------------------
// Specific code to allow gdcm to read ACR-LibIDO formated images
// Note: ACR-LibIDO is an extension of the ACR standard that was
- // used at CREATIS. For the time being (say a couple years)
+ // used at CREATIS. For the time being (say a couple of years)
// we keep this kludge to allow CREATIS users
// reading their old images.
//
/**
* \brief Parses a DocEntrySet (Zero-level DocEntries or SQ Item DocEntries)
- * @param set DocEntrySet we are going to parse ('zero level' or a SQItem)
+ * @param set DocEntrySet we are going to parse ('zero level' or a SQItem)
* @param offset start of parsing
- * @param l_max length to parse
+ * @param l_max length to parse (meaningless when we are in 'delimitor mode')
* @param delim_mode : whether we are in 'delimitor mode' (l=0xffffff) or not
*/
void Document::ParseDES(DocEntrySet *set, long offset,
SeqEntry *newSeqEntry;
VRKey vr;
bool used;
-
+ bool delim_mode_intern = delim_mode;
+ bool first = true;
while (true)
{
if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max)
break;
}
- used = true;
newDocEntry = ReadNextDocEntry( );
+ // Uncoment this printf line to be able to 'follow' the DocEntries
+ // when something *very* strange happens
+
+ printf( "%04x|%04x %s\n",newDocEntry->GetGroup(),
+ newDocEntry->GetElement(),
+ newDocEntry->GetVR().c_str() );
+
if ( !newDocEntry )
{
break;
}
- vr = newDocEntry->GetVR();
+ // an Item Starter found elsewhere but the first postition
+ // of a SeqEntry means previous entry was a Sequence
+ // but we didn't get it (private Sequence + Implicit VR)
+ // we have to backtrack.
+ if ( !first && newDocEntry->IsItemStarter() )
+ {
+ newDocEntry = Backtrack(newDocEntry);
+ }
+ else
+ {
+ PreviousDocEntry = newDocEntry;
+ }
+
+ used = true;
newValEntry = dynamic_cast<ValEntry*>(newDocEntry);
newBinEntry = dynamic_cast<BinEntry*>(newDocEntry);
- newSeqEntry = dynamic_cast<SeqEntry*>(newDocEntry);
- if ( newValEntry || newBinEntry )
+ if ( newValEntry || newBinEntry )
{
+ //////////////////////////// ContentEntry
if ( newBinEntry )
{
+ vr = newDocEntry->GetVR();
if ( Filetype == ExplicitVR &&
!Global::GetVR()->IsVROfBinaryRepresentable(vr) )
{
}
//////////////////// BinEntry or UNKOWN VR:
+
// When "this" is a Document the Key is simply of the
// form ( group, elem )...
if ( dynamic_cast< Document* > ( set ) )
// but when "this" is a SQItem, we are inserting this new
// valEntry in a sequence item, and the key has the
// generalized form (refer to \ref BaseTagKey):
- if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) )
- {
- newBinEntry->SetKey( parentSQItem->GetBaseTagKey()
- + newBinEntry->GetKey() );
- }
- LoadDocEntry( newBinEntry );
+ // time waste hunting
+ //if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) )
+ //{
+ // newBinEntry->SetKey( parentSQItem->GetBaseTagKey()
+ // + newBinEntry->GetKey() );
+ //}
+
if ( !set->AddEntry( newBinEntry ) )
{
- //Expect big troubles if here
- //delete newBinEntry;
- used=false;
+ gdcmWarningMacro( "in ParseDES : cannot add a BinEntry "
+ << newBinEntry->GetKey()
+ << " (at offset : "
+ << newBinEntry->GetOffset() << " )" );
+ used=false;
}
- }
+ else
+ {
+ // Load only if we can add (not a duplicate key)
+ LoadDocEntry( newBinEntry );
+ }
+ } // end BinEntry
else
{
/////////////////////// ValEntry
// ...but when "set" is a SQItem, we are inserting this new
// valEntry in a sequence item. Hence the key has the
// generalized form (refer to \ref BaseTagKey):
- if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) )
+
+ // time waste hunting
+ //if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) )
+ //{
+ // newValEntry->SetKey( parentSQItem->GetBaseTagKey()
+ // + newValEntry->GetKey() );
+ //}
+
+ if ( !set->AddEntry( newValEntry ) )
{
- newValEntry->SetKey( parentSQItem->GetBaseTagKey()
- + newValEntry->GetKey() );
+ gdcmWarningMacro( "in ParseDES : cannot add a ValEntry "
+ << newValEntry->GetKey()
+ << " (at offset : "
+ << newValEntry->GetOffset() << " )" );
+ used=false;
+ }
+ else
+ {
+ // Load only if we can add (not a duplicate key)
+ LoadDocEntry( newValEntry );
}
-
- LoadDocEntry( newValEntry );
- bool delimitor=newValEntry->IsItemDelimitor();
- if ( LoadMode & NO_SHADOW ) // User asked to skip, if possible,
- // shadow groups ( if possible :
- // whether element 0x0000 exits)
+ if ( newValEntry->GetElement() == 0x0000 ) // if on group length
{
- if ( newValEntry->GetGroup()%2 != 0 )
+ if ( newValEntry->GetGroup()%2 != 0 ) // if Shadow Group
{
- if ( newValEntry->GetElement() == 0x0000 )
+ if ( LoadMode & NO_SHADOW ) // if user asked to skip shad.gr
{
std::string strLgrGroup = newValEntry->GetValue();
int lgrGroup;
lgrGroup = atoi(strLgrGroup.c_str());
Fp->seekg(lgrGroup, std::ios::cur);
used = false;
+ RemoveEntry( newDocEntry );
+ newDocEntry = 0;
continue;
}
}
}
}
- if ( !set->AddEntry( newValEntry ) )
- {
- // If here expect big troubles
- // delete newValEntry; //otherwise mem leak
- used=false;
- }
+ bool delimitor=newValEntry->IsItemDelimitor();
- if (delimitor)
- {
- if ( !used )
- delete newDocEntry;
- break;
- }
- if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max )
+ if ( (delimitor) ||
+ (!delim_mode && ((long)(Fp->tellg())-offset) >= l_max) )
{
if ( !used )
delete newDocEntry;
/////////////////////// SeqEntry : VR = "SQ"
unsigned long l = newDocEntry->GetReadLength();
- if ( l != 0 ) // don't mess the delim_mode for zero-length sequence
+ if ( l != 0 ) // don't mess the delim_mode for 'zero-length sequence'
{
if ( l == 0xffffffff )
{
- delim_mode = true;
+ delim_mode_intern = true;
}
else
{
- delim_mode = false;
+ delim_mode_intern = false;
}
}
-
- if ( (LoadMode & NO_SHADOWSEQ) && ! delim_mode )
- {
- // User asked to skip SQ only if they belong to Shadow group
- if ( newDocEntry->GetGroup()%2 != 0 )
- {
- Fp->seekg( l, std::ios::cur);
- used = false;
- continue;
- }
- }
-
- if ( (LoadMode & NO_SEQ) && ! delim_mode )
+
+ if ( (LoadMode & NO_SHADOWSEQ) && ! delim_mode_intern )
+ {
+ // User asked to skip SeQuences *only* if they belong to Shadow Group
+ if ( newDocEntry->GetGroup()%2 != 0 )
+ {
+ Fp->seekg( l, std::ios::cur);
+ used = false;
+ continue;
+ }
+ }
+ if ( (LoadMode & NO_SEQ) && ! delim_mode_intern )
{
// User asked to skip *any* SeQuence
Fp->seekg( l, std::ios::cur);
used = false;
continue;
- }
+ }
+ // delay the dynamic cast as late as possible
+ newSeqEntry = dynamic_cast<SeqEntry*>(newDocEntry);
- // no other way to create it ...
- newSeqEntry->SetDelimitorMode( delim_mode );
+ // no other way to create the Delimitor ...
+ newSeqEntry->SetDelimitorMode( delim_mode_intern );
// At the top of the hierarchy, stands a Document. When "set"
// is a Document, then we are building the first depth level.
// But when "set" is already a SQItem, we are building a nested
// sequence, and hence the depth level of the new SeqEntry
// we are building, is one level deeper:
+
+ // time waste hunting
if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) )
{
newSeqEntry->SetDepthLevel( parentSQItem->GetDepthLevel() + 1 );
- newSeqEntry->SetKey( parentSQItem->GetBaseTagKey()
- + newSeqEntry->GetKey() );
+
+ // newSeqEntry->SetKey( parentSQItem->GetBaseTagKey()
+ // + newSeqEntry->GetKey() );
}
if ( l != 0 )
{ // Don't try to parse zero-length sequences
ParseSQ( newSeqEntry,
newDocEntry->GetOffset(),
- l, delim_mode);
+ l, delim_mode_intern);
}
if ( !set->AddEntry( newSeqEntry ) )
{
+ gdcmWarningMacro( "in ParseDES : cannot add a SeqEntry "
+ << newSeqEntry->GetKey()
+ << " (at offset : "
+ << newSeqEntry->GetOffset() << " )" );
used = false;
}
-
+
if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max)
{
if ( !used )
- delete newDocEntry;
- break;
+ delete newDocEntry;
+ break;
}
- }
+ } // end SeqEntry : VR = "SQ"
if ( !used )
+ {
delete newDocEntry;
- }
+ }
+ first = false;
+ } // end While
}
/**
if ( !newDocEntry )
{
// FIXME Should warn user
+ gdcmWarningMacro("in ParseSQ : should never get here!");
break;
}
if ( delim_mode )
}
// create the current SQItem
SQItem *itemSQ = new SQItem( seqEntry->GetDepthLevel() );
+/*
std::ostringstream newBase;
newBase << seqEntry->GetKey()
<< "/"
<< SQItemNumber
<< "#";
itemSQ->SetBaseTagKey( newBase.str() );
+*/
unsigned int l = newDocEntry->GetReadLength();
if ( l == 0xffffffff )
delete newDocEntry;
Fp->seekg(offsetStartCurrentSQItem, std::ios::beg);
// fill up the current SQItem, starting at the beginning of fff0,e000
+
ParseDES(itemSQ, offsetStartCurrentSQItem, l+8, dlm_mod);
+
offsetStartCurrentSQItem = Fp->tellg();
// end try -----------------
}
}
+/**
+ * \brief When a private Sequence + Implicit VR is encountered
+ * we cannot guess it's a Sequence till we find the first
+ * Item Starter. We then backtrack to do the job.
+ * @param docEntry Item Starter that warned us
+ */
+DocEntry *Document::Backtrack(DocEntry *docEntry)
+{
+ // delete the Item Starter, built erroneously out of any Sequence
+ // it's not yet in the HTable/chained list
+ delete docEntry;
+
+ // Get all info we can from PreviousDocEntry
+ uint16_t group = PreviousDocEntry->GetGroup();
+ uint16_t elem = PreviousDocEntry->GetElement();
+ uint32_t lgt = PreviousDocEntry->GetLength();
+ long offset = PreviousDocEntry->GetOffset();
+
+ gdcmWarningMacro( "Backtrack :" << std::hex << group
+ << "|" << elem
+ << " at offset " << offset );
+ RemoveEntry( PreviousDocEntry );
+
+ // forge the Seq Entry
+ DocEntry *newEntry = NewSeqEntry(group, elem);
+ newEntry->SetLength(lgt);
+ newEntry->SetOffset(offset);
+
+ // Move back to the beginning of the Sequence
+ Fp->seekg( 0, std::ios::beg);
+ Fp->seekg(offset, std::ios::cur);
+
+return newEntry;
+}
+
/**
* \brief Loads the element content if its length doesn't exceed
* the value specified with Document::SetMaxSizeLoadEntry()
}
// The elements whose length is bigger than the specified upper bound
- // are not loaded. Instead we leave a short notice of the offset of
+ // are not loaded. Instead we leave a short notice on the offset of
// the element content and it's length.
std::ostringstream s;
*/
void Document::SkipToNextDocEntry(DocEntry *currentDocEntry)
{
- Fp->seekg((long)(currentDocEntry->GetOffset()), std::ios::beg);
+ int l = currentDocEntry->GetReadLength();
+ if ( l == -1 ) // length = 0xffff shouldn't appear here ...
+ // ... but PMS imagers happen !
+ return;
+ Fp->seekg((long)(currentDocEntry->GetOffset()), std::ios::beg);
if (currentDocEntry->GetGroup() != 0xfffe) // for fffe pb
+ {
Fp->seekg( (long)(currentDocEntry->GetReadLength()),std::ios::cur);
+ }
}
/**
}
/**
- * \brief Read the next tag but WITHOUT loading it's value
+ * \brief Read the next tag WITHOUT loading it's value
* (read the 'Group Number', the 'Element Number',
* gets the Dict Entry
* gets the VR, gets the length, gets the offset value)
- * @return On succes the newly created DocEntry, NULL on failure.
+ * @return On succes : the newly created DocEntry, NULL on failure.
*/
DocEntry *Document::ReadNextDocEntry()
{
{
DictEntry *dictEntry = GetDictEntry(group,elem);
if ( dictEntry )
+ {
realVR = dictEntry->GetVR();
+ }
}
}
{
std::string msg;
int offset = Fp->tellg();
- msg = Util::Format("Entry (%04x,%04x) at %x should be Explicit VR\n",
+ msg = Util::Format("Entry (%04x,%04x) at 0x(%x) should be Explicit VR\n",
newEntry->GetGroup(), newEntry->GetElement(), offset );
gdcmWarningMacro( msg.c_str() );
}
}
newEntry->SetOffset(Fp->tellg());
-
+
return newEntry;
}
/**
* \brief Handle broken private tag from Philips NTSCAN
- * where the endianess is being switched to BigEndian for no
- * apparent reason
+ * where the endianess is being switched to BigEndian
+ * for no apparent reason
* @return no return
*/
void Document::HandleBrokenEndian(uint16_t &group, uint16_t &elem)
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff