Program: gdcm
Module: $RCSfile: gdcmDocument.cxx,v $
Language: C++
- Date: $Date: 2005/01/11 11:37:13 $
- Version: $Revision: 1.173 $
+ Date: $Date: 2005/01/14 11:28:30 $
+ Version: $Revision: 1.190 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
namespace gdcm
{
-//-----------------------------------------------------------------------------
-static const char *TransferSyntaxStrings[] = {
- // Implicit VR Little Endian
- "1.2.840.10008.1.2",
- // Implicit VR Big Endian DLX (G.E Private)
- "1.2.840.113619.5.2",
- // Explicit VR Little Endian
- "1.2.840.10008.1.2.1",
- // Deflated Explicit VR Little Endian
- "1.2.840.10008.1.2.1.99",
- // Explicit VR Big Endian
- "1.2.840.10008.1.2.2",
- // JPEG Baseline (Process 1)
- "1.2.840.10008.1.2.4.50",
- // JPEG Extended (Process 2 & 4)
- "1.2.840.10008.1.2.4.51",
- // JPEG Extended (Process 3 & 5)
- "1.2.840.10008.1.2.4.52",
- // JPEG Spectral Selection, Non-Hierarchical (Process 6 & 8)
- "1.2.840.10008.1.2.4.53",
- // JPEG Full Progression, Non-Hierarchical (Process 10 & 12)
- "1.2.840.10008.1.2.4.55",
- // JPEG Lossless, Non-Hierarchical (Process 14)
- "1.2.840.10008.1.2.4.57",
- // JPEG Lossless, Hierarchical, First-Order Prediction (Process 14, [Selection Value 1])
- "1.2.840.10008.1.2.4.70",
- // JPEG 2000 Lossless
- "1.2.840.10008.1.2.4.90",
- // JPEG 2000
- "1.2.840.10008.1.2.4.91",
- // RLE Lossless
- "1.2.840.10008.1.2.5",
- // Unknown
- "Unknown Transfer Syntax"
-};
//-----------------------------------------------------------------------------
// Refer to Document::CheckSwap()
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;
}
* value from disk when only parsing occured).
* @return The encountered Transfer Syntax of the current document.
*/
-TransferSyntaxType Document::GetTransferSyntax()
+std::string Document::GetTransferSyntax()
{
DocEntry *entry = GetDocEntry(0x0002, 0x0010);
if ( !entry )
{
- return UnknownTS;
+ return GDCM_UNKNOWN;
}
// The entry might be present but not loaded (parsing and loading
if ( transfer.length() == 0 )
{
// for brain damaged headers
- return UnknownTS;
+ return GDCM_UNKNOWN;
}
while ( !isdigit((unsigned char)transfer[transfer.length()-1]) )
{
transfer.erase(transfer.length()-1, 1);
}
- for (int i = 0; TransferSyntaxStrings[i] != NULL; i++)
- {
- if ( TransferSyntaxStrings[i] == transfer )
- {
- return TransferSyntaxType(i);
- }
- }
+ return transfer;
}
- return UnknownTS;
-}
-
-bool Document::IsJPEGLossless()
-{
- TransferSyntaxType r = GetTransferSyntax();
- return r == JPEGFullProgressionProcess10_12
- || r == JPEGLosslessProcess14
- || r == JPEGLosslessProcess14_1;
-}
-
-/**
- * \brief Determines if the Transfer Syntax was already encountered
- * and if it corresponds to a JPEG2000 one
- * @return True when JPEG2000 (Lossly or LossLess) found. False in all
- * other cases.
- */
-bool Document::IsJPEG2000()
-{
- TransferSyntaxType r = GetTransferSyntax();
- return r == JPEG2000Lossless || r == JPEG2000;
-}
-
-/**
- * \brief Determines if the Transfer Syntax corresponds to any form
- * of Jpeg encoded Pixel data.
- * @return True when any form of JPEG found. False otherwise.
- */
-bool Document::IsJPEG()
-{
- TransferSyntaxType r = GetTransferSyntax();
- return r == JPEGBaselineProcess1
- || r == JPEGExtendedProcess2_4
- || r == JPEGExtendedProcess3_5
- || r == JPEGSpectralSelectionProcess6_8
- || IsJPEGLossless()
- || IsJPEG2000();
-}
-
-/**
- * \brief Determines if the Transfer Syntax corresponds to encapsulated
- * of encoded Pixel Data (as opposed to native).
- * @return True when encapsulated. False when native.
- */
-bool Document::IsEncapsulate()
-{
- TransferSyntaxType r = GetTransferSyntax();
- return IsJPEG() || r == RLELossless;
+ return GDCM_UNKNOWN;
}
/**
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;
return true;
}
-std::string Document::GetTransferSyntaxValue(TransferSyntaxType type)
-{
- return TransferSyntaxStrings[type];
-}
-
//-----------------------------------------------------------------------------
// Protected
* \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;
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.");
}
if ( ( newDocEntry->GetGroup() == 0x7fe0 )
&& ( newDocEntry->GetElement() == 0x0010 ) )
{
- TransferSyntaxType ts = GetTransferSyntax();
- if ( ts == RLELossless )
+ std::string ts = GetTransferSyntax();
+ if ( Global::GetTS()->IsRLELossless(ts) )
{
long positionOnEntry = Fp->tellg();
Fp->seekg( newDocEntry->GetOffset(), std::ios::beg );
ComputeRLEInfo();
Fp->seekg( positionOnEntry, std::ios::beg );
}
- else if ( IsJPEG() )
+ else if ( Global::GetTS()->IsJPEG(ts) )
{
long positionOnEntry = Fp->tellg();
Fp->seekg( newDocEntry->GetOffset(), std::ios::beg );
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 )
- {
- TransferSyntaxType ts = GetTransferSyntax();
- if ( 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();
}
<< std::hex << testGroup << "," << testElement << ")" << std::endl
<< " but instead we encountered tag ("
<< std::hex << itemTagGroup << "," << itemTagElement << ")"
- << std::dec
- << " at address: " << (unsigned int)currentPosition
- << std::hex
- << " 0x(" << (unsigned int)currentPosition << ")"
+ << " at address: " << " 0x(" << (unsigned int)currentPosition << ")"
) ;
Fp->seekg(positionOnEntry, std::ios::beg);
{
gdcmVerboseMacro( "Basic Item Length is: "
<< itemLength << std::endl
- << " at address: " << (unsigned int)currentPosition);
+ << " at address: " << std::hex << (unsigned int)currentPosition);
}
return itemLength;
}
*/
void Document::ComputeRLEInfo()
{
- TransferSyntaxType ts = GetTransferSyntax();
- if ( ts != RLELossless )
+ std::string ts = GetTransferSyntax();
+ if ( !Global::GetTS()->IsRLELossless(ts) )
{
return;
}
void Document::ComputeJPEGFragmentInfo()
{
// If you need to, look for comments of ComputeRLEInfo().
- if ( ! IsJPEG() )
+ std::string ts = GetTransferSyntax();
+ if ( ! Global::GetTS()->IsJPEG(ts) )
{
return;
}
* 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)
{