Program: gdcm
Module: $RCSfile: gdcmDocument.cxx,v $
Language: C++
- Date: $Date: 2005/01/11 22:05:22 $
- Version: $Revision: 1.177 $
+ Date: $Date: 2005/01/15 03:49:49 $
+ Version: $Revision: 1.191 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
long lgt = Fp->tellg();
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
+ ParseDES( this, beg, lgt, false); // Loading is done during parsing
Fp->seekg( 0, std::ios::beg);
/// 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
- /// altered on PURPOUS but now contains a WRONG value.
+ /// 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:
SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
Initialise();
- SwapCode = 0;
+ SwapCode = 1234;
Filetype = ExplicitVR;
Group0002Parsed = false;
}
}
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)
{
switch (SwapCode)
{
- case 0 :
+ case 1234 :
break;
case 4321 :
a=( ((a<<24) & 0xff000000) | ((a<<8) & 0x00ff0000) |
((a>>8) & 0x0000ff00) | ((a>>24) & 0x000000ff) );
- break;
-
+ break;
case 3412 :
a=( ((a<<16) & 0xffff0000) | ((a>>16) & 0x0000ffff) );
- break;
-
+ break;
case 2143 :
a=( ((a<< 8) & 0xff00ff00) | ((a>>8) & 0x00ff00ff) );
- break;
+ break;
default :
gdcmErrorMacro( "Unset swap code:" << SwapCode );
a = 0;
BinEntry *newBinEntry;
SeqEntry *newSeqEntry;
VRKey vr;
- bool used=false;
+ bool used = false;
while (true)
{
break;
}
- used=true;
+ used = true;
newDocEntry = ReadNextDocEntry( );
if ( !newDocEntry )
{
if ( ! Global::GetVR()->IsVROfBinaryRepresentable(vr) )
{
////// Neither ValEntry NOR BinEntry: should mean UNKOWN VR
- gdcmVerboseMacro( "Neither Valentry, nor BinEntry."
+ gdcmVerboseMacro( std::hex << newDocEntry->GetGroup()
+ << "|" << newDocEntry->GetElement()
+ << " : Neither Valentry, nor BinEntry."
"Probably unknown VR.");
}
newSeqEntry->SetDepthLevel( 1 );
newSeqEntry->SetKey( newSeqEntry->GetKey() );
}
- // But when "set" is allready a SQItem, we are building a nested
+ // 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:
if (SQItem *parentSQItem = dynamic_cast< SQItem* > ( set ) )
while (true)
{
- DocEntry *newDocEntry = ReadNextDocEntry();
+ DocEntry *newDocEntry = ReadNextDocEntry();
if ( !newDocEntry )
{
// FIXME Should warn user
}
ParseDES(itemSQ, newDocEntry->GetOffset(), l, dlm_mod);
- delete newDocEntry;
-
+ delete newDocEntry; // FIXME Why deleting fffe 000e ?!?
+
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;
// Length is encoded on 2 bytes.
length16 = ReadInt16();
+
+ // FIXME : This heuristic supposes that the first group following
+ // group 0002 *has* and element 0000.
+ // BUT ... Element 0000 is optionnal :-(
+
+
+ // Fixed using : HandleOutOfGroup0002()
+ // (first hereafter strategy ...)
// We can tell the current file is encoded in big endian (like
// Data/US-RGB-8-epicard) when we find the "Transfer Syntax" tag
// ones with zero as element number) has to be of 4 (0x0004). When we
// encounter 1024 (0x0400) chances are the encoding changed and we
// found a group with big endian encoding.
+ //---> Unfortunately, element 0000 is optional.
+ //---> This will not work when missing!
// We shall use this second strategy. In order to make sure that we
// can interpret the presence of an apparently big endian encoded
// length of a "Group Length" without committing a big mistake, we
// endian encoding". When this is the case, chances are we have got our
// hands on a big endian encoded file: we switch the swap code to
// big endian and proceed...
- if ( element == 0x0000 && length16 == 0x0400 )
- {
- std::string ts = GetTransferSyntax();
- if ( Global::GetTS()->GetSpecialTransferSyntax(ts)
- != TS::ExplicitVRBigEndian )
- {
- throw FormatError( "Document::FindDocEntryLength()",
- " not explicit VR." );
- return;
- }
- length16 = 4;
- SwitchByteSwapCode();
+
+ //
+ // if ( element == 0x0000 && length16 == 0x0400 )
+ // {
+ // std::string ts = GetTransferSyntax();
+ // if ( Global::GetTS()->GetSpecialTransferSyntax(ts)
+ // != TS::ExplicitVRBigEndian )
+ // {
+ // throw FormatError( "Document::FindDocEntryLength()",
+ // " not explicit VR." );
+ // return;
+ // }
+ // length16 = 4;
+ // SwitchByteSwapCode();
// Restore the unproperly loaded values i.e. the group, the element
// and the dictionary entry depending on them.
- uint16_t correctGroup = SwapShort( entry->GetGroup() );
- uint16_t correctElem = SwapShort( entry->GetElement() );
- DictEntry *newTag = GetDictEntry( correctGroup, correctElem );
- if ( !newTag )
- {
+// uint16_t correctGroup = SwapShort( entry->GetGroup() );
+// uint16_t correctElem = SwapShort( entry->GetElement() );
+// DictEntry *newTag = GetDictEntry( correctGroup, correctElem ); if ( !newTag )
+// {
// This correct tag is not in the dictionary. Create a new one.
- newTag = NewVirtualDictEntry(correctGroup, correctElem);
- }
+// newTag = NewVirtualDictEntry(correctGroup, correctElem);
+// }
// FIXME this can create a memory leaks on the old entry that be
// left unreferenced.
- entry->SetDictEntry( newTag );
- }
-
- // Heuristic: well, some files are really ill-formed.
+// entry->SetDictEntry( newTag );
+// }
+
+
+ // 0xffff means that we deal with 'No Length' Sequence
+ // or 'No Length' SQItem
if ( length16 == 0xffff)
- {
- // 0xffff means that we deal with 'Unknown Length' Sequence
+ {
length16 = 0;
}
FixDocEntryFoundLength( entry, (uint32_t)length16 );
net2host = false;
}
- // 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".
+ // The easiest case is the one of a 'true' DICOM header, we just have
+ // to look for the string "DICM" inside the file preamble.
Fp->read(deb, 256);
char *entCur = deb + 128;
if( memcmp(entCur, "DICM", (size_t)4) == 0 )
{
- gdcmVerboseMacro( "Looks like DICOM Version3" );
+ gdcmVerboseMacro( "Looks like DICOM Version3 (preamble + DCM)" );
- // Next, 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) -,
+ // Group 0002 should always be VR, and the first element 0000
+ // 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) -,
// in which case we (almost) know it is explicit VR.
// WARNING: if it happens to be implicit VR then what we will read
// is the length of the group. If this ascii representation of this
// length happens to be "UL" then we shall believe it is explicit VR.
- // FIXME: in order to fix the above warning, we could read the next
- // element value (or a couple of elements values) in order to make
- // sure we are not commiting a big mistake.
// We need to skip :
// * the 128 bytes of File Preamble (often padded with zeroes),
// * the 4 bytes of "DICM" string,
// i.e. a total of 136 bytes.
entCur = deb + 136;
- // FIXME : FIXME:
- // Sometimes (see : gdcmData/icone.dcm) group 0x0002 *is* Explicit VR,
- // but elem 0002,0010 (Transfer Syntax) tells us the file is
- // *Implicit* VR. -and it is !-
+ // group 0x0002 *is always* Explicit VR Sometimes ,
+ // 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 ||
memcmp(entCur, "OB", (size_t)2) == 0 ||
memcmp(entCur, "UI", (size_t)2) == 0 ||
memcmp(entCur, "CS", (size_t)2) == 0 ) // CS, to remove later
- // when Write DCM *adds*
+ // when Write DCM *adds*
// FIXME
// Use Document::dicom_vr to test all the possibilities
// instead of just checking for UL, OB and UI !? group 0000
{
Filetype = ExplicitVR;
- gdcmVerboseMacro( "Explicit Value Representation");
+ gdcmVerboseMacro( "Group 0002 : Explicit Value Representation");
}
else
{
Filetype = ImplicitVR;
- gdcmVerboseMacro( "Not an explicit Value Representation");
+ gdcmVerboseMacro( "Group 0002 :Not an explicit Value Representation;"
+ << "Looks like a bugged Header!");
}
if ( net2host )
}
else
{
- SwapCode = 0;
+ SwapCode = 1234;
gdcmVerboseMacro( "HostByteOrder = NetworkByteOrder");
}
- // Position the file position indicator at first tag (i.e.
- // after the file preamble and the "DICM" string).
+ // Position the file position indicator at first tag
+ // (i.e. after the file preamble and the "DICM" string).
Fp->seekg(0, std::ios::beg);
Fp->seekg ( 132L, std::ios::beg);
return true;
Filetype = ACR;
return true;
case 0x00000004 :
- SwapCode = 0;
+ SwapCode = 1234;
Filetype = ACR;
return true;
default :
case 0x0006 :
case 0x0007 :
case 0x0008 :
- SwapCode = 0;
+ SwapCode = 1234;
Filetype = ACR;
return true;
case 0x0100 :
Filetype = Unknown;
return false;
}
- // Then the only info we have is the net2host one.
- //if (! net2host )
- // SwapCode = 0;
- //else
- // SwapCode = 4321;
- //return;
}
}
*/
void Document::SwitchByteSwapCode()
{
- gdcmVerboseMacro( "Switching Byte Swap code.");
- if ( SwapCode == 0 )
+ gdcmVerboseMacro( "Switching Byte Swap code from "<< SwapCode);
+ if ( SwapCode == 1234 )
{
SwapCode = 4321;
}
else if ( SwapCode == 4321 )
{
- SwapCode = 0;
+ SwapCode = 1234;
}
else if ( SwapCode == 3412 )
{
* apparent reason
* @return no return
*/
-void Document::HandleBrokenEndian(uint16_t group, uint16_t elem)
+void Document::HandleBrokenEndian(uint16_t &group, uint16_t &elem)
{
// Endian reversion. Some files contain groups of tags with reversed endianess.
static int reversedEndian = 0;
}
}
+/**
+ * \brief Accesses the info from 0002,0010 : Transfer Syntax and TS
+ * else 1.
+ * @return The full Transfer Syntax Name (as opposed to Transfer Syntax UID)
+ */
+std::string Document::GetTransferSyntaxName()
+{
+ // use the TS (TS : Transfer Syntax)
+ std::string transferSyntax = GetEntry(0x0002,0x0010);
+
+ if ( (transferSyntax.find(GDCM_NOTLOADED) < transferSyntax.length()) )
+ {
+ gdcmErrorMacro( "Transfer Syntax not loaded. " << std::endl
+ << "Better you increase MAX_SIZE_LOAD_ELEMENT_VALUE" );
+ return "Uncompressed ACR-NEMA";
+ }
+ if ( transferSyntax == GDCM_UNFOUND )
+ {
+ gdcmVerboseMacro( "Unfound Transfer Syntax (0002,0010)");
+ return "Uncompressed ACR-NEMA";
+ }
+
+ // we do it only when we need it
+ const TSKey &tsName = Global::GetTS()->GetValue( transferSyntax );
+
+ // Global::GetTS() is a global static you shall never try to delete it!
+ return tsName;
+}
+
/**
* \brief Group 0002 is always coded Little Endian
* 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)
{
Group0002Parsed = true;
- // we just came out of group 0002
- // if Transfer syntax is Big Endian we have to change CheckSwap
+ // we just came out of group 0002
+ // if Transfer syntax is Big Endian we have to change CheckSwap
- TagKey key = DictEntry::TranslateToKey(0x0002, 0x0010);
- if ( !TagHT.count(key))
+ std::string ts = GetTransferSyntax();
+ if ( !Global::GetTS()->IsTransferSyntax(ts) )
{
- gdcmVerboseMacro("True DICOM File, with NO Tansfer Syntax ?!?");
+ gdcmVerboseMacro("True DICOM File, with NO Tansfer Syntax: " << ts );
return;
}
- // FIXME Strangely, this works with
- //'Implicit VR Transfer Syntax (GE Private)
-
- if ( ((ValEntry *)TagHT.find(key)->second)->GetValue()
- == "Explicit VR - Big Endian" )
- {
- gdcmVerboseMacro("Tansfer Syntax = Explicit VR - Big Endian");
- SwitchByteSwapCode();
- }
+ // FIXME Strangely, this works with
+ //'Implicit VR Transfer Syntax (GE Private)
+ if ( Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRBigEndian )
+ {
+ gdcmVerboseMacro("Transfer Syntax Name = ["
+ << GetTransferSyntaxName() << "]" );
+ SwitchByteSwapCode();
+ group = SwapShort(group);
+ elem = SwapShort(elem);
+ }
}
}
// Sometimes file contains groups of tags with reversed endianess.
HandleBrokenEndian(group, elem);
-// In 'true DICOM' files Group 0002 is allways little endian
+// 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();
}
* 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