Program: gdcm
Module: $RCSfile: gdcmDocument.cxx,v $
Language: C++
- Date: $Date: 2005/01/13 09:53:42 $
- Version: $Revision: 1.188 $
+ Date: $Date: 2005/01/20 11:37:37 $
+ Version: $Revision: 1.203 $
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
*/
Document::Document( std::string const &filename ) : ElementSet(-1)
{
+ RLEInfo = NULL;
+ JPEGInfo = NULL;
+
SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
Filename = filename;
- Initialise();
+ Initialize();
Fp = 0;
if ( !OpenFile() )
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
// 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"
*/
Document::Document() : ElementSet(-1)
{
+ RLEInfo = NULL;
+ JPEGInfo = NULL;
+
Fp = 0;
SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
- Initialise();
+ Initialize();
SwapCode = 1234;
Filetype = ExplicitVR;
Group0002Parsed = false;
RefPubDict = NULL;
RefShaDict = NULL;
- delete RLEInfo;
- delete JPEGInfo;
+ if( RLEInfo )
+ delete RLEInfo;
+ if( JPEGInfo )
+ delete JPEGInfo;
}
//-----------------------------------------------------------------------------
}
if( TagHT.empty() )
- {
- gdcmVerboseMacro( "No tags in internal hash table.");
+ {
+ gdcmVerboseMacro( "No tag in internal hash table.");
return false;
}
Fp = 0;
}
- return true; //FIXME how do we detect a non-close ifstream ?
+ return true; //FIXME how do we detect a non-closed ifstream ?
}
/**
* \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).
*/
}
}
}
-
// Create a new seqEntry if necessary
if (!seqEntry)
{
return NULL;
}
}
-
return seqEntry;
}
/**
* \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
+ * \brief Loads (from disk) the element content
+ * when a string is not suitable
* @param group group number of the Entry
* @param elem element number of the Entry
*/
}
/**
- * \brief Loads (from disk) the element content
- * when a string is not suitable
- * @param element Entry whose binArea is going to be loaded
+ * \brief Loads (from disk) the element content
+ * when a string is not suitable
+ * @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;
return false;
}*/
-/**
- * \brief retrieves a Dicom Element (the first one) using (group, element)
- * \warning (group, element) IS NOT an identifier inside the Dicom Header
- * 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
- * @return
- */
-DocEntry *Document::GetDocEntry(uint16_t group, uint16_t element)
-{
- TagKey key = DictEntry::TranslateToKey(group, element);
- if ( !TagHT.count(key))
- {
- return NULL;
- }
- return TagHT.find(key)->second;
-}
-
-/**
- * \brief Same as \ref Document::GetDocEntry except it only
- * returns a result when the corresponding entry is of type
- * ValEntry.
- * @return When present, the corresponding ValEntry.
- */
-ValEntry *Document::GetValEntry(uint16_t group, uint16_t element)
-{
- DocEntry *currentEntry = GetDocEntry(group, element);
- if ( !currentEntry )
- {
- return 0;
- }
- if ( ValEntry *entry = dynamic_cast<ValEntry*>(currentEntry) )
- {
- return entry;
- }
- gdcmVerboseMacro( "Unfound ValEntry.");
-
- return 0;
-}
-
-/**
- * \brief Same as \ref Document::GetDocEntry except it only
- * returns a result when the corresponding entry is of type
- * BinEntry.
- * @return When present, the corresponding BinEntry.
- */
-BinEntry *Document::GetBinEntry(uint16_t group, uint16_t element)
-{
- DocEntry *currentEntry = GetDocEntry(group, element);
- if ( !currentEntry )
- {
- return 0;
- }
- if ( BinEntry *entry = dynamic_cast<BinEntry*>(currentEntry) )
- {
- return entry;
- }
- gdcmVerboseMacro( "Unfound BinEntry.");
-
- return 0;
-}
/**
- * \brief Loads the element while preserving the current
- * underlying file position indicator as opposed to
- * to LoadDocEntry that modifies it.
+ * \brief Loads the element while preserving the current
+ * underlying file position indicator as opposed to
+ * LoadDocEntry that modifies it.
* @param entry Header Entry whose value will be loaded.
* @return
*/
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( std::hex << newDocEntry->GetGroup()
//////////////////// 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() );
}
{
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
{
if ( newDocEntry->IsSequenceDelimitor() )
{
- seqEntry->SetSequenceDelimitationItem( newDocEntry );
+ seqEntry->SetDelimitationItem( newDocEntry );
break;
}
}
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;
-
- seqEntry->AddEntry( itemSQ, SQItemNumber );
+ 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->AddSQItem( itemSQ, SQItemNumber );
SQItemNumber++;
if ( !delim_mode && ((long)(Fp->tellg())-offset ) >= l_max )
{
// 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();
-
- // Restore the unproperly loaded values i.e. the group, the element
- // and the dictionary entry depending on them.
-// uint16_t correctGroup = SwapShort( entry->GetGroup() );
+// 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 )
+// DictEntry *newTag = GetDictEntry( correctGroup, correctElem );
+// if ( !newTag )
// {
- // This correct tag is not in the dictionary. Create a new one.
+// // This correct tag is not in the dictionary. Create a new one.
// newTag = NewVirtualDictEntry(correctGroup, correctElem);
// }
- // FIXME this can create a memory leaks on the old entry that be
- // left unreferenced.
+// // FIXME this can create a memory leaks on the old entry that be
+// // left unreferenced.
// entry->SetDictEntry( newTag );
// }
-
// 0xffff means that we deal with 'No Length' Sequence
// or 'No Length' SQItem
// 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);
}
/**
* \brief Loads all the needed Dictionaries
* \warning NOT end user intended method !
*/
-void Document::Initialise()
+void Document::Initialize()
{
RefPubDict = Global::GetDicts()->GetDefaultPubDict();
RefShaDict = NULL;
}
}
-
-
/**
* \brief Change the Byte Swap code.
*/
*/
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()
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 )
<< GetTransferSyntaxName() << "]" );
SwitchByteSwapCode();
group = SwapShort(group);
- elem = SwapShort(elem);
+ elem = SwapShort(elem);
}
}
}
if ( newEntry->GetGroup() != 0xfffe )
{
std::string msg;
- msg = Util::Format("Falsely explicit vr file (%04x,%04x)\n",
+ msg = Util::Format("Entry (%04x,%04x) should be Explicit VR\n",
newEntry->GetGroup(), newEntry->GetElement());
gdcmVerboseMacro( msg.c_str() );
}
*/
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