Program: gdcm
Module: $RCSfile: gdcmDocument.cxx,v $
Language: C++
- Date: $Date: 2005/01/12 15:22:23 $
- Version: $Revision: 1.183 $
+ Date: $Date: 2005/01/17 11:03:28 $
+ Version: $Revision: 1.192 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
long beg = Fp->tellg();
lgt -= beg;
- ParseDES( this, beg, lgt, false); // le Load sera fait a la volee
+ ParseDES( this, beg, lgt, false); // Loading is done during parsing
Fp->seekg( 0, std::ios::beg);
/// FIXME FIXME FIXME
/// The tags refered by the three following lines used to be CORRECTLY
/// defined as having an US Value Representation in the public
- /// dictionnary. BUT the semantics implied by the three following
+ /// dictionary. BUT the semantics implied by the three following
/// lines state that the corresponding tag contents are in fact
/// the ones of a BinEntry.
- /// In order to fix things "Quick and Dirty" the dictionnary was
+ /// In order to fix things "Quick and Dirty" the dictionary was
/// 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
- /// wether 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
}
if( TagHT.empty() )
- {
+ {
gdcmVerboseMacro( "No tags in internal hash table.");
return false;
}
Fp = new std::ifstream(Filename.c_str(), std::ios::in | std::ios::binary);
if( ! *Fp )
{
- gdcmVerboseMacro( "Cannot open file: " << Filename.c_str());
+ gdcmDebugMacro( "Cannot open file: " << Filename.c_str());
delete Fp;
Fp = 0;
return 0;
* \brief Loads the element while preserving the current
* underlying file position indicator as opposed to
* to LoadDocEntry that modifies it.
- * @param entry Header Entry whose value shall be loaded.
+ * @param entry Header Entry whose value will be loaded.
* @return
*/
void Document::LoadDocEntrySafe(DocEntry *entry)
BinEntry *newBinEntry;
SeqEntry *newSeqEntry;
VRKey vr;
- bool used=false;
+ bool used = false;
while (true)
{
break;
}
- used=true;
+ used = true;
newDocEntry = ReadNextDocEntry( );
+
if ( !newDocEntry )
{
break;
//////////////////// 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 ) )
+ if (/*Document *dummy =*/ dynamic_cast< Document* > ( set ) )
{
- (void)dummy;
+ //(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
+ // valEntry in a sequence item, and the key has the
// generalized form (refer to \ref BaseTagKey):
if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) )
{
/////////////////////// ValEntry
// 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;
+ //(void)dummy;
newValEntry->SetKey( newValEntry->GetKey() );
}
// ...but when "set" is a SQItem, we are inserting this new
// 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;
+ //(void)dummy;
newSeqEntry->SetDepthLevel( 1 );
newSeqEntry->SetKey( newSeqEntry->GetKey() );
}
{
int SQItemNumber = 0;
bool dlm_mod;
+ long offsetStartCurrentSQItem = offset;
while (true)
{
- DocEntry *newDocEntry = ReadNextDocEntry();
+ // the first time, we read the fff0,e000 of the first SQItem
+ DocEntry *newDocEntry = ReadNextDocEntry();
+
if ( !newDocEntry )
{
// FIXME Should warn user
delete newDocEntry;
break;
}
-
+ // create the current SQItem
SQItem *itemSQ = new SQItem( seqEntry->GetDepthLevel() );
std::ostringstream newBase;
newBase << seqEntry->GetKey()
{
dlm_mod = false;
}
-
- ParseDES(itemSQ, newDocEntry->GetOffset(), l, dlm_mod);
+ // FIXME, TODO
+ // when we're here, element fffe,e000 is already passed.
+ // it's lost for the SQItem we're going to process !!
+
+ //ParseDES(itemSQ, newDocEntry->GetOffset(), l, dlm_mod);
+ //delete newDocEntry; // FIXME well ... it's too late to use it !
+
+ // Let's try :------------
+ // remove fff0,e000, created out of the SQItem
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 -----------------
+
seqEntry->AddEntry( itemSQ, SQItemNumber );
SQItemNumber++;
if ( !delim_mode && ((long)(Fp->tellg())-offset ) >= l_max )
void Document::FindDocEntryLength( DocEntry *entry )
throw ( FormatError )
{
- uint16_t element = entry->GetElement();
std::string vr = entry->GetVR();
uint16_t length16;
void Document::SkipToNextDocEntry(DocEntry *currentDocEntry)
{
Fp->seekg((long)(currentDocEntry->GetOffset()), std::ios::beg);
- Fp->seekg( (long)(currentDocEntry->GetReadLength()),std::ios::cur);
+ if (currentDocEntry->GetGroup() != 0xfffe) // for fffe pb
+ Fp->seekg( (long)(currentDocEntry->GetReadLength()),std::ios::cur);
}
/**
gdcmVerboseMacro( "Looks like DICOM Version3 (preamble + DCM)" );
// Group 0002 should always be VR, and the first element 0000
- // Let's be carefull (so many wrong hedaers ...)
+ // Let's be carefull (so many wrong headers ...)
// and determine the value representation (VR) :
// Let's skip to the first element (0002,0000) and check there if we find
// "UL" - or "OB" if the 1st one is (0002,0001) -,
entCur = deb + 136;
// group 0x0002 *is always* Explicit VR Sometimes ,
- // even elem 0002,0010 (Transfer Syntax) tells us the file is
+ // even if elem 0002,0010 (Transfer Syntax) tells us the file is
// *Implicit* VR (see former 'gdcmData/icone.dcm')
if( memcmp(entCur, "UL", (size_t)2) == 0 ||
// use the TS (TS : Transfer Syntax)
std::string transferSyntax = GetEntry(0x0002,0x0010);
- if ( transferSyntax == GDCM_NOTLOADED )
+ if ( (transferSyntax.find(GDCM_NOTLOADED) < transferSyntax.length()) )
{
gdcmErrorMacro( "Transfer Syntax not loaded. " << std::endl
<< "Better you increase MAX_SIZE_LOAD_ELEMENT_VALUE" );
* whatever Transfer Syntax is
* @return no return
*/
-void Document::HandleOutOfGroup0002(uint16_t group)
+void Document::HandleOutOfGroup0002(uint16_t &group, uint16_t &elem)
{
// Endian reversion. Some files contain groups of tags with reversed endianess.
if ( !Group0002Parsed && group != 0x0002)
gdcmVerboseMacro("Transfer Syntax Name = ["
<< GetTransferSyntaxName() << "]" );
SwitchByteSwapCode();
+ group = SwapShort(group);
+ elem = SwapShort(elem);
}
}
}
// In 'true DICOM' files Group 0002 is always little endian
if ( HasDCMPreamble )
- HandleOutOfGroup0002(group);
+ HandleOutOfGroup0002(group, elem);
std::string vr = FindDocEntryVR();
std::string realVR = vr;
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());
- gdcmVerboseMacro( msg.c_str() );
+ // implicit VR tag. Let's backtrack.
+ if ( newEntry->GetGroup() != 0xfffe )
+ {
+ std::string msg;
+ msg = Util::Format("Entry (%04x,%04x) should be Explicit VR\n",
+ newEntry->GetGroup(), newEntry->GetElement());
+ gdcmVerboseMacro( msg.c_str() );
+ }
}
newEntry->SetImplicitVR();
}
*/
uint32_t Document::ReadTagLength(uint16_t testGroup, uint16_t testElement)
{
- long positionOnEntry = Fp->tellg();
- (void)positionOnEntry;
if ( !ReadTag(testGroup, testElement) )
{
* when recursively walking the given set.
* @param set The structure to be traversed (recursively).
*/
-void Document::BuildFlatHashTableRecurse( TagDocEntryHT &builtHT,
+/*void Document::BuildFlatHashTableRecurse( TagDocEntryHT &builtHT,
DocEntrySet *set )
{
if (ElementSet *elementSet = dynamic_cast< ElementSet* > ( set ) )
}
}
-}
+}*/
/**
* \brief Build a \ref TagDocEntryHT (i.e. a std::map<>) from the current
* \ref BuildFlatHashTable again...
* @return The flat std::map<> we juste build.
*/
-TagDocEntryHT *Document::BuildFlatHashTable()
+/*TagDocEntryHT *Document::BuildFlatHashTable()
{
TagDocEntryHT *FlatHT = new TagDocEntryHT;
BuildFlatHashTableRecurse( *FlatHT, this );
return FlatHT;
-}
+}*/
// for each zero-level Tag in the DCM Header
DocEntry *entry;
- Initialize();
+ InitTraversal();
entry = GetNextEntry();
while(entry)
{
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff