// gdcmParser.cxx
//-----------------------------------------------------------------------------
-#include "gdcmParser.h"
-#include "gdcmUtil.h"
#include <errno.h>
+#include <vector>
// For nthos:
#ifdef _MSC_VER
#endif
# include <iomanip>
+#include "gdcmParser.h"
+#include "gdcmGlobal.h"
+#include "gdcmUtil.h"
+#include "gdcmDebug.h"
+
#define UI1_2_840_10008_1_2 "1.2.840.10008.1.2"
#define UI1_2_840_10008_1_2_1 "1.2.840.10008.1.2.1"
#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
- //
-
- // Other usefull abreviations :
- // Radiographic view associated with Patient Position (0018,5100).
- // Defined Terms:
- //
- // AP = Anterior/Posterior
- // PA = Posterior/Anterior
- // LL = Left Lateral
- // RL = Right Lateral
- // RLD = Right Lateral Decubitus
- // LLD = Left Lateral Decubitus
- // RLO = Right Lateral Oblique
- // LLO = Left Lateral Oblique
-
//-----------------------------------------------------------------------------
// Refer to gdcmParser::CheckSwap()
const unsigned int gdcmParser::HEADER_LENGTH_TO_READ = 256;
// Constructor / Destructor
/**
- * \ingroup gdcmParser
- * \brief constructor
+ * \brief constructor
* @param inFilename
* @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,
* 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')
+ * @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);
+ SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
filename = inFilename;
Initialise();
*/
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
* @return
*/
}
/**
- * \ingroup gdcmParser
- * \brief Prints The Dict Entries of THE shadow Dicom Dictionnry
+ * \brief Prints The Dict Entries of THE shadow Dicom Dictionnary
* @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
}
/**
- * \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.
}
/**
- * \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.
}
/**
- * \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.
}
/**
- * \ingroup gdcmParser
* \brief returns the File Type
* (ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown)
* @return the FileType code
}
/**
- * \ingroup gdcmParser
* \brief opens the file
* @param exception_on_error
* @return
}
/**
- * \ingroup gdcmParser
* \brief closes the file
* @return TRUE if the close was successfull
*/
}
/**
- * \ingroup gdcmParser
- * \brief writes on disc all the Header Entries (Dicom Elements)
+ * \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 : 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 (?)
-
+ // 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)
{
SetEntryLengthByNumber(20, 0x0002, 0x0010);
}
-/* TODO : rewrite later
+/* TODO : rewrite later, if really usefull
if ( (type == ImplicitVR) || (type == ExplicitVR) )
UpdateGroupLength(false,type);
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
- * \warning : adds the Header Entry to the HTable, NOT to the chained List
- * @param Value passed as a std::string
- * @param Group group of the Entry
- * @param Elem element of the Entry
- * \return pointer to the created Header Entry
- * NULL if creation failed
+ * 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 ){
+ guint16 Elem ){
gdcmHeaderEntry* a;
- a = GetHeaderEntryByNumber( Group, Elem);
+ a = GetHeaderEntryByNumber( Group, Elem);
if (a == NULL) {
- gdcmHeaderEntry *a =NewHeaderEntryByNumber(Group, Elem);
+ gdcmHeaderEntry *a = NewHeaderEntryByNumber(Group, Elem);
if (a == NULL)
return NULL;
AddHeaderEntry(a);
}
- //SetEntryByNumber(Value, Group, Elem);
+ //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 group of the Entry
- * @param Elem element of the Entry
- * \return pointer to the created Header Entry
- * NULL if creation failed
- *
- */
-gdcmHeaderEntry * gdcmParser::ReplaceOrCreateByNumber(
- char* Value,
- guint16 Group,
- guint16 Elem ) {
- gdcmHeaderEntry* nvHeaderEntry=NewHeaderEntryByNumber(Group, Elem);
-
- if(!nvHeaderEntry)
- return(NULL);
-
- AddHeaderEntry(nvHeaderEntry);
-
- std::string v = Value;
- SetEntryByNumber(v, Group, Elem);
- return(nvHeaderEntry);
-}
-
-/**
- * \ingroup gdcmParser
- * \brief Set a new value if the invoked element exists
- * Seems to be useless !!!
+ * \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
*/
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
* @param group Group 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));
}
/**
return GDCM_UNFOUND;
gdcmHeaderEntry* elem = GetHeaderEntryByNumber(dictEntry->GetGroup(),
- dictEntry->GetElement());
+ dictEntry->GetElement());
return elem->GetVR();
}
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()));
else if( (vr == "UL") || (vr == "SL") )
lgr = 4;
else
- lgr = l;
+ lgr = l;
a->SetLength(lgr);
return true;
-}
+}
/**
* \ingroup gdcmParser
*/
bool gdcmParser::SetEntryLengthByNumber(guint32 l,
guint16 group,
- guint16 element)
+ guint16 element)
{
TagKey key = gdcmDictEntry::TranslateToKey(group, element);
if ( ! tagHT.count(key))
return false;
if (l%2) l++; // length must be even
- ( ((tagHT.equal_range(key)).first)->second )->SetLength(l);
-
- return true ;
+ ( ((tagHT.equal_range(key)).first)->second )->SetLength(l);
+
+ return true ;
}
/**
*/
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",
*/
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 group of the Entry
int l=Element->GetLength();
void * a = malloc(l);
if(!a)
- return NULL;
+ return NULL;
SetEntryVoidAreaByNumber(a, Group, Elem);
// TODO check the result
size_t l2 = fread(a, 1, l ,fp);
if(l != l2)
{
- free(a);
- return NULL;
+ free(a);
+ return NULL;
}
return a;
*/
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 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
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
{
// 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
+ 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) ONE
- * gdcmHeaderEntry
- * @param tag pointer on the gdcmHeaderEntry 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::WriteEntry(gdcmHeaderEntry *tag, FILE *_fp,FileType type)
+void gdcmParser::WriteEntryTagVRLength(gdcmHeaderEntry *tag,
+ FILE *_fp,
+ FileType type)
{
- guint16 gr, el;
- guint32 lgr;
- std::string value;
- const char * val;
- std::string vr;
- guint32 val_uint32;
- guint16 val_uint16;
- guint16 valZero =0;
- void *voidArea;
- std::vector<std::string> tokens;
+ guint16 group = tag->GetGroup();
+ std::string vr = tag->GetVR();
+ guint16 el = tag->GetElement();
+ guint32 lgr = tag->GetReadLength();
- void *ptr;
- int ff=0xffffffff;
- // TODO (?) tester les echecs en ecriture (apres chaque fwrite)
- int compte =0;
- itsTimeToWritePixels = false;
-
- // === Deal with the length
- // --------------------
- if((tag->GetLength())%2==1)
- {
- tag->SetValue(tag->GetValue()+"\0");
- tag->SetLength(tag->GetReadLength()+1);
- }
-
- gr = tag->GetGroup();
- el = tag->GetElement();
- lgr = tag->GetReadLength();
- val = tag->GetValue().c_str();
- vr = tag->GetVR();
- voidArea = tag->GetVoidArea();
+ 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) return; // ignore pure DICOM V3 groups
- if (gr %2) return; // ignore shadow groups
- if (vr == "SQ" ) return; // ignore Sequences
- // TODO : find a trick to *skip* the SeQuences !
- // Not only ignore the SQ element
- if (gr == 0xfffe ) return; // ignore delimiters
- }
+ if ( type == ExplicitVR ) {
+
+ // 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 (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 ignore spurious fffe|0000 tag !
+ return;
- fwrite ( &gr,(size_t)2 ,(size_t)1 ,_fp); //group
- fwrite ( &el,(size_t)2 ,(size_t)1 ,_fp); //element
-
- if ( (type == ExplicitVR) || (type == DICOMDIR) ) {
- // EXPLICIT VR
- guint16 z=0, shortLgr;
-
- if (gr == 0xfffe) { // NO Value Representation for 'delimiters'
- // no length : write ffffffff
- fwrite (&ff,(size_t)4 ,(size_t)1 ,_fp);
- return; // NO value for 'delimiters'
- }
-
- shortLgr=lgr;
- if (vr == "unkn") { // Unknown was 'written'
- // deal with Little Endian
- fwrite ( &shortLgr,(size_t)2 ,(size_t)1 ,_fp);
+ int ff=0xffffffff;
+ fwrite (&ff,(size_t)4 ,(size_t)1 ,_fp);
+ return;
+ }
+
+ guint16 z=0;
+ guint16 shortLgr = lgr;
+ if (vr == "unkn") { // Unknown 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 {
- 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 {
- fwrite ( &shortLgr,(size_t)2 ,(size_t)1 ,_fp);
- }
+ 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);
+ }
+}
- // === Deal with the value
- // -------------------
- if (vr == "SQ") return; // no "value" to write for the SEQuences
- if (gr == 0xfffe)return; // no "value" to write for the delimiters
+/**
+ * \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)
+{
+ guint16 group = tag->GetGroup();
+ std::string vr = tag->GetVR();
+ guint32 lgr = tag->GetReadLength();
+
+ if (vr == "SQ")
+ // SeQuences have no value:
+ return;
+ if (group == 0xfffe)
+ // Delimiters have no associated value:
+ return;
+
- if (voidArea != NULL)
- { // there is a 'non string' LUT, overlay, etc
- fwrite ( voidArea,(size_t)lgr ,(size_t)1 ,_fp); // Elem 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")
+ if (vr == "US" || vr == "SS")
+ {
+ 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 (tag->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();
- return;
+ 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;
+ }
+
+ 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 (tag->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();
- return;
- }
+ guint32 val_uint32 = atoi(tokens[i].c_str());
+ void *ptr = &val_uint32;
+ fwrite ( ptr,(size_t)4 ,(size_t)1 ,_fp);
+ }
+ tokens.clear();
+ return;
+ }
- // Pixels are never loaded in the element !
- // we stop writting when Pixel are processed
- // FIX : we loose trailing elements (RAB, right now)
-
- if ((gr == GrPixel) && (el == NumPixel) ) {
- compte++;
- if (compte == countGrPixel) {// we passed *all* the GrPixel,NumPixel
- itsTimeToWritePixels = true;
- return;
- }
- }
- fwrite ( val,(size_t)lgr ,(size_t)1 ,_fp); // Elem value
+ fwrite (tag->GetValue().c_str(), (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;
}
/**
- * \ingroup gdcmParser
* \brief writes on disc according to the requested format
* (ACR-NEMA, ExplicitVR, ImplicitVR) the image
* using the Chained List
* @param _fp already open file pointer
*/
-void gdcmParser::WriteEntries(FILE *_fp,FileType type)
+bool gdcmParser::WriteEntries(FILE *_fp,FileType type)
{
// TODO (?) tester les echecs en ecriture (apres chaque fwrite)
tag2 != listEntries.end();
++tag2)
{
- WriteEntry(*tag2,_fp,type);
- if (itsTimeToWritePixels)
- break;
+ if ( type == ACR ){
+ if ((*tag2)->GetGroup() < 0x0008)
+ // Ignore pure DICOM V3 groups
+ continue;
+ if ((*tag2)->GetElement() %2)
+ // Ignore the "shadow" groups
+ continue;
+ if ((*tag2)->GetVR() == "SQ" )
+ // For the time being sequences are simply ignored
+ // TODO : find a trick not to *skip* the SeQuences !
+ continue;
+ if ((*tag2)->GetGroup() == 0xfffe )
+ // Ignore the documented delimiter
+ continue;
+ }
+ if (! WriteEntry(*tag2,_fp,type) )
+ return false;
}
+ return true;
}
/**
for (TagHeaderEntryHT::iterator tag2=tagHT.begin();
tag2 != tagHT.end();
++tag2){
- WriteEntry(tag2->second,_fp,type);
- if (itsTimeToWritePixels)
+ if ( type == ACR ){
+ 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
+ // TODO : find a trick to *skip* the SeQuences !
+ // Not only ignore the SQ element
+ // --> will be done with the next organization
+ if ((*tag2->second).GetGroup() == 0xfffe ) continue; // ignore delimiters
+ }
+ if ( ! WriteEntry(tag2->second,_fp,type))
break;
}
}
SkipHeaderEntry(newHeaderEntry);
if ( (ignoreShadow==0) || (newHeaderEntry->GetGroup()%2) == 0) {
AddHeaderEntry(newHeaderEntry);
- }
+ }
}
return true;
}
// 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." )
// When integer(s) are expected, read and convert the following
// n *(two or four bytes)
- // properly i.e. as integers as opposed to strings.
+ // properly i.e. as integers as opposed to strings.
// Elements with Value Multiplicity > 1
// contain a set of integers (not a single one)
-
+
// Any compacter code suggested (?)
if ( IsHeaderEntryAnInteger(Entry) ) {
guint32 NewInt;
NewInt = ReadInt16();
s << NewInt;
}
- }
+ }
}
else if (vr == "UL" || vr == "SL") {
nbInt = length / 4;
#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
}
if( (vr == "UI") ) // Because of correspondance with the VR dic
- Entry->SetValue(NewValue.c_str()); // ??? JPR ???
+ Entry->SetValue(NewValue.c_str());
else
Entry->SetValue(NewValue);
}
std::string vr = Entry->GetVR();
guint16 length16;
- if( (element == NumPixel) && (group == GrPixel) )
- {
- dbg.SetDebug(GDCM_DEBUG);
- dbg.Verbose(2, "gdcmParser::FindLength: ",
- "we reached (GrPixel,NumPixel)");
- }
-
if ( (filetype == ExplicitVR) && (! Entry->IsImplicitVR()) )
{
if ( (vr=="OB") || (vr=="OW") || (vr=="SQ") || (vr=="UN") )
// is in explicit VR and try to fix things if it happens not to be
// the case.
- int lgrLue=fread (&VR, (size_t)2,(size_t)1, fp); // lgrLue not used
+ (void)fread (&VR, (size_t)2,(size_t)1, fp);
VR[2]=0;
if(!CheckHeaderEntryVR(Entry,VR))
{
gdcmDictEntry* NewEntry = NewVirtualDictEntry(
Entry->GetGroup(),Entry->GetElement(),
"UL","FIXME","Group Length");
- Entry->SetDictEntry(NewEntry);
+ Entry->SetDictEntry(NewEntry);
}
return(false);
}
void gdcmParser::FixHeaderEntryFoundLength(gdcmHeaderEntry *Entry, guint32 FoundLength)
{
Entry->SetReadLength(FoundLength); // will be updated only if a bug is found
-
+
if ( FoundLength == 0xffffffff) {
FoundLength = 0;
}
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 :-(
-
+ // fffe|e000 is just a marker, its length *should be* zero
else if(Entry->GetGroup() == 0xfffe)
{
- // cout << "ReadLength " <<Entry->GetReadLength() << " UsableLength " << FoundLength << endl;
- // Entry->Print();
- // 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);
}
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 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 )
{
// 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 !-
+ // 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*
+ (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 !? // group 0000
-
+ // instead of just checking for UL, OB and UI !? group 0000
{
filetype = ExplicitVR;
dbg.Verbose(1, "gdcmParser::CheckSwap:",
filetype = ACR;
return true;
default :
-
+
// 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,
case 0x0800 :
sw = 4321;
filetype = ACR;
- return true;
+ return true;
default :
dbg.Verbose(0, "gdcmParser::CheckSwap:",
"ACR/NEMA unfound swap info (Really hopeless !)");
filetype = Unknown;
return false;
}
-
- // Then the only info we have is the net2host one.
- //if (! net2host )
+
+ // Then the only info we have is the net2host one.
+ //if (! net2host )
// sw = 0;
//else
// sw = 4321;
- //return;
+ //return;
}
}
// 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;
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff