Program: gdcm
Module: $RCSfile: gdcmDocument.cxx,v $
Language: C++
- Date: $Date: 2005/01/12 11:33:39 $
- Version: $Revision: 1.182 $
+ Date: $Date: 2005/01/18 16:23:52 $
+ Version: $Revision: 1.197 $
Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See Doc/License.txt or
#include <iomanip>
// For nthos:
-#if defined(_MSC_VER) || defined(__BORLANDC__)
+#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__)
#include <winsock.h>
-#else
+#endif
+
+#ifdef CMAKE_HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
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);
/// 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
- /// altered on PURPOUS but now contains a WRONG value.
+ /// 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
// we switch lineNumber and columnNumber
//
std::string RecCode;
- RecCode = GetEntry(0x0008, 0x0010); // recognition code
+ RecCode = GetEntry(0x0008, 0x0010); // recognition code (RET)
if (RecCode == "ACRNEMA_LIBIDO_1.1" ||
RecCode == "CANRME_AILIBOD1_1." ) // for brain-damaged softwares
// with "little-endian strings"
}
if( TagHT.empty() )
- {
- gdcmVerboseMacro( "No tags in internal hash table.");
+ {
+ gdcmVerboseMacro( "No tag 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 Writes in a file all the Header Entries (Dicom Elements)
- * @param fp file pointer on an already open file
+ * @param fp file pointer on an already open file (actually: Output File Stream)
* @param filetype Type of the File to be written
* (ACR-NEMA, ExplicitVR, ImplicitVR)
* \return Always true.
* when it exists. Create it with the given value when unexistant.
* A copy of the binArea is made to be kept in the Document.
* @param binArea (binary) value to be set
- * @param Group Group number of the Entry
- * @param Elem Element number of the Entry
+ * @param group Group number of the Entry
+ * @param elem Element number of the Entry
* @param vr V(alue) R(epresentation) of the Entry -if private Entry-
* \return pointer to the modified/created Header Entry (NULL when creation
* failed).
/*
* \brief Modifies the value of a given Header Entry (Dicom Element)
* when it exists. Create it when unexistant.
- * @param Group Group number of the Entry
- * @param Elem Element number of the Entry
+ * @param group Group number of the Entry
+ * @param elem Element number of the Entry
* \return pointer to the modified/created SeqEntry (NULL when creation
* failed).
*/
/**
* \brief Checks if a given Dicom Element exists within the H table
- * @param group Group number of the searched Dicom Element
- * @param element Element number of the searched Dicom Element
+ * @param group Group number of the searched Dicom Element
+ * @param elem Element number of the searched Dicom Element
* @return true is found
*/
-bool Document::CheckIfEntryExist(uint16_t group, uint16_t element )
+bool Document::CheckIfEntryExist(uint16_t group, uint16_t elem )
{
- const std::string &key = DictEntry::TranslateToKey(group, element );
+ const std::string &key = DictEntry::TranslateToKey(group, elem );
return TagHT.count(key) != 0;
}
* \brief Searches within Header Entries (Dicom Elements) parsed with
* the public and private dictionaries
* for the element value representation of a given tag.
- * @param group Group number of the searched tag.
- * @param element Element number of the searched tag.
+ * @param group Group number of the searched tag.
+ * @param elem Element number of the searched tag.
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-std::string Document::GetEntry(uint16_t group, uint16_t element)
+std::string Document::GetEntry(uint16_t group, uint16_t elem)
{
- TagKey key = DictEntry::TranslateToKey(group, element);
+ TagKey key = DictEntry::TranslateToKey(group, elem);
if ( !TagHT.count(key))
{
return GDCM_UNFOUND;
* \brief Searches within Header Entries (Dicom Elements) parsed with
* the public and private dictionaries
* for the element value representation of a given tag..
- *
* Obtaining the VR (Value Representation) might be needed by caller
* to convert the string typed content to caller's native type
* (think of C++ vs Python). The VR is actually of a higher level
* of semantics than just the native C++ type.
- * @param group Group number of the searched tag.
- * @param element Element number of the searched tag.
+ * @param group Group number of the searched tag.
+ * @param elem Element number of the searched tag.
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-std::string Document::GetEntryVR(uint16_t group, uint16_t element)
+std::string Document::GetEntryVR(uint16_t group, uint16_t elem)
{
- DocEntry *elem = GetDocEntry(group, element);
- if ( !elem )
+ DocEntry *element = GetDocEntry(group, elem);
+ if ( !element )
{
return GDCM_UNFOUND;
}
- return elem->GetVR();
+ return element->GetVR();
}
/**
* \brief Searches within Header Entries (Dicom Elements) parsed with
* the public and private dictionaries
* for the value length of a given tag..
- * @param group Group number of the searched tag.
- * @param element Element number of the searched tag.
+ * @param group Group number of the searched tag.
+ * @param elem Element number of the searched tag.
* @return Corresponding element length; -2 if not found
*/
-int Document::GetEntryLength(uint16_t group, uint16_t element)
+int Document::GetEntryLength(uint16_t group, uint16_t elem)
{
- DocEntry *elem = GetDocEntry(group, element);
- if ( !elem )
+ DocEntry *element = GetDocEntry(group, elem);
+ if ( !element )
{
return -2; //magic number
}
- return elem->GetLength();
+ return element->GetLength();
}
/**
* through it's (group, element) and modifies it's content with
* the given value.
* @param content new value (string) to substitute with
- * @param group group number of the Dicom Element to modify
- * @param element element number of the Dicom Element to modify
+ * @param group group number of the Dicom Element to modify
+ * @param elem element number of the Dicom Element to modify
*/
bool Document::SetEntry(std::string const& content,
- uint16_t group, uint16_t element)
+ uint16_t group, uint16_t elem)
{
- ValEntry *entry = GetValEntry(group, element);
+ ValEntry *entry = GetValEntry(group, elem);
if (!entry )
{
gdcmVerboseMacro( "No corresponding ValEntry (try promotion first).");
* the given value.
* @param content new value (void* -> uint8_t*) to substitute with
* @param lgth new value length
- * @param group group number of the Dicom Element to modify
- * @param element element number of the Dicom Element to modify
+ * @param group group number of the Dicom Element to modify
+ * @param elem element number of the Dicom Element to modify
*/
bool Document::SetEntry(uint8_t*content, int lgth,
- uint16_t group, uint16_t element)
+ uint16_t group, uint16_t elem)
{
- BinEntry *entry = GetBinEntry(group, element);
+ BinEntry *entry = GetBinEntry(group, elem);
if (!entry )
{
gdcmVerboseMacro( "No corresponding ValEntry (try promotion first).");
* @param content new value (string) to substitute with
* @param entry Entry to be modified
*/
-bool Document::SetEntry(std::string const &content,ValEntry *entry)
+bool Document::SetEntry(std::string const &content, ValEntry *entry)
{
if(entry)
{
* and modifies it's content with the given value.
* @param content new value (void* -> uint8_t*) to substitute with
* @param entry Entry to be modified
- * @param lgth new value length
+ * @param lgth new value length
*/
bool Document::SetEntry(uint8_t *content, int lgth, BinEntry *entry)
{
/**
* \brief Loads (from disk) the element content
* when a string is not suitable
- * @param element Entry whose binArea is going to be loaded
+ * @param elem Entry whose binArea is going to be loaded
*/
-void Document::LoadEntryBinArea(BinEntry *element)
+void Document::LoadEntryBinArea(BinEntry *elem)
{
- if(element->GetBinArea())
+ if(elem->GetBinArea())
return;
bool openFile = !Fp;
if(openFile)
OpenFile();
- size_t o =(size_t)element->GetOffset();
+ size_t o =(size_t)elem->GetOffset();
Fp->seekg(o, std::ios::beg);
- size_t l = element->GetLength();
+ size_t l = elem->GetLength();
uint8_t *a = new uint8_t[l];
if( !a )
{
- gdcmVerboseMacro( "Cannot allocate a");
+ gdcmVerboseMacro( "Cannot allocate BinEntry content");
return;
}
return;
}
- element->SetBinArea(a);
+ elem->SetBinArea(a);
if(openFile)
CloseFile();
/**
* \brief Sets a 'non string' value to a given Dicom Element
* @param area area containing the 'non string' value
- * @param group Group number of the searched Dicom Element
- * @param element Element number of the searched Dicom Element
+ * @param group Group number of the searched Dicom Element
+ * @param elem Element number of the searched Dicom Element
* @return
*/
/*bool Document::SetEntryBinArea(uint8_t *area,
- uint16_t group, uint16_t element)
+ uint16_t group, uint16_t elem)
{
- DocEntry *currentEntry = GetDocEntry(group, element);
+ DocEntry *currentEntry = GetDocEntry(group, elem);
if ( !currentEntry )
{
return false;
* if you think it's NOT UNIQUE, check the count number
* and use iterators to retrieve ALL the Dicoms Elements within
* a given couple (group, element)
- * @param group Group number of the searched Dicom Element
- * @param element Element number of the searched Dicom Element
+ * @param group Group number of the searched Dicom Element
+ * @param elem Element number of the searched Dicom Element
* @return
*/
-DocEntry *Document::GetDocEntry(uint16_t group, uint16_t element)
+DocEntry *Document::GetDocEntry(uint16_t group, uint16_t elem)
{
- TagKey key = DictEntry::TranslateToKey(group, element);
+ TagKey key = DictEntry::TranslateToKey(group, elem);
if ( !TagHT.count(key))
{
return NULL;
* \brief Same as \ref Document::GetDocEntry except it only
* returns a result when the corresponding entry is of type
* ValEntry.
+ * @param group Group number of the searched Dicom Element
+ * @param elem Element number of the searched Dicom Element
* @return When present, the corresponding ValEntry.
*/
-ValEntry *Document::GetValEntry(uint16_t group, uint16_t element)
+ValEntry *Document::GetValEntry(uint16_t group, uint16_t elem)
{
- DocEntry *currentEntry = GetDocEntry(group, element);
+ DocEntry *currentEntry = GetDocEntry(group, elem);
if ( !currentEntry )
{
return 0;
* \brief Same as \ref Document::GetDocEntry except it only
* returns a result when the corresponding entry is of type
* BinEntry.
+ * @param group Group number of the searched Dicom Element
+ * @param elem Element number of the searched Dicom Element
* @return When present, the corresponding BinEntry.
*/
-BinEntry *Document::GetBinEntry(uint16_t group, uint16_t element)
+BinEntry *Document::GetBinEntry(uint16_t group, uint16_t elem)
{
- DocEntry *currentEntry = GetDocEntry(group, element);
+ DocEntry *currentEntry = GetDocEntry(group, elem);
if ( !currentEntry )
{
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;
{
if ( newBinEntry )
{
- if ( ! Global::GetVR()->IsVROfBinaryRepresentable(vr) )
+ if ( Filetype == ExplicitVR && ! 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.");
}
//////////////////// 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 ( dynamic_cast< Document* > ( set ) )
{
- (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 ( dynamic_cast< Document* > ( set ) )
{
- (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() );
}
- // 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 ) )
{
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;
// 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 );
// on Data elements "Implicit and Explicit VR Data Elements shall
// not coexist in a Data Set and Data Sets nested within it".]
// Length is on 4 bytes.
+
+ // Well ... group 0002 is always coded in 'Explicit VR Litle Endian'
+ // even if Transfer Syntax is 'Implicit VR ...'
FixDocEntryFoundLength( entry, ReadInt32() );
return;
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);
}
/**
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 )
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;
}
}
-
-
/**
* \brief Change the Byte Swap code.
*/
void Document::SwitchByteSwapCode()
{
- gdcmVerboseMacro( "Switching Byte Swap code.");
+ gdcmVerboseMacro( "Switching Byte Swap code from "<< SwapCode);
if ( SwapCode == 1234 )
{
SwapCode = 4321;
*/
void Document::SetMaxSizePrintEntry(long newSize)
{
- //DOH !! This is exactly SetMaxSizeLoadEntry FIXME FIXME
if ( newSize < 0 )
{
return;
/**
* \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 == 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)
// we just came out of group 0002
// if Transfer syntax is Big Endian we have to change CheckSwap
- std::string ts = GetTransferSyntaxName();
+ std::string ts = GetTransferSyntax();
if ( !Global::GetTS()->IsTransferSyntax(ts) )
{
gdcmVerboseMacro("True DICOM File, with NO Tansfer Syntax: " << ts );
return;
}
+ // Group 0002 is always 'Explicit ...' enven when Transfer Syntax says 'Implicit ..."
+
+ if ( Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ImplicitVRLittleEndian )
+ {
+ Filetype = ImplicitVR;
+ }
+
// FIXME Strangely, this works with
//'Implicit VR Transfer Syntax (GE Private)
if ( Global::GetTS()->GetSpecialTransferSyntax(ts) == TS::ExplicitVRBigEndian )
{
- gdcmVerboseMacro("Tansfer Syntax = Explicit VR - Big Endian");
+ 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();
}
*/
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;
-}
+}*/
bool found0002 = false;
// for each zero-level Tag in the DCM Header
- DocEntry *entry;
-
- Initialize();
- entry = GetNextEntry();
+ DocEntry *entry = GetFirstEntry();
while(entry)
{
gr = entry->GetGroup();
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff