Program: gdcm
Module: $RCSfile: gdcmDocument.cxx,v $
Language: C++
- Date: $Date: 2005/10/18 10:43:31 $
- Version: $Revision: 1.291 $
+ Date: $Date: 2005/10/26 17:06:33 $
+ Version: $Revision: 1.312 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
Group0002Parsed = false;
- gdcmWarningMacro( "Starting parsing of file: " << Filename.c_str());
+ gdcmDebugMacro( "Starting parsing of file: " << Filename.c_str());
Fp->seekg(0, std::ios::end);
long lgt = Fp->tellg(); // total length of the file
*/
void Document::AddForceLoadElement (uint16_t group, uint16_t elem)
{
- Element el;
+ DicomElement el;
el.Group = group;
el.Elem = elem;
UserForceLoadList.push_back(el);
* \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.
+ * @return The encountered Transfer Syntax of the current document, if DICOM.
+ * GDCM_UNKNOWN for ACR-NEMA files (or broken headers ...)
*/
std::string Document::GetTransferSyntax()
{
return a;
}
+/**
+ * \brief Swaps back the bytes of 8-byte long 'double' accordingly to
+ * processor order.
+ * @return The properly swaped 64 bits double.
+ */
+double Document::SwapDouble(double a)
+{
+ switch (SwapCode)
+ {
+ // There were no 'double' at ACR-NEMA time.
+ // We just have to deal with 'straight Little Endian' and
+ // 'straight Big Endian'
+ case 1234 :
+ break;
+ case 4321 :
+ {
+ char *beg = (char *)&a;
+ char *end = beg + 7;
+ char t;
+ for (unsigned int i = 0; i<7; i++)
+ {
+ t = *beg;
+ *beg = *end;
+ *end = t;
+ beg++,
+ end--;
+ }
+ }
+ break;
+ default :
+ gdcmErrorMacro( "Unset swap code:" << SwapCode );
+ a = 0.;
+ }
+ return a;
+}
+
+
//
// -----------------File I/O ---------------
/**
{
// Skip if user wants to write an ACR-NEMA file
- if ( filetype == ImplicitVR || filetype == ExplicitVR )
+ if ( filetype == ImplicitVR || filetype == ExplicitVR ||
+ filetype == JPEG )
{
// writing Dicom File Preamble
char filePreamble[128];
/**
* \brief Loads (from disk) the element content
* when a string is not suitable
- * @param elem Entry whose binArea is going to be loaded
+ * @param entry Entry whose binArea is going to be loaded
*/
void Document::LoadEntryBinArea(DataEntry *entry)
{
return;
}
- // Read the datas
+ // Read the data
Fp->read((char*)data, l);
if ( Fp->fail() || Fp->eof() )
{
// Swap the data content if necessary
uint32_t i;
- unsigned short vrLgth = Global::GetVR()->GetAtomicElementLength(entry->GetVR());
+ unsigned short vrLgth =
+ Global::GetVR()->GetAtomicElementLength(entry->GetVR());
if( entry->GetVR() == "OW" )
vrLgth = 1;
}
case 8:
{
- gdcmWarningMacro("Can't swap 64 bits datas");
-/* uint64_t *data64 = (uint64_t *)data;
+ double *data64 = (double *)data;
for(i=0;i<l/vrLgth;i++)
- data64[i] = SwapLongLong(data64[i]);*/
+ data64[i] = SwapDouble(data64[i]);
break;
}
}
/**
* \brief Re-computes the length of a ACR-NEMA/Dicom group from a DcmHeader
*/
-int Document::ComputeGroup0002Length( /*FileType filetype*/ )
+int Document::ComputeGroup0002Length( )
{
uint16_t gr;
- std::string vr;
+ VRKey vr;
int groupLength = 0;
bool found0002 = false;
//if ( filetype == ExplicitVR )
//{
- // if ( (vr == "OB") || (vr == "OW") || (vr == "UT") || (vr == "SQ") )
+ //if ( (vr == "OB")||(vr == "OW")||(vr == "UT")||(vr == "SQ"))
// (no SQ, OW, UT in group 0x0002;)
if ( vr == "OB" )
{
- // explicit VR AND OB, OW, SQ, UT : 4 more bytes
+ // explicit VR AND (OB, OW, SQ, UT) : 4 more bytes
groupLength += 4;
}
//}
// It's too late to do the Job
// (we should check the value, but we know it after LoadDocEntry ...)
- // Uncoment this printf line to be able to 'follow' the DocEntries
+ // Uncoment this cerr 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( Debug::GetDebugFlag() )
+ std::cerr<<newDocEntry->GetKey()<<" "<<newDocEntry->GetVR()<<std::endl;
if ( !newDocEntry )
{
if ( newDataEntry )
{
//////////////////////////// DataEntry
+
vr = newDocEntry->GetVR();
+
+ // Useless checking, now !
+ /*
if ( Filetype == ExplicitVR &&
!Global::GetVR()->IsVROfBinaryRepresentable(vr) )
{
////// No DataEntry: should mean UNKOWN VR
gdcmWarningMacro( std::hex << newDocEntry->GetGroup()
<< "|" << newDocEntry->GetElement()
- << " : No DataEntry."
- "Probably unknown VR.");
+ << " : unknown VR."
+ " Probably 'Implicit VR' entry within "
+ "an explicit VR 'document'.");
}
+ */
if ( !set->AddEntry( newDataEntry ) )
{
}
else
{
+ newDataEntry->Delete();
// Load only if we can add (not a duplicate key)
LoadDocEntry( newDataEntry );
}
(!delim_mode && ((long)(Fp->tellg())-offset) >= l_max) )
{
if ( !used )
- delete newDocEntry;
+ newDocEntry->Delete();
break;
}
if ( newDocEntry->GetGroup()%2 != 0 )
{
Fp->seekg( l, std::ios::cur);
- RemoveEntry( newDocEntry ); // Remove and delete
- //used = false; // never used
+ newDocEntry->Delete(); // Delete, not in the set
continue;
}
}
{
// User asked to skip *any* SeQuence
Fp->seekg( l, std::ios::cur);
- //used = false; // never used
- RemoveEntry( newDocEntry ); // Remove and delete
+ newDocEntry->Delete(); // Delete, not in the set
continue;
}
// delay the dynamic cast as late as possible
// is a Document, then we are building the first depth level.
// Hence the SeqEntry we are building simply has a depth
// level of one:
-// SQItem *parentSQItem = dynamic_cast< SQItem* > ( set );
if ( set == this ) // ( dynamic_cast< Document* > ( set ) )
{
newSeqEntry->SetDepthLevel( 1 );
- // 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
else if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) )
{
newSeqEntry->SetDepthLevel( parentSQItem->GetDepthLevel() + 1 );
-
- // newSeqEntry->SetKey( parentSQItem->GetBaseTagKey()
- // + newSeqEntry->GetKey() );
}
if ( l != 0 )
<< newSeqEntry->GetOffset() << " )" );
used = false;
}
+ else
+ {
+ newDocEntry->Delete();
+ }
if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max)
{
if ( !used )
- delete newDocEntry;
- break;
+ newDocEntry->Delete();
+ break;
}
} // end SeqEntry : VR = "SQ"
if ( !used )
{
- delete newDocEntry;
+ newDocEntry->Delete();
}
first = false;
} // end While
- gdcmWarningMacro( "Exit from ParseDES, delim-mode " << delim_mode );
+ gdcmDebugMacro( "Exit from ParseDES, delim-mode " << delim_mode );
}
/**
if ( newDocEntry->IsSequenceDelimitor() )
{
seqEntry->SetDelimitationItem( newDocEntry );
+ newDocEntry->Delete();
break;
}
}
if ( !delim_mode && ((long)(Fp->tellg())-offset) >= l_max)
{
- delete newDocEntry;
+ newDocEntry->Delete();
break;
}
// create the current SQItem
- SQItem *itemSQ = new SQItem( seqEntry->GetDepthLevel() );
+ SQItem *itemSQ = SQItem::New( seqEntry->GetDepthLevel() );
unsigned int l = newDocEntry->GetReadLength();
if ( l == 0xffffffff )
// 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
// end try -----------------
seqEntry->AddSQItem( itemSQ, SQItemNumber );
+ itemSQ->Delete();
+ newDocEntry->Delete();
SQItemNumber++;
if ( !delim_mode && ((long)(Fp->tellg())-offset ) >= l_max )
{
{
// delete the Item Starter, built erroneously out of any Sequence
// it's not yet in the HTable/chained list
- delete docEntry;
+ docEntry->Delete();
// Get all info we can from PreviousDocEntry
uint16_t group = PreviousDocEntry->GetGroup();
void Document::LoadDocEntry(DocEntry *entry, bool forceLoad)
{
uint16_t group = entry->GetGroup();
- std::string vr = entry->GetVR();
+ uint16_t elem = entry->GetElement();
+ const VRKey &vr = entry->GetVR();
uint32_t length = entry->GetLength();
Fp->seekg((long)entry->GetOffset(), std::ios::beg);
// (fffe e000) tells us an Element is beginning
// (fffe e00d) tells us an Element just ended
// (fffe e0dd) tells us the current SeQuence just ended
- if ( group == 0xfffe || vr == "SQ" )
+ //
+ // (fffe 0000) is an 'impossible' tag value,
+ // found in MR-PHILIPS-16-Multi-Seq.dcm
+
+ if ( (group == 0xfffe && elem != 0x0000 ) || vr == "SQ" )
{
// NO more value field for SQ !
return;
void Document::FindDocEntryLength( DocEntry *entry )
throw ( FormatError )
{
- std::string vr = entry->GetVR();
+ const VRKey &vr = entry->GetVR();
uint16_t length16;
if ( Filetype == ExplicitVR && !entry->IsImplicitVR() )
* \brief Find the Value Representation of the current Dicom Element.
* @return Value Representation of the current Entry
*/
-std::string Document::FindDocEntryVR()
+VRKey Document::FindDocEntryVR()
{
if ( Filetype != ExplicitVR )
- return GDCM_UNKNOWN;
+ return GDCM_VRUNKNOWN;
long positionOnEntry = Fp->tellg();
// Warning: we believe this is explicit VR (Value Representation) because
// is in explicit VR and try to fix things if it happens not to be
// the case.
- char vr[3];
- Fp->read (vr, (size_t)2);
- vr[2] = 0;
+ VRKey vr;
+ Fp->read(&(vr[0]),(size_t)2);
+ //gdcmDebugMacro( "--> VR: " << vr )
if ( !CheckDocEntryVR(vr) )
{
+ gdcmWarningMacro( "Unknown VR '" << vr << "' at offset :"
+ << positionOnEntry );
Fp->seekg(positionOnEntry, std::ios::beg);
- return GDCM_UNKNOWN;
+ return GDCM_VRUNKNOWN;
}
return vr;
}
* @return false if the VR is incorrect or if the VR isn't referenced
* otherwise, it returns true
*/
-bool Document::CheckDocEntryVR(VRKey vr)
+bool Document::CheckDocEntryVR(const VRKey &vr)
{
- if ( !Global::GetVR()->IsValidVR(vr) )
- return false;
-
- return true;
+ return Global::GetVR()->IsValidVR(vr);
}
/**
void Document::FixDocEntryFoundLength(DocEntry *entry,
uint32_t foundLength)
{
- entry->SetReadLength( foundLength ); // will be updated only if a bug is found
+ entry->SetReadLength( foundLength );// will be updated only if a bug is found
if ( foundLength == 0xffffffff)
{
foundLength = 0;
if ( foundLength % 2)
{
- gdcmWarningMacro( "Warning : Tag with uneven length " << foundLength
+ gdcmWarningMacro( "Warning : Tag with uneven length " << foundLength
<< " in x(" << std::hex << gr << "," << elem <<")");
}
else if ( gr == 0x0009 && ( elem == 0x1113 || elem == 0x1114 ) )
{
foundLength = 4;
- entry->SetReadLength(4); // a bug is to be fixed !?
+ entry->SetReadLength(4); // a bug is to be fixed !
}
else if ( entry->GetVR() == "SQ" )
{
foundLength = 0;
}
- }
+ else
+ {
+ foundLength=12; // to skip the mess that follows this bugged Tag !
+ }
+ }
entry->SetLength(foundLength);
}
{
uint16_t elem = entry->GetElement();
uint16_t group = entry->GetGroup();
- const std::string &vr = entry->GetVR();
+ const VRKey &vr = entry->GetVR();
uint32_t length = entry->GetLength();
// When we have some semantics on the element we just read, and if we
}
else
{
- // Allthough this should never happen, still some images have a
+ // Although this should never happen, still some images have a
// corrupted group length [e.g. have a glance at offset x(8336) of
- // gdcmData/gdcm-MR-PHILIPS-16-Multi-Seq.dcm].
+ // gdcmData/gdcm-MR-PHILIPS-16-Multi-Seq.dcm.
// Since for dicom compliant and well behaved headers, the present
// test is useless (and might even look a bit paranoid), when we
// encounter such an ill-formed image, we simply display a warning
char *entCur = deb + 128;
if ( memcmp(entCur, "DICM", (size_t)4) == 0 )
{
- gdcmWarningMacro( "Looks like DICOM Version3 (preamble + DCM)" );
+ gdcmDebugMacro( "Looks like DICOM Version3 (preamble + DCM)" );
// Group 0002 should always be VR, and the first element 0000
// Let's be carefull (so many wrong headers ...)
// instead of just checking for UL, OB and UI !? group 0000
{
Filetype = ExplicitVR;
- gdcmWarningMacro( "Group 0002 : Explicit Value Representation");
+ gdcmDebugMacro( "Group 0002 : Explicit Value Representation");
}
else
{
Filetype = ImplicitVR;
- gdcmWarningMacro( "Group 0002 :Not an explicit Value Representation;"
+ gdcmErrorMacro( "Group 0002 :Not an explicit Value Representation;"
<< "Looks like a bugged Header!");
}
if ( net2host )
{
SwapCode = 4321;
- gdcmWarningMacro( "HostByteOrder != NetworkByteOrder");
+ gdcmDebugMacro( "HostByteOrder != NetworkByteOrder");
}
else
{
SwapCode = 1234;
- gdcmWarningMacro( "HostByteOrder = NetworkByteOrder");
+ gdcmDebugMacro( "HostByteOrder = NetworkByteOrder");
}
// Position the file position indicator at first tag
memcmp(entCur, "OB", (size_t)2) == 0 )
{
Filetype = ExplicitVR;
- gdcmWarningMacro( "Group 0002 : Explicit Value Representation");
+ gdcmDebugMacro( "Group 0002 : Explicit Value Representation");
return true;
}
}
// 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 -3, 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...
Filetype = ACR;
return true;
default :
- gdcmWarningMacro("ACR/NEMA unfound swap info (Really hopeless !)");
+ gdcmWarningMacro("ACR/NEMA unfound swap info (Hopeless !)");
Filetype = Unknown;
return false;
}
*/
void Document::SwitchByteSwapCode()
{
- gdcmWarningMacro( "Switching Byte Swap code from "<< SwapCode
- << " at :" <<std::hex << Fp->tellg() );
+ gdcmDebugMacro( "Switching Byte Swap code from "<< SwapCode
+ << " at: 0x" << std::hex << Fp->tellg() );
if ( SwapCode == 1234 )
{
SwapCode = 4321;
{
SwapCode = 3412;
}
+ gdcmDebugMacro( " Into: "<< SwapCode );
}
/**
if ( HasDCMPreamble )
HandleOutOfGroup0002(group, elem);
- std::string vr = FindDocEntryVR();
- std::string realVR = vr;
+ VRKey vr = FindDocEntryVR();
+
+ VRKey realVR = vr;
- if ( vr == GDCM_UNKNOWN )
+ if ( vr == GDCM_VRUNKNOWN )
{
if ( elem == 0x0000 ) // Group Length
{
if ( dictEntry )
{
realVR = dictEntry->GetVR();
+ dictEntry->Unregister();
}
}
}
+ // gdcmDebugMacro( "Found VR: " << vr << " / Real VR: " << realVR );
DocEntry *newEntry;
if ( Global::GetVR()->IsVROfSequence(realVR) )
static_cast<DataEntry *>(newEntry)->SetState(DataEntry::STATE_NOTLOADED);
}
- if ( vr == GDCM_UNKNOWN )
+ if ( vr == GDCM_VRUNKNOWN )
{
if ( Filetype == ExplicitVR )
{
{
std::string msg;
int offset = Fp->tellg();
- msg = Util::Format("Entry (%04x,%04x) at 0x(%x) should be Explicit VR\n",
- newEntry->GetGroup(), newEntry->GetElement(), offset );
+ msg = Util::Format(
+ "Entry (%04x,%04x) at x(%x) should be Explicit VR\n",
+ newEntry->GetGroup(), newEntry->GetElement(), offset );
gdcmWarningMacro( msg.c_str() );
}
}
catch ( FormatError )
{
// Call it quits
- delete newEntry;
+ newEntry->Delete();
return 0;
}
*/
void Document::HandleBrokenEndian(uint16_t &group, uint16_t &elem)
{
- // Endian reversion. Some files contain groups of tags with reversed endianess.
+ // 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))
// Do what you want, it breaks !
//reversedEndian--;
//SwitchByteSwapCode();
- gdcmWarningMacro( "Should never get here! reversed Sequence Terminator!" );
+ gdcmWarningMacro( "Should never get here! reversed Sequence Terminator!" );
// fix the tag
group = 0xfffe;
elem = 0xe0dd;
*/
void Document::HandleOutOfGroup0002(uint16_t &group, uint16_t &elem)
{
- // Endian reversion. Some files contain groups of tags with reversed endianess.
+ // Endian reversion.
+ // Some files contain groups of tags with reversed endianess.
if ( !Group0002Parsed && group != 0x0002)
{
Group0002Parsed = true;
return;
}
- // Group 0002 is always 'Explicit ...' even when Transfer Syntax says 'Implicit ..."
+ // Group 0002 is always 'Explicit ...'
+ // even when Transfer Syntax says 'Implicit ..."
- if ( Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRLittleEndian )
+ if ( Global::GetTS()->GetSpecialTransferSyntax(ts) ==
+ TS::ImplicitVRLittleEndian )
{
Filetype = ImplicitVR;
}
// FIXME Strangely, this works with
//'Implicit VR BigEndian Transfer Syntax (GE Private)
//
- // --> Probabely normal, since we considered we never have to trust manufacturers.
- // (we find very often 'Implicit VR' tag, even when Transfer Syntax tells us it's Explicit ...
- if ( Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRBigEndian )
+ // --> Probabely normal, since we considered we never have
+ // to trust manufacturers.
+ // (we find very often 'Implicit VR' tag,
+ // even when Transfer Syntax tells us it's Explicit ...
+ if ( Global::GetTS()->GetSpecialTransferSyntax(ts) ==
+ TS::ExplicitVRBigEndian )
{
gdcmWarningMacro("Transfer Syntax Name = ["
<< GetTransferSyntaxName() << "]" );