-// gdcmHeader.cxx
+// gdcmParser.cxx
//-----------------------------------------------------------------------------
+//#define UINT32_MAX (4294967295U)
+
+
#include "gdcmParser.h"
+#include "gdcmGlobal.h"
#include "gdcmUtil.h"
+#include "gdcmDebug.h"
+
#include <errno.h>
+#include <vector>
// For nthos:
#ifdef _MSC_VER
#include <netinet/in.h>
#endif
-#ifdef GDCM_NO_ANSI_STRING_STREAM
-# include <strstream>
-# define ostringstream ostrstream
-# else
-# include <sstream>
-#endif
# include <iomanip>
#define UI1_2_840_10008_1_2 "1.2.840.10008.1.2"
#define UI1_2_840_10008_1_2_2 "1.2.840.10008.1.2.2"
#define UI1_2_840_10008_1_2_1_99 "1.2.840.10008.1.2.1.99"
- // Fourth semantics:
- //
- // ---> Warning : This fourth field is NOT part
- // of the 'official' Dicom Dictionnary
- // and should NOT be used.
- // (Not defined for all the groups
- // may be removed in a future release)
- //
- // CMD Command
- // META Meta Information
- // DIR Directory
- // ID
- // PAT Patient
- // ACQ Acquisition
- // REL Related
- // IMG Image
- // SDY Study
- // VIS Visit
- // WAV Waveform
- // PRC
- // DEV Device
- // NMI Nuclear Medicine
- // MED
- // BFS Basic Film Session
- // BFB Basic Film Box
- // BIB Basic Image Box
- // BAB
- // IOB
- // PJ
- // PRINTER
- // RT Radio Therapy
- // DVH
- // SSET
- // RES Results
- // CRV Curve
- // OLY Overlays
- // PXL Pixels
- // DL Delimiters
- //
+typedef struct {
+ guint32 totalSQlength;
+ guint32 alreadyParsedlength;
+} pileElem;
//-----------------------------------------------------------------------------
// Refer to gdcmParser::CheckSwap()
const unsigned int gdcmParser::HEADER_LENGTH_TO_READ = 256;
-// Refer to gdcmParser::SetMaxSizeLoadElementValue()
+// Refer to gdcmParser::SetMaxSizeLoadEntry()
const unsigned int gdcmParser::MAX_SIZE_LOAD_ELEMENT_VALUE = 4096;
+const unsigned int gdcmParser::MAX_SIZE_PRINT_ELEMENT_VALUE = 64;
+
//-----------------------------------------------------------------------------
// Constructor / Destructor
+
/**
- * \ingroup gdcmParser
- * \brief
- * @param InFilename
- * @param exception_on_error
+ * \brief constructor
+ * @param inFilename file to be opened for parsing
+ * @param exception_on_error whether we throw an exception or not
* @param enable_sequences = true to allow the header
- * to be parsed *inside* the SeQuences,
+ * to be parsed *inside* the SeQuences,
* when they have an actual length
- * @param ignore_shadow to allow skipping the shadow elements,
- * to save memory space.
- * \warning The TRUE value for this param has to be used
- * with a FALSE value for the 'enable_sequence' param.
- * ('public elements' may be embedded in 'shadow Sequences')
- */
-gdcmParser::gdcmParser(const char *InFilename,
+ * \warning enable_sequences *has to be* true for reading PAPYRUS 3.0 files
+ * @param ignore_shadow to allow skipping the shadow elements,
+ * to save memory space.
+ * \warning The TRUE value for this param has to be used
+ * with a FALSE value for the 'enable_sequence' param.
+ * ('public elements' may be embedded in 'shadow Sequences')
+ */
+gdcmParser::gdcmParser(const char *inFilename,
bool exception_on_error,
bool enable_sequences,
- bool ignore_shadow) {
+ bool ignore_shadow) {
enableSequences=enable_sequences;
ignoreShadow =ignore_shadow;
- SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
- filename = InFilename;
+ SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
+ filename = inFilename;
Initialise();
if ( !OpenFile(exception_on_error))
return;
- Parse();
- LoadHeaderEntries();
+
+ LoadHeaderEntries();
CloseFile();
wasUpdated = 0; // will be set to 1 if user adds an entry
}
/**
- * \ingroup gdcmParser
- * \brief
+ * \brief constructor
* @param exception_on_error
*/
gdcmParser::gdcmParser(bool exception_on_error) {
+ (void)exception_on_error;
enableSequences=0;
SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
}
/**
- * \ingroup gdcmParser
* \brief Canonical destructor.
*/
gdcmParser::~gdcmParser (void) {
//-----------------------------------------------------------------------------
// Print
/**
- * \ingroup gdcmParser
* \brief Prints the Header Entries (Dicom Elements)
- * both from the H Table and the chained list
+ * from the chained list
* @return
*/
void gdcmParser::PrintEntry(std::ostream & os) {
- std::ostringstream s;
-
+
for (ListTag::iterator i = listEntries.begin();
- i != listEntries.end();
- ++i)
+ i != listEntries.end();
+ ++i)
{
- (*i)->SetPrintLevel(printLevel);
- (*i)->Print(os);
+ (*i)->SetPrintLevel(printLevel);
+ (*i)->Print(os);
}
- os<<s.str();
}
+
/**
- * \ingroup gdcmParser
- * \brief Prints The Dict Entries of THE public Dicom Dictionnry
+ * \brief Prints The Dict Entries of THE public Dicom Dictionary
* @return
*/
void gdcmParser::PrintPubDict(std::ostream & os) {
}
/**
- * \ingroup gdcmParser
- * \brief Prints The Dict Entries of THE shadow Dicom Dictionnry
+ * \brief Prints The Dict Entries of THE shadow Dicom Dictionary
* @return
*/
void gdcmParser::PrintShaDict(std::ostream & os) {
//-----------------------------------------------------------------------------
// Public
/**
- * \ingroup gdcmParser
* \brief Get the public dictionary used
*/
gdcmDict *gdcmParser::GetPubDict(void) {
}
/**
- * \ingroup gdcmParser
* \brief Get the shadow dictionary used
*/
gdcmDict *gdcmParser::GetShaDict(void) {
}
/**
- * \ingroup gdcmParser
* \brief Set the shadow dictionary used
* \param dict dictionary to use in shadow
*/
}
/**
- * \ingroup gdcmParser
* \brief Set the shadow dictionary used
* \param dictName name of the dictionary to use in shadow
*/
}
/**
- * \ingroup gdcmParser
* \brief This predicate, based on hopefully reasonable heuristics,
* decides whether or not the current gdcmParser was properly parsed
* and contains the mandatory information for being considered as
* @return true when gdcmParser is the one of a reasonable Dicom/Acr file,
* false otherwise.
*/
-bool gdcmParser::IsReadable(void) {
- if(filetype==Unknown)
+bool gdcmParser::IsReadable(void) {
+ if(filetype==gdcmUnknown) {
return(false);
-
- if(listEntries.size()<=0)
+ }
+ if(listEntries.size()<=0) {
return(false);
+ }
return(true);
}
/**
- * \ingroup gdcmParser
* \brief Determines if the Transfer Syntax was already encountered
* and if it corresponds to a ImplicitVRLittleEndian one.
- *
* @return True when ImplicitVRLittleEndian found. False in all other cases.
*/
bool gdcmParser::IsImplicitVRLittleEndianTransferSyntax(void) {
}
/**
- * \ingroup gdcmParser
* \brief Determines if the Transfer Syntax was already encountered
* and if it corresponds to a ExplicitVRLittleEndian one.
- *
* @return True when ExplicitVRLittleEndian found. False in all other cases.
*/
bool gdcmParser::IsExplicitVRLittleEndianTransferSyntax(void) {
}
/**
- * \ingroup gdcmParser
* \brief Determines if the Transfer Syntax was already encountered
* and if it corresponds to a DeflatedExplicitVRLittleEndian one.
- *
* @return True when DeflatedExplicitVRLittleEndian found. False in all other cases.
*/
bool gdcmParser::IsDeflatedExplicitVRLittleEndianTransferSyntax(void) {
}
/**
- * \ingroup gdcmParser
* \brief Determines if the Transfer Syntax was already encountered
* and if it corresponds to a Explicit VR Big Endian one.
- *
* @return True when big endian found. False in all other cases.
*/
bool gdcmParser::IsExplicitVRBigEndianTransferSyntax(void) {
}
/**
- * \ingroup gdcmParser
* \brief returns the File Type
- * (ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown)
- * @return
+ * (ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unfound)
+ * @return the FileType code
*/
FileType gdcmParser::GetFileType(void) {
return(filetype);
}
/**
- * \ingroup gdcmParser
* \brief opens the file
* @param exception_on_error
* @return
return(fp);
fclose(fp);
- dbg.Verbose(0, "gdcmParser::gdcmParser not DICOM/ACR", filename.c_str());
+ dbg.Verbose(0, "gdcmParser::OpenFile not DICOM/ACR", filename.c_str());
}
else {
- dbg.Verbose(0, "gdcmParser::gdcmParser cannot open file", filename.c_str());
+ dbg.Verbose(0, "gdcmParser::OpenFile cannot open file", filename.c_str());
}
return(NULL);
}
/**
- * \ingroup gdcmParser
* \brief closes the file
* @return TRUE if the close was successfull
*/
}
/**
- * \ingroup gdcmParser
- * \brief
+ * \brief Writes in a file all the Header Entries (Dicom Elements)
+ * of the Chained List
* @param fp file pointer on an already open file
- * @param type type of the File to be written
+ * @param type Type of the File to be written
* (ACR-NEMA, ExplicitVR, ImplicitVR)
- * @return always "True" ?!
+ * \return Always true.
*/
bool gdcmParser::Write(FILE *fp, FileType type) {
-// ==============
-// TODO The stuff has been rewritten using the chained list instead
-// of the H table
-// so we could remove the GroupHT from the gdcmParser
-// To be checked
-// =============
-
- // TODO : move the following lines (and a lot of others, to be written)
- // to a future function CheckAndCorrectHeader
+/// \todo
+/// ==============
+/// The stuff will have to be rewritten using the SeQuence based
+/// tree-like stucture instead of the chained list .
+/// (so we shall remove the GroupHT from the gdcmParser)
+/// To be checked
+/// =============
+
+ /// \todo move the following lines (and a lot of others, to be written)
+ /// to a future function CheckAndCorrectHeader
- // Question :
- // Comment pourrait-on savoir si le DcmHeader vient d'un fichier DicomV3 ou non
- // (FileType est un champ de gdcmParser ...)
- // WARNING : Si on veut ecrire du DICOM V3 a partir d'un DcmHeader ACR-NEMA
- // no way
- // a moins de se livrer a un tres complique ajout des champs manquants.
- // faire un CheckAndCorrectHeader (?)
-
-
- if (type == ImplicitVR)
+ /// \todo
+ /// Question :
+ /// Comment pourrait-on savoir si le DcmHeader vient d'un fichier
+ /// DicomV3 ou non (FileType est un champ de gdcmParser ...)
+ /// WARNING : Si on veut ecrire du DICOM V3 a partir d'un DcmHeader ACR-NEMA
+ /// no way
+ /// a moins de se livrer a un tres complique ajout des champs manquants.
+ /// faire un CheckAndCorrectHeader (?)
+
+ if (type == gdcmImplicitVR)
{
std::string implicitVRTransfertSyntax = UI1_2_840_10008_1_2;
ReplaceOrCreateByNumber(implicitVRTransfertSyntax,0x0002, 0x0010);
- //FIXME Refer to standards on page 21, chapter 6.2 "Value representation":
- // values with a VR of UI shall be padded with a single trailing null
- // Dans le cas suivant on doit pader manuellement avec un 0
+ /// \todo Refer to standards on page 21, chapter 6.2
+ /// "Value representation": values with a VR of UI shall be
+ /// padded with a single trailing null
+ /// Dans le cas suivant on doit pader manuellement avec un 0
SetEntryLengthByNumber(18, 0x0002, 0x0010);
}
- if (type == ExplicitVR)
+ if (type == gdcmExplicitVR)
{
std::string explicitVRTransfertSyntax = UI1_2_840_10008_1_2_1;
ReplaceOrCreateByNumber(explicitVRTransfertSyntax,0x0002, 0x0010);
- //FIXME Refer to standards on page 21, chapter 6.2 "Value representation":
- // values with a VR of UI shall be padded with a single trailing null
- // Dans le cas suivant on doit pader manuellement avec un 0
+ /// \todo Refer to standards on page 21, chapter 6.2
+ /// "Value representation": values with a VR of UI shall be
+ /// padded with a single trailing null
+ /// Dans le cas suivant on doit pader manuellement avec un 0
SetEntryLengthByNumber(20, 0x0002, 0x0010);
}
+/**
+ * \todo rewrite later, if really usefull
+ *
+ * --> Warning : un-updated odd groups lengths can causes pb
+ * --> (xmedcon breaks)
+ * --> to be re- written with future org.
+ *
+ * if ( (type == ImplicitVR) || (type == ExplicitVR) )
+ * UpdateGroupLength(false,type);
+ * if ( type == ACR)
+ * UpdateGroupLength(true,ACR);
+ */
- if ( (type == ImplicitVR) || (type == ExplicitVR) )
- UpdateGroupLength(false,type);
- if ( type == ACR)
- UpdateGroupLength(true,ACR);
-
- WriteEntries(type, fp);
+ WriteEntries(fp,type);
return(true);
- }
+}
/**
- * \ingroup gdcmParser
* \brief Modifies the value of a given Header Entry (Dicom Element)
- * if it exists; Creates it with the given value if it doesn't
- * @param Value passed as a std::string
- * @param Group
- * @param Elem
- * \return boolean
- */
-bool gdcmParser::ReplaceOrCreateByNumber(std::string Value,
+ * when it exists. Create it with the given value when unexistant.
+ * \warning Adds the Header Entry to the HTable, NOT to the chained List
+ * @param Value Value to be set
+ * @param Group Group of the Entry
+ * @param Elem Element of the Entry
+ * \return pointer to the modified/created Header Entry (NULL when creation
+ * failed).
+ */
+gdcmHeaderEntry * gdcmParser::ReplaceOrCreateByNumber(
+ std::string Value,
guint16 Group,
- guint16 Elem ){
- if (CheckIfEntryExistByNumber(Group, Elem) == 0) {
- gdcmHeaderEntry *a =NewHeaderEntryByNumber(Group, Elem);
+ guint16 Elem ){
+ gdcmHeaderEntry* a;
+ a = GetHeaderEntryByNumber( Group, Elem);
+ if (a == NULL) {
+ a =NewHeaderEntryByNumber(Group, Elem);
if (a == NULL)
- return false;
+ return NULL;
AddHeaderEntry(a);
}
- SetEntryByNumber(Value, Group, Elem);
- return(true);
+ //CLEANME SetEntryByNumber(Value, Group, Elem);
+ a->SetValue(Value);
+ return(a);
}
/**
- * \ingroup gdcmParser
- * \brief Modifies the value of a given Header Entry (Dicom Element)
- * if it exists; Creates it with the given value if it doesn't
- * @param Value passed as a char*
- * @param Group
- * @param Elem
- * \return boolean
- *
- */
-bool gdcmParser::ReplaceOrCreateByNumber(char* Value, guint16 Group, guint16 Elem ) {
- gdcmHeaderEntry* nvHeaderEntry=NewHeaderEntryByNumber(Group, Elem);
-
- if(!nvHeaderEntry)
- return(false);
-
- AddHeaderEntry(nvHeaderEntry);
-
- std::string v = Value;
- SetEntryByNumber(v, Group, Elem);
- return(true);
-}
-
-/**
- * \ingroup gdcmParser
- * \brief Set a new value if the invoked element exists
- * Seems to be useless !!!
- * @param Value
- * @param Group
- * @param Elem
+ * \brief Set a new value if the invoked element exists
+ * Seems to be useless !!!
+ * @param Value new element value
+ * @param Group group of the Entry
+ * @param Elem element of the Entry
* \return boolean
*/
bool gdcmParser::ReplaceIfExistByNumber(char* Value, guint16 Group, guint16 Elem )
{
- std::string v = Value;
+ std::string v = Value;
SetEntryByNumber(v, Group, Elem);
return true;
}
//-----------------------------------------------------------------------------
// Protected
+
/**
- * \ingroup gdcmParser
* \brief Checks if a given Dicom Element exists
- * \ within the H table
+ * within the H table
* @param group Group number of the searched Dicom Element
* @param element Element number of the searched Dicom Element
* @return number of occurences
*/
int gdcmParser::CheckIfEntryExistByNumber(guint16 group, guint16 element ) {
- std::string key = gdcmDictEntry::TranslateToKey(group, element );
- return (tagHT.count(key));
+ std::string key = gdcmDictEntry::TranslateToKey(group, element );
+ return (tagHT.count(key));
}
/**
- * \ingroup gdcmParser
* \brief Searches within Header Entries (Dicom Elements) parsed with
* the public and private dictionaries
* for the element value of a given tag.
}
/**
- * \ingroup gdcmParser
* \brief Searches within Header Entries (Dicom Elements) parsed with
* the public and private dictionaries
* for the element value representation of a given tag.
return GDCM_UNFOUND;
gdcmHeaderEntry* elem = GetHeaderEntryByNumber(dictEntry->GetGroup(),
- dictEntry->GetElement());
+ dictEntry->GetElement());
return elem->GetVR();
}
+
/**
- * \ingroup gdcmParser
* \brief Searches within Header Entries (Dicom Elements) parsed with
* the public and private dictionaries
* for the element value representation of a given tag.
}
/**
- * \ingroup gdcmParser
* \brief Searches within Header Entries (Dicom Elements) parsed with
* the public and private dictionaries
* for the element value representation of a given tag..
}
/**
- * \ingroup gdcmParser
+ * \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 of the searched tag.
+ * @param element Element of the searched tag.
+ * @return Corresponding element length; -2 if not found
+ */
+int gdcmParser::GetEntryLengthByNumber(guint16 group, guint16 element) {
+ gdcmHeaderEntry* elem = GetHeaderEntryByNumber(group, element);
+ if ( !elem )
+ return -2;
+ return elem->GetLength();
+}
+/**
* \brief Sets the value (string) of the Header Entry (Dicom Element)
* @param content string value of the Dicom Element
* @param tagName name of the searched Dicom Element.
bool gdcmParser::SetEntryByName(std::string content,std::string tagName) {
gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName);
if( dictEntry == NULL)
- return false;
+ return false;
return(SetEntryByNumber(content,dictEntry->GetGroup(),
dictEntry->GetElement()));
}
/**
- * \ingroup gdcmParser
* \brief Accesses an existing gdcmHeaderEntry (i.e. a Dicom Element)
* through it's (group, element) and modifies it's content with
* the given value.
if ( ! tagHT.count(key))
return false;
int l = content.length();
- if(l%2) // Odd length are padded with a space (020H).
+ if(l%2) // Non even length are padded with a space (020H).
{
l++;
content = content + '\0';
else if( (vr == "UL") || (vr == "SL") )
lgr = 4;
else
- lgr = l;
+ lgr = l;
a->SetLength(lgr);
return true;
-}
+}
/**
- * \ingroup gdcmParser
* \brief Accesses an existing gdcmHeaderEntry (i.e. a Dicom Element)
* in the PubHeaderEntrySet of this instance
* through it's (group, element) and modifies it's length with
* the given value.
* \warning Use with extreme caution.
- * @param length new length to substitute with
- * @param group group of the entry to modify
- * @param element element of the Entry to modify
- * @return 1 on success, 0 otherwise.
+ * @param l new length to substitute with
+ * @param group group of the Entry to modify
+ * @param element element of the Entry to modify
+ * @return true on success, false otherwise.
*/
-
-bool gdcmParser::SetEntryLengthByNumber(guint32 length,
+bool gdcmParser::SetEntryLengthByNumber(guint32 l,
guint16 group,
- guint16 element)
+ guint16 element)
{
TagKey key = gdcmDictEntry::TranslateToKey(group, element);
if ( ! tagHT.count(key))
return false;
- if (length%2) length++; // length must be even
- ( ((tagHT.equal_range(key)).first)->second )->SetLength(length);
-
- return true ;
+ if (l%2) l++; // length must be even
+ ( ((tagHT.equal_range(key)).first)->second )->SetLength(l);
+
+ return true ;
}
/**
- * \ingroup gdcmParser
* \brief Gets (from Header) the offset of a 'non string' element value
- * \ (LoadElementValues has already be executed)
- * @param Group
- * @param Elem
+ * (LoadElementValues has already be executed)
+ * @param Group group of the Entry
+ * @param Elem element of the Entry
* @return File Offset of the Element Value
*/
size_t gdcmParser::GetEntryOffsetByNumber(guint16 Group, guint16 Elem)
{
- gdcmHeaderEntry* Entry = GetHeaderEntryByNumber(Group, Elem);
+ gdcmHeaderEntry* Entry = GetHeaderEntryByNumber(Group, Elem);
if (!Entry)
{
dbg.Verbose(1, "gdcmParser::GetHeaderEntryByNumber",
}
/**
- * \ingroup gdcmParser
* \brief Gets (from Header) a 'non string' element value
- * \ (LoadElementValues has already be executed)
- * @param Group
- * @param Elem
+ * (LoadElementValues has already be executed)
+ * @param Group group of the Entry
+ * @param Elem element of the Entry
* @return Pointer to the 'non string' area
*/
void * gdcmParser::GetEntryVoidAreaByNumber(guint16 Group, guint16 Elem)
{
- gdcmHeaderEntry* Entry = GetHeaderEntryByNumber(Group, Elem);
+ gdcmHeaderEntry* Entry = GetHeaderEntryByNumber(Group, Elem);
if (!Entry)
{
dbg.Verbose(1, "gdcmParser::GetHeaderEntryByNumber",
}
/**
- * \ingroup gdcmParser
* \brief Loads (from disk) the element content
* when a string is not suitable
- * @param Group
- * @param Elem
+ * @param Group group of the Entry
+ * @param Elem element of the Entry
*/
void *gdcmParser::LoadEntryVoidArea(guint16 Group, guint16 Elem)
{
return NULL;
size_t o =(size_t)Element->GetOffset();
fseek(fp, o, SEEK_SET);
- int l=Element->GetLength();
- void * a = malloc(l);
+ size_t l=Element->GetLength();
+ char* a = new char[l];
if(!a)
- return NULL;
+ return NULL;
SetEntryVoidAreaByNumber(a, Group, Elem);
- // TODO check the result
+ /// \todo check the result
size_t l2 = fread(a, 1, l ,fp);
if(l != l2)
{
- free(a);
- return NULL;
+ delete[] a;
+ return NULL;
}
+
return a;
}
/**
- * \ingroup gdcmParser
* \brief Sets a 'non string' value to a given Dicom Element
* @param area
* @param group Group number of the searched Dicom Element
*/
bool gdcmParser::SetEntryVoidAreaByNumber(void * area,
guint16 group,
- guint16 element)
+ guint16 element)
{
TagKey key = gdcmDictEntry::TranslateToKey(group, element);
if ( ! tagHT.count(key))
return false;
- ( ((tagHT.equal_range(key)).first)->second )->SetVoidArea(area);
+ ( ((tagHT.equal_range(key)).first)->second )->SetVoidArea(area);
return true;
}
/**
- * \ingroup gdcmParser
- * \brief Update the entries with the shadow dictionary. Only odd entries are
- * analized
+ * \brief Update the entries with the shadow dictionary.
+ * Only non even entries are analyzed
*/
void gdcmParser::UpdateShaEntries(void) {
gdcmDictEntry *entry;
}
/**
- * \ingroup gdcmParser
* \brief Searches within the Header Entries for a Dicom Element of
* a given tag.
* @param tagName name of the searched Dicom Element.
}
/**
- * \ingroup gdcmParser
* \brief retrieves a Dicom Element (the first one) using (group, element)
- * \ warning (group, element) IS NOT an identifier inside the Dicom Header
+ * \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)
*/
gdcmHeaderEntry* gdcmParser::GetHeaderEntryByNumber(guint16 group, guint16 element)
{
- TagKey key = gdcmDictEntry::TranslateToKey(group, element);
+ TagKey key = gdcmDictEntry::TranslateToKey(group, element);
if ( ! tagHT.count(key))
return NULL;
return tagHT.find(key)->second;
}
/**
- * \ingroup gdcmParser
* \brief retrieves the Dicom Elements (all of them) using (group, element)
* @param group Group number of the searched Dicom Element.
* @param element Element number of the searched Dicom Element.
}
/**
- * \ingroup gdcmParser
* \brief Loads the element while preserving the current
* underlying file position indicator as opposed to
* to LoadHeaderEntry that modifies it.
}
/**
- * \ingroup gdcmParser
* \brief Re-computes the length of a ACR-NEMA/Dicom group from a DcmHeader
* \warning : to be re-written using the chained list instead of the H table.
* \warning : DO NOT use (doesn't work any longer because of the multimap)
vr = elem->GetVR();
sprintf(trash, "%04x", gr);
- key = trash; // generate 'group tag'
+ key = trash; // generate 'group tag'
// if the caller decided not to take SEQUENCEs into account
// e.g : he wants to write an ACR-NEMA File
// since it's at the end of the Hash Table
// (fffe,e0dd)
- // pas SEQUENCE en ACR-NEMA
+ // there is SEQUENCE in ACR-NEMA
// WARNING :
// --> la descente a l'interieur' des SQ
// devrait etre faite avec une liste chainee, pas avec une HTable...
if ( groupHt.count(key) == 0) // we just read the first elem of a given group
{
if (el == 0x0000) // the first elem is 0x0000
- {
- groupHt[key] = 0; // initialize group length
+ {
+ groupHt[key] = 0; // initialize group length
}
else
{
}
else // any elem but the first
{
- if (type == ExplicitVR)
+ if (type == gdcmExplicitVR)
{
if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") )
{
{
// FIXME: g++ -Wall -Wstrict-prototypes reports on following line:
// warning: unsigned int format, different type arg
- sscanf(g->first.c_str(),"%x",&gr_bid);
- tk = g->first + "|0000"; // generate the element full tag
+ sscanf(g->first.c_str(),"%x",&gr_bid); //FIXME
+ tk = g->first + "|0000"; // generate the element full tag
if ( tagHT.count(tk) == 0) // if element 0x0000 not found
- {
+ {
gdcmDictEntry * tagZ = new gdcmDictEntry(gr_bid, 0x0000, "UL");
elemZ = new gdcmHeaderEntry(tagZ);
elemZ->SetLength(4);
- AddHeaderEntry(elemZ); // create it
+ AddHeaderEntry(elemZ); // create it
}
else
{
}
/**
- * \ingroup gdcmParser
- * \brief writes on disc according to the requested format
- * \ (ACR-NEMA, ExplicitVR, ImplicitVR) the image
- * \ warning does NOT add the missing elements in the header :
- * \ it's up to the user doing it !
- * \ (function CheckHeaderCoherence to be written)
- * @param type type of the File to be written
- * (ACR-NEMA, ExplicitVR, ImplicitVR)
- * @param _fp already open file pointer
+ * \brief Writes in a file (according to the requested format)
+ * the group, the element, the value representation and the length
+ * of a single gdcmHeaderEntry passed as argument.
+ * @param tag pointer on the gdcmHeaderEntry to be written
+ * @param _fp already open file pointer
+ * @param type type of the File to be written
*/
-void gdcmParser::WriteEntries(FileType type, FILE * _fp)
+void gdcmParser::WriteEntryTagVRLength(gdcmHeaderEntry *tag,
+ FILE *_fp,
+ FileType type)
{
- guint16 gr, el;
- guint32 lgr;
- const char * val;
- std::string vr;
- guint32 val_uint32;
- guint16 val_uint16;
-
- std::vector<std::string> tokens;
-
- // uses now listEntries to iterate, not TagHt!
- //
- // pb : gdcmParser.Add does NOT update listEntries
- // TODO : find a trick (in STL?) to do it, at low cost !
-
- void *ptr;
-
- // TODO (?) tester les echecs en ecriture (apres chaque fwrite)
-
- for (ListTag::iterator tag2=listEntries.begin();
- tag2 != listEntries.end();
- ++tag2)
- {
- gr = (*tag2)->GetGroup();
- el = (*tag2)->GetElement();
- lgr = (*tag2)->GetLength();
- val = (*tag2)->GetValue().c_str();
- vr = (*tag2)->GetVR();
+ guint16 group = tag->GetGroup();
+ std::string vr = tag->GetVR();
+ guint16 el = tag->GetElement();
+ guint32 lgr = tag->GetReadLength();
+
+ if ( (group == 0xfffe) && (el == 0x0000) )
+ // Fix in order to make some MR PHILIPS images e-film readable
+ // see gdcmData/gdcm-MR-PHILIPS-16-Multi-Seq.dcm:
+ // we just *always* ignore spurious fffe|0000 tag !
+ return;
+
+ fwrite ( &group,(size_t)2 ,(size_t)1 ,_fp); //group
+ fwrite ( &el,(size_t)2 ,(size_t)1 ,_fp); //element
- if ( type == ACR )
- {
- if (gr < 0x0008) continue; // ignore pure DICOM V3 groups
- if (gr %2) continue; // ignore shadow groups
- if (vr == "SQ" ) continue; // ignore Sequences
- // TODO : find a trick to *skip* the SeQuences !
- // Not only ignore the SQ element
- if (gr == 0xfffe ) continue; // ignore delimiters
- }
+ if ( type == gdcmExplicitVR ) {
- fwrite ( &gr,(size_t)2 ,(size_t)1 ,_fp); //group
- fwrite ( &el,(size_t)2 ,(size_t)1 ,_fp); //element
+ // Special case of delimiters:
+ if (group == 0xfffe) {
+ // Delimiters have NO Value Representation and have NO length.
+ // Hence we skip writing the VR and length and we pad by writing
+ // 0xffffffff
- if ( (type == ExplicitVR) && (gr <= 0x0002) )
- {
- // EXPLICIT VR
- guint16 z=0, shortLgr;
- fwrite (vr.c_str(),(size_t)2 ,(size_t)1 ,_fp);
+ int ff=0xffffffff;
+ fwrite (&ff,(size_t)4 ,(size_t)1 ,_fp);
+ return;
+ }
- if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") )
+ guint16 z=0;
+ guint16 shortLgr = lgr;
+ if (vr == "unkn") { // Unfound was 'written'
+ // deal with Little Endian
+ fwrite ( &shortLgr,(size_t)2 ,(size_t)1 ,_fp);
+ fwrite ( &z, (size_t)2 ,(size_t)1 ,_fp);
+ } else {
+ fwrite (vr.c_str(),(size_t)2 ,(size_t)1 ,_fp);
+ if ( (vr == "OB") || (vr == "OW") || (vr == "SQ") )
{
fwrite ( &z, (size_t)2 ,(size_t)1 ,_fp);
fwrite ( &lgr,(size_t)4 ,(size_t)1 ,_fp);
-
- }
- else
- {
- shortLgr=lgr;
+ } else {
fwrite ( &shortLgr,(size_t)2 ,(size_t)1 ,_fp);
}
- }
- else // IMPLICIT VR
- {
- fwrite ( &lgr,(size_t)4 ,(size_t)1 ,_fp);
}
+ }
+ else // IMPLICIT VR
+ {
+ fwrite ( &lgr,(size_t)4 ,(size_t)1 ,_fp);
+ }
+}
+
+/**
+ * \brief Writes in a file (according to the requested format)
+ * the value of a single gdcmHeaderEntry passed as argument.
+ * @param tag Pointer on the gdcmHeaderEntry to be written
+ * @param _fp Already open file pointer
+ * @param type type of the File to be written
+ */
+void gdcmParser::WriteEntryValue(gdcmHeaderEntry *tag, FILE *_fp,FileType type)
+{
+ (void)type;
+ guint16 group = tag->GetGroup();
+ std::string vr = tag->GetVR();
+ guint32 lgr = tag->GetReadLength();
- if (vr == "US" || vr == "SS")
+ if (vr == "SQ")
+ // SeQuences have no value:
+ return;
+ if (group == 0xfffe)
+ // Delimiters have no associated value:
+ return;
+
+ void *voidArea;
+ voidArea = tag->GetVoidArea();
+ if (voidArea != NULL)
+ { // there is a 'non string' LUT, overlay, etc
+ fwrite ( voidArea,(size_t)lgr ,(size_t)1 ,_fp); // Elem value
+ return;
+ }
+
+ if (vr == "US" || vr == "SS")
+ {
+ // some 'Short integer' fields may be mulivaluated
+ // each single value is separated from the next one by '\'
+ // we split the string and write each value as a short int
+ std::vector<std::string> tokens;
+ tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
+ Tokenize (tag->GetValue(), tokens, "\\");
+ for (unsigned int i=0; i<tokens.size();i++)
{
- tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
- Tokenize ((*tag2)->GetValue(), tokens, "\\");
- for (unsigned int i=0; i<tokens.size();i++)
- {
- val_uint16 = atoi(tokens[i].c_str());
- ptr = &val_uint16;
- fwrite ( ptr,(size_t)2 ,(size_t)1 ,_fp);
- }
- tokens.clear();
- continue;
+ guint16 val_uint16 = atoi(tokens[i].c_str());
+ void *ptr = &val_uint16;
+ fwrite ( ptr,(size_t)2 ,(size_t)1 ,_fp);
}
- if (vr == "UL" || vr == "SL")
+ tokens.clear();
+ return;
+ }
+ // some 'Integer' fields may be mulivaluated
+ // each single value is separated from the next one by '\'
+ // we split the string and write each value as an int
+ if (vr == "UL" || vr == "SL")
+ {
+ std::vector<std::string> tokens;
+ tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
+ Tokenize (tag->GetValue(), tokens, "\\");
+ for (unsigned int i=0; i<tokens.size();i++)
{
- tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
- Tokenize ((*tag2)->GetValue(), tokens, "\\");
- for (unsigned int i=0; i<tokens.size();i++)
- {
- val_uint32 = atoi(tokens[i].c_str());
- ptr = &val_uint32;
- fwrite ( ptr,(size_t)4 ,(size_t)1 ,_fp);
- }
- tokens.clear();
- continue;
- }
- // Pixels are never loaded in the element !
- if ((gr == 0x7fe0) && (el == 0x0010) )
- break;
+ guint32 val_uint32 = atoi(tokens[i].c_str());
+ void *ptr = &val_uint32;
+ fwrite ( ptr,(size_t)4 ,(size_t)1 ,_fp);
+ }
+ tokens.clear();
+ return;
+ }
+ fwrite (tag->GetValue().c_str(), (size_t)lgr ,(size_t)1, _fp); // Elem value
+}
- fwrite ( val,(size_t)lgr ,(size_t)1 ,_fp); // Elem value
+/**
+ * \brief Writes in a file (according to the requested format)
+ * a single gdcmHeaderEntry passed as argument.
+ * \sa WriteEntryValue, WriteEntryTagVRLength.
+ * @param tag Pointer on the gdcmHeaderEntry to be written
+ * @param _fp Already open file pointer
+ * @param type type of the File to be written
+ */
+
+bool gdcmParser::WriteEntry(gdcmHeaderEntry *tag, FILE *_fp,FileType type)
+{
+ guint32 length = tag->GetLength();
+
+ // The value of a tag MUST (see the DICOM norm) be an odd number of
+ // bytes. When this is not the case, pad with an additional byte:
+ if(length%2==1)
+ {
+ tag->SetValue(tag->GetValue()+"\0");
+ tag->SetLength(tag->GetReadLength()+1);
+ }
+
+ WriteEntryTagVRLength(tag, _fp, type);
+ WriteEntryValue(tag, _fp, type);
+ return true;
+}
+
+/**
+ * \brief writes on disc according to the requested format
+ * (ACR-NEMA, ExplicitVR, ImplicitVR) the image
+ * using the Chained List
+ * \warning does NOT add the missing elements in the header :
+ * it's up to the user doing it !
+ * (function CheckHeaderCoherence to be written)
+ * \warning DON'T try, right now, to write a DICOM image
+ * from an ACR Header (meta elements will be missing!)
+ * \sa WriteEntriesDeprecated (Special temporary method for Theralys)
+ * @param type type of the File to be written
+ * (ACR-NEMA, ExplicitVR, ImplicitVR)
+ * @param _fp already open file pointer
+ */
+
+bool gdcmParser::WriteEntries(FILE *_fp,FileType type)
+{
+ /// \todo (?) check write failures (after *each* fwrite)
+
+ for (ListTag::iterator tag2=listEntries.begin();
+ tag2 != listEntries.end();
+ ++tag2)
+ {
+ if ( type == gdcmACR ){
+ if ((*tag2)->GetGroup() < 0x0008)
+ // Ignore pure DICOM V3 groups
+ continue;
+ if ((*tag2)->GetElement() %2)
+ // Ignore the "shadow" groups
+ continue;
+ if ((*tag2)->GetVR() == "SQ" ) // ignore Sequences
+ continue;
+ if ((*tag2)->GetSQDepthLevel() != 0) // Not only ignore the SQ element
+ continue;
+ }
+ if (! WriteEntry(*tag2,_fp,type) )
+ return false;
+ }
+ return true;
+}
+
+/**
+ * \brief writes on disc according to the requested format
+ * (ACR-NEMA, ExplicitVR, ImplicitVR) the image,
+ * using only the last synonym of each mutimap H Table post.
+ * \warning Uses the H Table, instead of the Chained List
+ * in order to be compliant with the old way to proceed
+ * (added elements taken in to account)
+ * Only THERALYS, during a transitory phase is supposed
+ * to use this method !!!
+ * \warning DON'T try, right now, to write a DICOM image
+ * from an ACR Header (meta elements will be missing!)
+ * \sa WriteEntries
+ * @param _fp already open file pointer
+ * @param type type of the File to be written
+ * (ACR-NEMA, ExplicitVR, ImplicitVR)
+ */
+void gdcmParser::WriteEntriesDeprecated(FILE *_fp,FileType type) {
+
+ // restent a tester les echecs en ecriture (apres chaque fwrite)
+
+ for (TagHeaderEntryHT::iterator tag2=tagHT.begin();
+ tag2 != tagHT.end();
+ ++tag2){
+ if ( type == gdcmACR ){
+ if ((*tag2->second).GetGroup() < 0x0008) continue; // ignore pure DICOM V3 groups
+ if ((*tag2->second).GetElement() %2) continue; // ignore shadow groups
+ if ((*tag2->second).GetVR() == "SQ" ) continue; // ignore Sequences
+ if ((*tag2->second).GetSQDepthLevel() != 0) continue; // Not only ignore the SQ element
+ }
+ if ( ! WriteEntry(tag2->second,_fp,type))
+ break;
}
}
/**
- * \ingroup gdcmParser
* \brief Swaps back the bytes of 4-byte long integer accordingly to
* processor order.
* @return The properly swaped 32 bits integer.
}
/**
- * \ingroup gdcmParser
* \brief Unswaps back the bytes of 4-byte long integer accordingly to
* processor order.
* @return The properly unswaped 32 bits integer.
}
/**
- * \ingroup gdcmParser
* \brief Swaps the bytes so they agree with the processor order
* @return The properly swaped 16 bits integer.
*/
}
/**
- * \ingroup gdcmParser
* \brief Unswaps the bytes so they agree with the processor order
* @return The properly unswaped 16 bits integer.
*/
//-----------------------------------------------------------------------------
// Private
/**
- * \ingroup gdcmParser
- * \brief Parses the header of the file but WITHOUT loading element values.
+ * \brief Parses the header of the file and load element values.
+ * @return false if file is not ACR-NEMA / PAPYRUS / DICOM
*/
-void gdcmParser::Parse(bool exception_on_error) throw(gdcmFormatError) {
- gdcmHeaderEntry *newHeaderEntry = (gdcmHeaderEntry *)0;
-
+bool gdcmParser::LoadHeaderEntries(bool exception_on_error) throw(gdcmFormatError) {
+ (void)exception_on_error;
rewind(fp);
- CheckSwap();
+ if (!CheckSwap())
+ return false;
+
+ gdcmHeaderEntry *newHeaderEntry = (gdcmHeaderEntry *)0;
while ( (newHeaderEntry = ReadNextHeaderEntry()) ) {
SkipHeaderEntry(newHeaderEntry);
- if ( (ignoreShadow==0) || (newHeaderEntry->GetGroup()%2) == 0) { //JPR
+ if ( (ignoreShadow==0) || (newHeaderEntry->GetGroup()%2) == 0) {
AddHeaderEntry(newHeaderEntry);
- }
- }
-}
-
-/**
- * \ingroup gdcmParser
- * \brief Loads the element values of all the Header Entries pointed in the
- * public Chained List.
- */
-void gdcmParser::LoadHeaderEntries(void) {
- rewind(fp);
- for (ListTag::iterator i = GetListEntry().begin();
- i != GetListEntry().end();
- ++i)
- {
- LoadHeaderEntry(*i);
- }
-
+ }
+ }
rewind(fp);
-
- // Load 'non string' values
+ // Be carefull : merging this two loops may cause troubles ...
+ for (ListTag::iterator i = GetListEntry().begin();
+ i != GetListEntry().end();
+ ++i)
+ {
+ LoadHeaderEntry(*i);
+ }
+ rewind(fp);
+
+ // Load 'non string' values
+
std::string PhotometricInterpretation = GetEntryByNumber(0x0028,0x0004);
if( PhotometricInterpretation == "PALETTE COLOR " ) {
LoadEntryVoidArea(0x0028,0x1200); // gray LUT
LoadEntryVoidArea(0x0028,0x1221); // Segmented Red Palette Color LUT Data
LoadEntryVoidArea(0x0028,0x1222); // Segmented Green Palette Color LUT Data
LoadEntryVoidArea(0x0028,0x1223); // Segmented Blue Palette Color LUT Data
- }
-
+ }
+ //FIXME later : how to use it?
+ LoadEntryVoidArea(0x0028,0x3006); //LUT Data (CTX dependent)
+
// --------------------------------------------------------------
// Special Patch to allow gdcm to read ACR-LibIDO formated images
//
// if recognition code tells us we deal with a LibIDO image
// we switch lineNumber and columnNumber
//
- std::string RecCode;
+ std::string RecCode;
RecCode = GetEntryByNumber(0x0008, 0x0010); // recognition code
if (RecCode == "ACRNEMA_LIBIDO_1.1" ||
- RecCode == "CANRME_AILIBOD1_1." )
+ RecCode == "CANRME_AILIBOD1_1." ) // for brain-damaged softwares
+ // with "little-endian strings"
{
- filetype = ACR_LIBIDO;
+ filetype = gdcmACR_LIBIDO;
std::string rows = GetEntryByNumber(0x0028, 0x0010);
std::string columns = GetEntryByNumber(0x0028, 0x0011);
SetEntryByNumber(columns, 0x0028, 0x0010);
SetEntryByNumber(rows , 0x0028, 0x0011);
}
- // ----------------- End of Special Patch ----------------
+ // ----------------- End of Special Patch ----------------
+ return true;
}
/**
- * \ingroup gdcmParser
- * \brief Loads the element content if it's length is not bigger
- * than the value specified with
- * gdcmParser::SetMaxSizeLoadEntry()
+ * \brief Loads the element content if its length doesn't exceed
+ * the value specified with gdcmParser::SetMaxSizeLoadEntry()
* @param Entry Header Entry (Dicom Element) to be dealt with
*/
void gdcmParser::LoadHeaderEntry(gdcmHeaderEntry *Entry) {
guint16 group = Entry->GetGroup();
std::string vr= Entry->GetVR();
guint32 length = Entry->GetLength();
- bool SkipLoad = false;
fseek(fp, (long)Entry->GetOffset(), SEEK_SET);
-
- // the test was commented out to 'go inside' the SeQuences
- // we don't any longer skip them !
-
- // if( vr == "SQ" ) // (DO NOT remove this comment)
- // SkipLoad = true;
// A SeQuence "contains" a set of Elements.
// (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 )
- SkipLoad = true;
-
- if ( SkipLoad ) {
- Entry->SetLength(0);
+ if( group == 0xfffe ) {
Entry->SetValue("gdcm::Skipped");
return;
}
Entry->SetValue(s.str());
return;
}
-
- // When integer(s) are expected, read and convert the following
- // n *(two or four bytes)
- // properly i.e. as integers as opposed to a strings.
- // Elements with Value Multiplicity > 1
- // contain a set of integers (not a single one)
-
+
// Any compacter code suggested (?)
if ( IsHeaderEntryAnInteger(Entry) ) {
guint32 NewInt;
std::ostringstream s;
int nbInt;
+ // When short integer(s) are expected, read and convert the following
+ // n *two characters properly i.e. as short integers as opposed to strings.
+ // Elements with Value Multiplicity > 1
+ // contain a set of integers (not a single one)
if (vr == "US" || vr == "SS") {
nbInt = length / 2;
NewInt = ReadInt16();
NewInt = ReadInt16();
s << NewInt;
}
- }
+ }
}
+ // When integer(s) are expected, read and convert the following
+ // n * four characters properly i.e. as integers as opposed to strings.
+ // Elements with Value Multiplicity > 1
+ // contain a set of integers (not a single one)
else if (vr == "UL" || vr == "SL") {
nbInt = length / 4;
NewInt = ReadInt32();
#endif //GDCM_NO_ANSI_STRING_STREAM
Entry->SetValue(s.str());
- return;
+ return;
}
// We need an additional byte for storing \0 that is not on disk
}
/**
- * \ingroup gdcmParser
* \brief add a new Dicom Element pointer to
- * the H Table and to the chained List
+ * the H Table and at the end of the chained List
* \warning push_bash in listEntries ONLY during ParseHeader
* \todo something to allow further Elements addition,
- * \ when position to be taken care of
+ * (at their right place in the chained list)
+ * when position to be taken care of
* @param newHeaderEntry
*/
void gdcmParser::AddHeaderEntry(gdcmHeaderEntry *newHeaderEntry) {
}
/**
- * \ingroup gdcmParser
- * \brief
- * @param Entry Header Entry whose length of the value shall be loaded.
-
- * @return
+ * \brief Find the value Length of the passed Header Entry
+ * @param Entry Header Entry whose length of the value shall be loaded.
*/
void gdcmParser::FindHeaderEntryLength (gdcmHeaderEntry *Entry) {
guint16 element = Entry->GetElement();
- guint16 group = Entry->GetGroup();
+ //guint16 group = Entry->GetGroup(); //FIXME
std::string vr = Entry->GetVR();
guint16 length16;
- if( (element == 0x0010) && (group == 0x7fe0) )
- {
- dbg.SetDebug(-1);
- dbg.Verbose(2, "gdcmParser::FindLength: ",
- "we reached 7fe0 0010");
- }
+
- if ( (filetype == ExplicitVR) && (! Entry->IsImplicitVR()) )
+ if ( (filetype == gdcmExplicitVR) && (! Entry->IsImplicitVR()) )
{
if ( (vr=="OB") || (vr=="OW") || (vr=="SQ") || (vr=="UN") )
{
//dbg.Verbose(0, "gdcmParser::FindLength",
// "Erroneous element length fixed.");
// Actually, length= 0xffff means that we deal with
- // Unknown Sequence Length
+ // Unfound Sequence Length
}
-
FixHeaderEntryFoundLength(Entry, (guint32)length16);
return;
}
else
{
- // Either implicit VR or a non DICOM conformal (see not below) explicit
+ // Either implicit VR or a non DICOM conformal (see note below) explicit
// VR that ommited the VR of (at least) this element. Farts happen.
// [Note: according to the part 5, PS 3.5-2001, section 7.1 p25
// 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.
+
FixHeaderEntryFoundLength(Entry, ReadInt32());
return;
}
}
/**
- * \ingroup gdcmParser
* \brief Find the Value Representation of the current Dicom Element.
* @param Entry
*/
void gdcmParser::FindHeaderEntryVR( gdcmHeaderEntry *Entry)
{
- if (filetype != ExplicitVR)
+ if (filetype != gdcmExplicitVR)
return;
char VR[3];
- int lgrLue;
long PositionOnEntry = ftell(fp);
// 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.
- lgrLue=fread (&VR, (size_t)2,(size_t)1, fp);
+ (void)fread (&VR, (size_t)2,(size_t)1, fp);
VR[2]=0;
if(!CheckHeaderEntryVR(Entry,VR))
{
}
/**
- * \ingroup gdcmParser
* \brief Check the correspondance between the VR of the header entry
* and the taken VR. If they are different, the header entry is
* updated with the new VR.
- * @param Entry
- * @param VR
+ * @param Entry Header Entry to check
+ * @param vr Dicom Value Representation
* @return false if the VR is incorrect of if the VR isn't referenced
* otherwise, it returns true
*/
sprintf(msg,"Falsely explicit vr file (%04x,%04x)\n",
Entry->GetGroup(),Entry->GetElement());
dbg.Verbose(1, "gdcmParser::FindVR: ",msg);
-
+ if (Entry->GetGroup()%2 && Entry->GetElement() == 0x0000) { // Group length is UL !
+ gdcmDictEntry* NewEntry = NewVirtualDictEntry(
+ Entry->GetGroup(),Entry->GetElement(),
+ "UL","FIXME","Group Length");
+ Entry->SetDictEntry(NewEntry);
+ }
return(false);
}
if ( Entry->IsVRUnknown() )
{
// When not a dictionary entry, we can safely overwrite the VR.
- Entry->SetVR(vr);
+ if (Entry->GetElement() == 0x0000) { // Group length is UL !
+ Entry->SetVR("UL");
+ } else {
+ Entry->SetVR(vr);
+ }
}
else if ( Entry->GetVR() != vr )
{
}
/**
- * \ingroup gdcmParser
* \brief Get the transformed value of the header entry. The VR value
* is used to define the transformation to operate on the value
* \warning NOT end user intended method !
std::ostringstream s;
int nbInt;
+ // When short integer(s) are expected, read and convert the following
+ // n * 2 bytes properly i.e. as a multivaluated strings
+ // (each single value is separated fromthe next one by '\'
+ // as usual for standard multivaluated filels
+ // Elements with Value Multiplicity > 1
+ // contain a set of short integers (not a single one)
+
if (vr == "US" || vr == "SS")
{
guint16 NewInt16;
}
}
+ // When integer(s) are expected, read and convert the following
+ // n * 4 bytes properly i.e. as a multivaluated strings
+ // (each single value is separated fromthe next one by '\'
+ // as usual for standard multivaluated filels
+ // Elements with Value Multiplicity > 1
+ // contain a set of integers (not a single one)
else if (vr == "UL" || vr == "SL")
{
guint32 NewInt32;
s << NewInt32;
}
}
-
#ifdef GDCM_NO_ANSI_STRING_STREAM
s << std::ends; // to avoid oddities on Solaris
#endif //GDCM_NO_ANSI_STRING_STREAM
}
/**
- * \ingroup gdcmParser
* \brief Get the reverse transformed value of the header entry. The VR
* value is used to define the reverse transformation to operate on
* the value
}
/**
- * \ingroup gdcmParser
* \brief Skip a given Header Entry
* \warning NOT end user intended method !
* @param entry
}
/**
- * \ingroup gdcmParser
* \brief When the length of an element value is obviously wrong (because
* the parser went Jabberwocky) one can hope improving things by
* applying this heuristic.
*/
void gdcmParser::FixHeaderEntryFoundLength(gdcmHeaderEntry *Entry, guint32 FoundLength)
{
- Entry->SetReadLength(FoundLength); // will be updated only if a bug is found
-
- if ( FoundLength == 0xffffffff)
- {
+ Entry->SetReadLength(FoundLength); // will be updated only if a bug is found
+ if ( FoundLength == 0xffffffff) {
FoundLength = 0;
}
+
+ guint16 gr =Entry->GetGroup();
+ guint16 el =Entry->GetElement();
+
+ if (FoundLength%2) {
+ std::ostringstream s;
+ s << "Warning : Tag with uneven length " << FoundLength
+ << " in x(" << std::hex << gr << "," << el <<")" << std::dec;
+ dbg.Verbose(0,s.str().c_str());
+ }
// Sorry for the patch!
- // XMedCom did the trick to read some nasty GE images ...
- else if (FoundLength == 13)
- {
+ // XMedCom did the trick to read some naughty GE images ...
+ if (FoundLength == 13) {
// The following 'if' will be removed when there is no more
// images on Creatis HDs with a 13 length for Manufacturer...
if ( (Entry->GetGroup() != 0x0008) ||
- ( (Entry->GetElement() != 0x0070) && (Entry->GetElement() != 0x0080) ) ) {
+ ( (Entry->GetElement() != 0x0070) && (Entry->GetElement() != 0x0080) ) ){
// end of remove area
FoundLength =10;
Entry->SetReadLength(10); // a bug is to be fixed
// to fix some garbage 'Leonardo' Siemens images
// May be commented out to avoid overhead
else if ( (Entry->GetGroup() == 0x0009) &&
- ( (Entry->GetElement() == 0x1113) || (Entry->GetElement() == 0x1114) ) )
- {
+ ( (Entry->GetElement() == 0x1113) || (Entry->GetElement() == 0x1114) ) ){
FoundLength =4;
Entry->SetReadLength(4); // a bug is to be fixed
}
// end of fix
-
+
// to try to 'go inside' SeQuences (with length), and not to skip them
else if ( Entry->GetVR() == "SQ")
{
if (enableSequences) // only if the user does want to !
- FoundLength =0; // ReadLength is unchanged
+ FoundLength =0; // ReadLength is unchanged
}
- // a SeQuence Element is beginning
- // Let's forget it's length
- // (we want to 'go inside')
-
- // Pb : *normaly* fffe|e000 is just a marker, its length *should be* zero
- // in gdcm-MR-PHILIPS-16-Multi-Seq.dcm we find lengthes as big as 28800
- // if we set the length to zero IsHeaderEntryAnInteger() breaks...
- // if we don't, we lost 28800 characters from the Header :-(
-
+ // we found a 'delimiter' element
+ // fffe|xxxx is just a marker, we don't take its length into account
else if(Entry->GetGroup() == 0xfffe)
- {
- // sometimes, length seems to be wrong
- FoundLength =0; // some more clever checking to be done !
- // I give up!
- // only gdcm-MR-PHILIPS-16-Multi-Seq.dcm
- // causes troubles :-(
- }
-
+ {
+ // *normally, fffe|0000 doesn't exist !
+ if( Entry->GetElement() != 0x0000 ) // gdcm-MR-PHILIPS-16-Multi-Seq.dcm
+ // causes extra troubles :-(
+ FoundLength =0;
+ }
+
Entry->SetUsableLength(FoundLength);
}
/**
- * \ingroup gdcmParser
- * \brief Apply some heuristics to predict wether the considered
+ * \brief Apply some heuristics to predict whether the considered
* element value contains/represents an integer or not.
* @param Entry The element value on which to apply the predicate.
* @return The result of the heuristical predicate.
else
{
std::ostringstream s;
- int filePosition = ftell(fp);
+ int filePosition = ftell(fp);
s << "Erroneous Group Length element length on : (" \
<< std::hex << group << " , " << element
- << ") -before- position x(" << filePosition << ")"
- << "lgt : " << length;
- // These 2 lines commented out : a *very dirty* patch
- // to go on PrintHeader'ing gdcm-MR-PHILIPS-16-Multi-Seq.dcm.
- // have a glance at offset x(8336) ...
- // For *regular* headers, the test is useless..
- // lets's print a warning message and go on,
- // instead of giving up with an error message
- std::cout << s.str().c_str() << std::endl;
- // dbg.Error("gdcmParser::IsHeaderEntryAnInteger",
- // s.str().c_str());
+ << ") -before- position x(" << filePosition << ")"
+ << "lgt : " << length;
+ // These 2 lines commented out : a *very dirty* patch
+ // to go on PrintHeader'ing gdcm-MR-PHILIPS-16-Multi-Seq.dcm.
+ // have a glance at offset x(8336) ...
+ // For *regular* headers, the test is useless..
+ // lets's print a warning message and go on,
+ // instead of giving up with an error message
+
+ //std::cout << s.str().c_str() << std::endl;
+ // dbg.Error("gdcmParser::IsHeaderEntryAnInteger",
+ // s.str().c_str());
}
}
if ( (vr == "UL") || (vr == "US") || (vr == "SL") || (vr == "SS") )
return false;
}
-
/**
- * \ingroup gdcmParser
- * \brief
- *
+ * \brief Find the Length till the next sequence delimiter
+ * \warning NOT end user intended method !
* @return
*/
+
guint32 gdcmParser::FindHeaderEntryLengthOB(void) {
// See PS 3.5-2001, section A.4 p. 49 on encapsulation of encoded pixel data.
guint16 g;
return 0;
TotalLength += 4; // We even have to decount the group and element
- if ( g != 0xfffe && g!=0xb00c ) /*for bogus header */
+ if ( g != 0xfffe && g!=0xb00c ) //for bogus header
{
char msg[100]; // for sprintf. Sorry
sprintf(msg,"wrong group (%04x) for an item sequence (%04x,%04x)\n",g, g,n);
errno = 1;
return 0;
}
- if ( n == 0xe0dd || ( g==0xb00c && n==0x0eb6 ) ) /* for bogus header */
+ if ( n == 0xe0dd || ( g==0xb00c && n==0x0eb6 ) ) // for bogus header
FoundSequenceDelimiter = true;
else if ( n != 0xe000 )
{
}
/**
- * \ingroup gdcmParser
* \brief Reads a supposed to be 16 Bits integer
- * \ (swaps it depending on processor endianity)
- *
+ * (swaps it depending on processor endianity)
* @return read value
*/
guint16 gdcmParser::ReadInt16(void) {
}
/**
- * \ingroup gdcmParser
* \brief Reads a supposed to be 32 Bits integer
- * \ (swaps it depending on processor endianity)
- *
+ * (swaps it depending on processor endianity)
* @return read value
*/
guint32 gdcmParser::ReadInt32(void) {
}
/**
- * \ingroup gdcmParser
- * \brief
- *
+ * \brief skips bytes inside the source file
+ * \warning NOT end user intended method !
* @return
*/
void gdcmParser::SkipBytes(guint32 NBytes) {
}
/**
- * \ingroup gdcmParser
- * \brief
+ * \brief Loads all the needed Dictionaries
+ * \warning NOT end user intended method !
*/
void gdcmParser::Initialise(void)
{
}
/**
- * \ingroup gdcmParser
* \brief Discover what the swap code is (among little endian, big endian,
* bad little endian, bad big endian).
- *
+ * sw is set
+ * @return false when we are absolutely sure
+ * it's neither ACR-NEMA nor DICOM
+ * true when we hope ours assuptions are OK
*/
-void gdcmParser::CheckSwap() {
+bool gdcmParser::CheckSwap() {
// The only guaranted way of finding the swap code is to find a
// group tag since we know it's length has to be of four bytes i.e.
// 0x00000004. Finding the swap code in then straigthforward. Trouble
// occurs when we can't find such group...
- guint32 s;
guint32 x=4; // x : for ntohs
bool net2host; // true when HostByteOrder is the same as NetworkByteOrder
-
+ guint32 s32;
+ guint16 s16;
+
int lgrLue;
char *entCur;
char deb[HEADER_LENGTH_TO_READ];
// * the 4 bytes of the first tag (0002, 0000),or (0002, 0001)
// 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 (Transfert Syntax) tells us the file is
+ // *Implicit* VR. -and it is !-
+
+ 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*
// FIXME
// Use gdcmParser::dicom_vr to test all the possibilities
- // instead of just checking for UL, OB and UI !?
- if( (memcmp(entCur, "UL", (size_t)2) == 0) ||
- (memcmp(entCur, "OB", (size_t)2) == 0) ||
- (memcmp(entCur, "UI", (size_t)2) == 0) )
+ // instead of just checking for UL, OB and UI !? group 0000
{
- filetype = ExplicitVR;
+ filetype = gdcmExplicitVR;
dbg.Verbose(1, "gdcmParser::CheckSwap:",
"explicit Value Representation");
}
else
{
- filetype = ImplicitVR;
+ filetype = gdcmImplicitVR;
dbg.Verbose(1, "gdcmParser::CheckSwap:",
"not an explicit Value Representation");
}
+
if (net2host)
{
sw = 4321;
// after the file preamble and the "DICM" string).
rewind(fp);
fseek (fp, 132L, SEEK_SET);
- return;
+ return true;
} // End of DicomV3
// Alas, this is not a DicomV3 file and whatever happens there is no file
// We assume the array of char we are considering contains the binary
// representation of a 32 bits integer. Hence the following dirty
// trick :
- s = *((guint32 *)(entCur));
+ s32 = *((guint32 *)(entCur));
- switch (s) {
+ switch (s32) {
case 0x00040000 :
sw = 3412;
- filetype = ACR;
- return;
+ filetype = gdcmACR;
+ return true;
case 0x04000000 :
sw = 4321;
- filetype = ACR;
- return;
+ filetype = gdcmACR;
+ return true;
case 0x00000400 :
sw = 2143;
- filetype = ACR;
- return;
+ filetype = gdcmACR;
+ return true;
case 0x00000004 :
sw = 0;
- filetype = ACR;
- return;
+ filetype = gdcmACR;
+ return true;
default :
- dbg.Verbose(0, "gdcmParser::CheckSwap:",
- "ACR/NEMA unfound swap info (time to raise bets)");
- }
- // We are out of luck. It is not a DicomV3 nor a 'clean' ACR/NEMA file.
- // It is time for despaired wild guesses. So, let's assume this file
- // happens to be 'dirty' ACR/NEMA, i.e. the length of the group is
- // not present. Then the only info we have is the net2host one.
- filetype = Unknown;
- if (! net2host )
- sw = 0;
- else
- sw = 4321;
- return;
+ // We are out of luck. It is not a DicomV3 nor a 'clean' ACR/NEMA file.
+ // It is time for despaired wild guesses.
+ // So, let's check if this file wouldn't happen to be 'dirty' ACR/NEMA,
+ // i.e. the 'group length' element is not present :
+
+ // check the supposed to be 'group number'
+ // 0x0002 or 0x0004 or 0x0008
+ // to determine ' sw' value .
+ // 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 -4, 8-)
+ // the file IS NOT ACR-NEMA nor DICOM V3
+ // Find a trick to tell it the caller...
+
+ s16 = *((guint16 *)(deb));
+
+ switch (s16) {
+ case 0x0002 :
+ case 0x0004 :
+ case 0x0008 :
+ sw = 0;
+ filetype = gdcmACR;
+ return true;
+ case 0x0200 :
+ case 0x0400 :
+ case 0x0800 :
+ sw = 4321;
+ filetype = gdcmACR;
+ return true;
+ default :
+ dbg.Verbose(0, "gdcmParser::CheckSwap:",
+ "ACR/NEMA unfound swap info (Really hopeless !)");
+ filetype = gdcmUnknown;
+ return false;
+ }
+
+ // Then the only info we have is the net2host one.
+ //if (! net2host )
+ // sw = 0;
+ //else
+ // sw = 4321;
+ //return;
+ }
}
/**
- * \ingroup gdcmParser
- * \brief
+ * \brief Restore the unproperly loaded values i.e. the group, the element
+ * and the dictionary entry depending on them.
*/
void gdcmParser::SwitchSwapToBigEndian(void)
{
}
/**
- * \ingroup gdcmParser
- * \brief
+ * \brief during parsing, Header Elements too long are not loaded in memory
* @param NewSize
- * @return
*/
void gdcmParser::SetMaxSizeLoadEntry(long NewSize)
{
MaxSizeLoadEntry = NewSize;
}
+
+/**
+ * \brief Header Elements too long will not be printed
+ * \todo See comments of \ref gdcmParser::MAX_SIZE_PRINT_ELEMENT_VALUE
+ * @param NewSize
+ */
+void gdcmParser::SetMaxSizePrintEntry(long NewSize)
+{
+ if (NewSize < 0)
+ return;
+ if ((guint32)NewSize >= (guint32)0xffffffff)
+ {
+ MaxSizePrintEntry = 0xffffffff;
+ return;
+ }
+ MaxSizePrintEntry = NewSize;
+}
+
/**
- * \ingroup gdcmParser
* \brief Searches both the public and the shadow dictionary (when they
* exist) for the presence of the DictEntry with given name.
* The public dictionary has precedence on the shadow one.
}
/**
- * \ingroup gdcmParser
* \brief Searches both the public and the shadow dictionary (when they
* exist) for the presence of the DictEntry with given
* group and element. The public dictionary has precedence on the
}
/**
- * \ingroup gdcmParser
* \brief Read the next tag but WITHOUT loading it's value
* @return On succes the newly created HeaderEntry, NULL on failure.
*/
gdcmHeaderEntry *gdcmParser::ReadNextHeaderEntry(void) {
guint16 g,n;
gdcmHeaderEntry *NewEntry;
-
g = ReadInt16();
n = ReadInt16();
// header parsing has to be considered as finished.
return (gdcmHeaderEntry *)0;
-/* Pb : how to propagate the element length (used in SkipHeaderEntry)
+// Pb : how to propagate the element length (used in SkipHeaderEntry)
// direct call to SkipBytes ?
- if (ignoreShadow == 1 && g%2 ==1) //JPR
+// if (ignoreShadow == 1 && g%2 ==1)
// if user wants to skip shadow groups
// and current element *is* a shadow element
// we don't create anything
- return (gdcmHeaderEntry *)1; // to tell caller it's NOT finished
-*/
+// return (gdcmHeaderEntry *)1; // to tell caller it's NOT finished
+
NewEntry = NewHeaderEntryByNumber(g, n);
FindHeaderEntryVR(NewEntry);
FindHeaderEntryLength(NewEntry);
-
+
if (errno == 1) {
// Call it quits
return NULL;
}
NewEntry->SetOffset(ftell(fp));
- //if ( (g==0x7fe0) && (n==0x0010) )
return NewEntry;
}
/**
- * \ingroup gdcmParser
* \brief Build a new Element Value from all the low level arguments.
* Check for existence of dictionary entry, and build
* a default one when absent.
{
gdcmDictEntry *NewTag = GetDictEntryByName(Name);
if (!NewTag)
- NewTag = NewVirtualDictEntry(0xffff, 0xffff, "LO", "Unknown", Name);
+ NewTag = NewVirtualDictEntry(0xffff, 0xffff, "LO", "unkn", Name);
gdcmHeaderEntry* NewEntry = new gdcmHeaderEntry(NewTag);
if (!NewEntry)
}
/**
- * \ingroup gdcmParser
* \brief Request a new virtual dict entry to the dict set
* @param group group of the underlying DictEntry
- * @param elem element of the underlying DictEntry
+ * @param element element of the underlying DictEntry
* @param vr VR of the underlying DictEntry
* @param fourth owner group
* @param name english name
}
/**
- * \ingroup gdcmParser
* \brief Build a new Element Value from all the low level arguments.
* Check for existence of dictionary entry, and build
* a default one when absent.
return NewEntry;
}
+/// \todo Never used; commented out, waiting for removal.
/**
- * \ingroup gdcmParser
* \brief Small utility function that creates a new manually crafted
* (as opposed as read from the file) gdcmHeaderEntry with user
* specified name and adds it to the public tag hash table.
* @param VR The Value Representation to be given to this new tag.
* @return The newly hand crafted Element Value.
*/
-gdcmHeaderEntry *gdcmParser::NewManualHeaderEntryToPubDict(std::string NewTagName,
- std::string VR)
-{
- gdcmHeaderEntry *NewEntry = NULL;
- guint32 StuffGroup = 0xffff; // Group to be stuffed with additional info
- guint32 FreeElem = 0;
- gdcmDictEntry *DictEntry = NULL;
-
- FreeElem = GenerateFreeTagKeyInGroup(StuffGroup);
- if (FreeElem == UINT32_MAX)
- {
- dbg.Verbose(1, "gdcmHeader::NewManualHeaderEntryToPubDict",
- "Group 0xffff in Public Dict is full");
- return NULL;
- }
-
- DictEntry = NewVirtualDictEntry(StuffGroup, FreeElem,
- VR, "GDCM", NewTagName);
- NewEntry = new gdcmHeaderEntry(DictEntry);
- AddHeaderEntry(NewEntry);
- return NewEntry;
-}
+//gdcmHeaderEntry *gdcmParser::NewManualHeaderEntryToPubDict(std::string NewTagName,
+// std::string VR)
+//{
+// gdcmHeaderEntry *NewEntry = NULL;
+// guint32 StuffGroup = 0xffff; // Group to be stuffed with additional info
+// guint32 FreeElem = 0;
+// gdcmDictEntry *DictEntry = NULL;
+//
+// FreeElem = GenerateFreeTagKeyInGroup(StuffGroup);
+// if (FreeElem == UINT32_MAX)
+// {
+// dbg.Verbose(1, "gdcmHeader::NewManualHeaderEntryToPubDict",
+// "Group 0xffff in Public Dict is full");
+// return NULL;
+// }
+//
+// DictEntry = NewVirtualDictEntry(StuffGroup, FreeElem,
+// VR, "GDCM", NewTagName);
+// NewEntry = new gdcmHeaderEntry(DictEntry);
+// AddHeaderEntry(NewEntry);
+// return NewEntry;
+//}
/**
- * \ingroup gdcmParser
* \brief Generate a free TagKey i.e. a TagKey that is not present
* in the TagHt dictionary.
* @param group The generated tag must belong to this group.
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff