Program: gdcm
Module: $RCSfile: gdcmDocument.cxx,v $
Language: C++
- Date: $Date: 2005/07/07 16:37:40 $
- Version: $Revision: 1.262 $
+ Date: $Date: 2005/08/30 15:13:09 $
+ Version: $Revision: 1.273 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
Group0002Parsed = false;
IsDocumentAlreadyLoaded = false;
IsDocumentModified = true;
- LoadMode = 0x00000000; // default : load everything, later
+ LoadMode = LD_ALL; // default : load everything, later
SetFileName("");
}
SwapCode = 1234;
Filetype = ExplicitVR;
Group0002Parsed = false;
- LoadMode = 0x00000000; // Load everything, later
+ LoadMode = LD_ALL; // Load everything, later
// Load will set it to true if sucessfull
IsDocumentAlreadyLoaded = false;
}
}
+ // Force Loading some more elements if user asked to.
+
+ gdcm::DocEntry *d;
+ for (ListElements::iterator it = UserForceLoadList.begin();
+ it != UserForceLoadList.end();
+ ++it)
+ {
+ d = GetDocEntry( (*it).Group, (*it).Elem);
+
+ if ( d == NULL)
+ continue;
+
+ if ( dynamic_cast<BinEntry *>(d) )
+ {
+ LoadDocEntry(d, true);
+ continue;
+ }
+
+ if ( dynamic_cast<BinEntry *>(d) )
+ {
+ LoadEntryBinArea((*it).Group, (*it).Elem);
+ continue;
+ }
+
+ if ( dynamic_cast<SeqEntry *>(d) )
+ {
+ gdcmWarningMacro( "You cannot 'ForceLoad' a SeqEntry ");
+ continue;
+ }
+ }
+
CloseFile();
// ----------------------------
SetValEntry(rows , 0x0028, 0x0011);
}
// --- End of ACR-LibIDO kludge ---
-
return true;
}
+
+/**
+ * \brief Adds a new element we want to load anyway
+ * @param group Group number of the target tag.
+ * @param elem Element number of the target tag.
+ */
+void Document::AddForceLoadElement (uint16_t group, uint16_t elem)
+{
+ Element el;
+ el.Group = group;
+ el.Elem = elem;
+ UserForceLoadList.push_back(el);
+}
/**
* \brief Get the public dictionary used
*/
uint8_t *a = new uint8_t[l];
if ( !a )
{
- gdcmWarningMacro( "Cannot allocate BinEntry content");
+ gdcmWarningMacro( "Cannot allocate BinEntry content for : "
+ << std::hex << elem->GetGroup()
+ << "|" << elem->GetElement() );
return;
}
VRKey vr;
bool used;
bool delim_mode_intern = delim_mode;
-
+ bool first = true;
while (true)
{
if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max)
newDocEntry = ReadNextDocEntry( );
+ // Uncoment this printf line to be able to 'follow' the DocEntries
+ // when something *very* strange happens
+
+ //printf( "%04x|%04x %s\n",newDocEntry->GetGroup(),
+ // newDocEntry->GetElement(),
+ // newDocEntry->GetVR().c_str() );
+
if ( !newDocEntry )
{
break;
}
+ // an Item Starter found elsewhere but the first postition
+ // of a SeqEntry means previous entry was a Sequence
+ // but we didn't get it (private Sequence + Implicit VR)
+ // we have to backtrack.
+ if ( !first && newDocEntry->IsItemStarter() )
+ {
+ newDocEntry = Backtrack(newDocEntry);
+ }
+ else
+ {
+ PreviousDocEntry = newDocEntry;
+ }
+
used = true;
newValEntry = dynamic_cast<ValEntry*>(newDocEntry);
newBinEntry = dynamic_cast<BinEntry*>(newDocEntry);
// When "this" is a Document the Key is simply of the
// form ( group, elem )...
- if ( dynamic_cast< Document* > ( set ) )
- {
- newBinEntry->SetKey( newBinEntry->GetKey() );
- }
+ //if ( set == this ) // ( dynamic_cast< Document* > ( set ) )
+ //{
+ // newBinEntry->SetKey( newBinEntry->GetKey() );
+ //}
// but when "this" is a SQItem, we are inserting this new
// valEntry in a sequence item, and the key has the
// generalized form (refer to \ref BaseTagKey):
if ( !set->AddEntry( newBinEntry ) )
{
gdcmWarningMacro( "in ParseDES : cannot add a BinEntry "
- << newBinEntry->GetKey() );
+ << newBinEntry->GetKey()
+ << " (at offset : "
+ << newBinEntry->GetOffset() << " )" );
used=false;
}
else
// When "set" is a Document, then we are at the top of the
// hierarchy and the Key is simply of the form ( group, elem )...
- if ( dynamic_cast< Document* > ( set ) )
- {
- newValEntry->SetKey( newValEntry->GetKey() );
- }
+ //if ( set == this ) // ( dynamic_cast< Document* > ( set ) )
+ //{
+ // newValEntry->SetKey( newValEntry->GetKey() );
+ //}
// ...but when "set" is a SQItem, we are inserting this new
// valEntry in a sequence item. Hence the key has the
// generalized form (refer to \ref BaseTagKey):
// + newValEntry->GetKey() );
//}
- if ( LoadMode & NO_SHADOW ) // User asked to skip, if possible,
- // shadow groups ( if possible :
- // whether element 0x0000 exits)
+ if ( !set->AddEntry( newValEntry ) )
+ {
+ gdcmWarningMacro( "in ParseDES : cannot add a ValEntry "
+ << newValEntry->GetKey()
+ << " (at offset : "
+ << newValEntry->GetOffset() << " )" );
+ used=false;
+ }
+ else
+ {
+ // Load only if we can add (not a duplicate key)
+ LoadDocEntry( newValEntry );
+ }
+
+ if ( 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 & LD_NOSHADOW ) // 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 ) )
- {
- gdcmWarningMacro( "in ParseDES : cannot add a ValEntry "
- << newValEntry->GetKey() );
- used=false;
- }
- else
- {
- // Load only if we can add (not a duplicate key)
- LoadDocEntry( newValEntry );
}
bool delimitor=newValEntry->IsItemDelimitor();
- if ( delimitor ||
+ if ( (delimitor) ||
(!delim_mode && ((long)(Fp->tellg())-offset) >= l_max) )
{
if ( !used )
}
}
- if ( (LoadMode & NO_SHADOWSEQ) && ! delim_mode_intern )
+ if ( (LoadMode & LD_NOSHADOWSEQ) && ! delim_mode_intern )
{
// User asked to skip SeQuences *only* if they belong to Shadow Group
if ( newDocEntry->GetGroup()%2 != 0 )
continue;
}
}
- if ( (LoadMode & NO_SEQ) && ! delim_mode_intern )
+ if ( (LoadMode & LD_NOSEQ) && ! delim_mode_intern )
{
// User asked to skip *any* SeQuence
Fp->seekg( l, std::ios::cur);
// is a Document, then we are building the first depth level.
// Hence the SeqEntry we are building simply has a depth
// level of one:
- if ( dynamic_cast< Document* > ( set ) )
+// SQItem *parentSQItem = dynamic_cast< SQItem* > ( set );
+ if ( set == this ) // ( dynamic_cast< Document* > ( set ) )
{
newSeqEntry->SetDepthLevel( 1 );
- newSeqEntry->SetKey( newSeqEntry->GetKey() );
+ // newSeqEntry->SetKey( newSeqEntry->GetKey() );
}
// But when "set" is already a SQItem, we are building a nested
// sequence, and hence the depth level of the new SeqEntry
// we are building, is one level deeper:
// time waste hunting
- if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) )
+ else if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) )
{
newSeqEntry->SetDepthLevel( parentSQItem->GetDepthLevel() + 1 );
if ( !set->AddEntry( newSeqEntry ) )
{
gdcmWarningMacro( "in ParseDES : cannot add a SeqEntry "
- << newSeqEntry->GetKey() );
+ << newSeqEntry->GetKey()
+ << " (at offset : "
+ << newSeqEntry->GetOffset() << " )" );
used = false;
}
- if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max)
+ if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max)
{
if ( !used )
- delete newDocEntry;
- break;
+ delete newDocEntry;
+ break;
}
} // end SeqEntry : VR = "SQ"
if ( !used )
+ {
delete newDocEntry;
+ }
+ first = false;
} // end While
}
}
/**
- * \brief Loads the element content if its length doesn't exceed
- * the value specified with Document::SetMaxSizeLoadEntry()
+ * \brief When a private Sequence + Implicit VR is encountered
+ * we cannot guess it's a Sequence till we find the first
+ * Item Starter. We then backtrack to do the job.
+ * @param docEntry Item Starter that warned us
+ */
+DocEntry *Document::Backtrack(DocEntry *docEntry)
+{
+ // delete the Item Starter, built erroneously out of any Sequence
+ // it's not yet in the HTable/chained list
+ delete docEntry;
+
+ // Get all info we can from PreviousDocEntry
+ uint16_t group = PreviousDocEntry->GetGroup();
+ uint16_t elem = PreviousDocEntry->GetElement();
+ uint32_t lgt = PreviousDocEntry->GetLength();
+ long offset = PreviousDocEntry->GetOffset();
+
+ gdcmWarningMacro( "Backtrack :" << std::hex << group
+ << "|" << elem
+ << " at offset " << offset );
+ RemoveEntry( PreviousDocEntry );
+
+ // forge the Seq Entry
+ DocEntry *newEntry = NewSeqEntry(group, elem);
+ newEntry->SetLength(lgt);
+ newEntry->SetOffset(offset);
+
+ // Move back to the beginning of the Sequence
+ Fp->seekg( 0, std::ios::beg);
+ Fp->seekg(offset, std::ios::cur);
+
+return newEntry;
+}
+
+/**
+ * \brief Loads (or not) the element content depending if its length exceeds
+ * or not the value specified with Document::SetMaxSizeLoadEntry()
* @param entry Header Entry (Dicom Element) to be dealt with
+ * @param forceLoad wheter we want to load its content even if its length
+ * exceeds the value specified with Document::SetMaxSizeLoadEntry()
*/
-void Document::LoadDocEntry(DocEntry *entry)
+void Document::LoadDocEntry(DocEntry *entry, bool forceLoad)
{
uint16_t group = entry->GetGroup();
std::string vr = entry->GetVR();
// the element content and it's length.
std::ostringstream s;
- if (length > MaxSizeLoadEntry)
- {
- if (BinEntry *binEntryPtr = dynamic_cast< BinEntry* >(entry) )
- {
- s << GDCM_NOTLOADED;
- s << " Ad.:" << (long)entry->GetOffset();
- s << " x(" << std::hex << entry->GetOffset() << ")";
- s << std::dec;
- s << " Lgt:" << entry->GetLength();
- s << " x(" << std::hex << entry->GetLength() << ")";
- binEntryPtr->SetValue(s.str());
- }
- else if (ValEntry *valEntryPtr = dynamic_cast< ValEntry* >(entry) )
- {
- s << GDCM_NOTLOADED;
- s << " Address:" << (long)entry->GetOffset();
- s << " Length:" << entry->GetLength();
- s << " x(" << std::hex << entry->GetLength() << ")";
- valEntryPtr->SetValue(s.str());
- }
- else
+
+ if (!forceLoad)
+ {
+ if (length > MaxSizeLoadEntry)
{
- // fusible
- gdcmErrorMacro( "MaxSizeLoadEntry exceeded, neither a BinEntry "
- << "nor a ValEntry ?! Should never print that !" );
- }
+ if (BinEntry *binEntryPtr = dynamic_cast< BinEntry* >(entry) )
+ {
+ s << GDCM_NOTLOADED;
+ s << " Ad.:" << (long)entry->GetOffset();
+ s << " x(" << std::hex << entry->GetOffset() << ")";
+ s << std::dec;
+ s << " Lgt:" << entry->GetLength();
+ s << " x(" << std::hex << entry->GetLength() << ")";
+ binEntryPtr->SetValue(s.str());
+ }
+ else if (ValEntry *valEntryPtr = dynamic_cast< ValEntry* >(entry) )
+ {
+ s << GDCM_NOTLOADED;
+ s << " Address:" << (long)entry->GetOffset();
+ s << " Length:" << entry->GetLength();
+ s << " x(" << std::hex << entry->GetLength() << ")";
+ valEntryPtr->SetValue(s.str());
+ }
+ else
+ {
+ // fusible
+ gdcmErrorMacro( "MaxSizeLoadEntry exceeded, neither a BinEntry "
+ << "nor a ValEntry ?! Should never print that !" );
+ }
- // to be sure we are at the end of the value ...
- Fp->seekg((long)entry->GetOffset()+(long)entry->GetLength(),
- std::ios::beg);
- return;
+ // to be sure we are at the end of the value ...
+ Fp->seekg((long)entry->GetOffset()+(long)entry->GetLength(),
+ std::ios::beg);
+ return;
+ }
}
// When we find a BinEntry not very much can be done :
*/
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);
+ }
}
/**
{
DictEntry *dictEntry = GetDictEntry(group,elem);
if ( dictEntry )
+ {
realVR = dictEntry->GetVR();
+ }
}
}
}
newEntry->SetOffset(Fp->tellg());
-
+
return newEntry;
}