// gdcmParser.cxx
//-----------------------------------------------------------------------------
+#include "gdcmParser.h"
+#include "gdcmGlobal.h"
+#include "gdcmUtil.h"
+#include "gdcmDebug.h"
+
#include <errno.h>
#include <vector>
#include <netinet/in.h>
#endif
-#ifdef GDCM_NO_ANSI_STRING_STREAM
-# include <strstream>
-# define ostringstream ostrstream
-# else
-# include <sstream>
-#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"
+typedef struct {
+ guint32 totalSQlength;
+ guint32 alreadyParsedlength;
+} pileElem;
+
//-----------------------------------------------------------------------------
// Refer to gdcmParser::CheckSwap()
const unsigned int gdcmParser::HEADER_LENGTH_TO_READ = 256;
/**
* \brief constructor
- * @param inFilename
+ * @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
+ * \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
return;
if (ParseHeader()) {
LoadHeaderEntries();
- }
+ }
CloseFile();
wasUpdated = 0; // will be set to 1 if user adds an entry
* @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 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)->SetPrintLevel(printLevel);
(*i)->Print(os);
}
- os<<s.str();
}
/**
- * \brief Prints The Dict Entries of THE public Dicom Dictionnry
+ * \ingroup gdcmParser
+ * \brief Prints the Header Entries (Dicom Elements)
+ * from the chained list
+ * and skips the elements belonging to a 'no length' SeQuence
+ * @return
+ */
+void gdcmParser::PrintEntryNoSQ(std::ostream & os) {
+ int countSQ = 0;
+ for (ListTag::iterator i = listEntries.begin();
+ i != listEntries.end();
+ ++i)
+ {
+ if ( (*i)->GetVR() == "SQ"){
+ countSQ ++;
+ }
+
+ if ( (*i)->GetGroup() == 0xfffe && (*i)->GetElement() == 0xe0dd){
+ countSQ --;
+ continue;
+ }
+
+ if (countSQ == 0) {
+ (*i)->SetPrintLevel(printLevel);
+ (*i)->Print(os);
+ }
+ }
+}
+
+/**
+ * \ingroup gdcmParser
+ * \brief Prints the Header Entries (Dicom Elements)
+ * from the chained list
+ * and indents the elements belonging to any SeQuence
+ * \warning : will be removed
+ * @return
+ */
+void gdcmParser::PrintEntryNiceSQ(std::ostream & os) {
+ pileElem pile[50]; // Hope embedded sequence depth is no more than 50
+ int top =-1;
+ int countSQ = 0;
+ int currentParsedlength = 0;
+ int totalElementlength;
+ std::ostringstream tab;
+ tab << " ";
+
+ int DEBUG = 0; // Sorry; Dealing with e-film breaker images
+ // will (certainly) cause a lot of troubles ...
+ // I prefer keeping my 'trace' on .
+
+ for (ListTag::iterator i = listEntries.begin();
+ i != listEntries.end();
+ ++i) {
+ if ( (*i)->GetVR() == "SQ" && (*i)->GetReadLength() != 0) { // SQ found
+ countSQ++;
+ top ++;
+ if ( top >= 50) {
+ std::cout << "Kaie ! Kaie! SQ stack overflow" << std::endl;
+ return;
+ }
+ if (DEBUG) std::cout << "\n >>>>> empile niveau " << top
+ << "; Lgr SeQ: " << (*i)->GetReadLength()
+ << "\n" <<std::endl;
+
+ pile[top].totalSQlength = (*i)->GetReadLength();
+ pile[top].alreadyParsedlength = 0;
+ currentParsedlength = 0;
+
+ } else { // non SQ found
+
+ if (countSQ != 0) { // we are 'inside a SeQuence'
+ if ( (*i)->GetGroup()==0xfffe && (*i)->GetElement()==0xe0dd){
+ // we just found 'end of SeQuence'
+
+ if (DEBUG)
+ std::cout << "fffe,e0dd : depile" << std::endl;
+ currentParsedlength += 8; // gr:2 elem:2 vr:2 lgt:2
+ countSQ --;
+ top --;
+ pile[top].alreadyParsedlength += currentParsedlength;
+ } else {
+ // we are on a 'standard' elem
+ // or a Zero-length SeQuence
+
+ totalElementlength = (*i)->GetFullLength();
+ currentParsedlength += totalElementlength;
+ pile[top].alreadyParsedlength += totalElementlength;
+
+ if (pile[top].totalSQlength == 0xffffffff) {
+ if (DEBUG)
+ std::cout << "totalSeQlength == 0xffffffff"
+ << std::endl;
+ } else {
+ if (DEBUG)
+ std::cout << "alrdyPseLgt:"
+ << pile[top].alreadyParsedlength << " totSeQlgt: "
+ << pile[top].totalSQlength << " curPseLgt: "
+ << currentParsedlength
+ << std::endl;
+ while (pile[top].alreadyParsedlength==pile[top].totalSQlength) {
+
+ if (DEBUG)
+ std::cout << " \n<<<<<< On depile niveau " << top
+ << "\n" << std::endl;
+
+ currentParsedlength = pile[top].alreadyParsedlength;
+ countSQ --;
+ top --;
+ if (top >=0) {
+
+ pile[top].alreadyParsedlength += currentParsedlength +12;
+ // 12 : length of 'SQ embedded' SQ element
+ currentParsedlength += 8; // gr:2 elem:2 vr:2 lgt:2
+
+ if (DEBUG)
+ std::cout << pile[top].alreadyParsedlength << " "
+ << pile[top].totalSQlength << " "
+ << currentParsedlength
+ << std::endl;
+ }
+ if (top == -1) {
+ currentParsedlength = 0;
+ break;
+ }
+ }
+ }
+ }
+ } // end : 'inside a SeQuence'
+ }
+
+ if (countSQ != 0) {
+ for (int i=0;i<countSQ;i++)
+ os << tab.str();
+ }
+ (*i)->SetPrintLevel(printLevel);
+ (*i)->Print(os);
+
+ } // end for
+}
+
+
+
+/**
+ * \brief Prints The Dict Entries of THE public Dicom Dictionary
* @return
*/
void gdcmParser::PrintPubDict(std::ostream & os) {
}
/**
- * \brief Prints The Dict Entries of THE shadow Dicom Dictionnary
+ * \brief Prints The Dict Entries of THE shadow Dicom Dictionary
* @return
*/
void gdcmParser::PrintShaDict(std::ostream & os) {
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;
size_t l2 = fread(a, 1, l ,fp);
if(l != l2)
{
- free(a);
+ delete[] a;
return NULL;
}
// 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...
{
// FIXME: g++ -Wall -Wstrict-prototypes reports on following line:
// warning: unsigned int format, different type arg
- sscanf(g->first.c_str(),"%x",&gr_bid);
+ 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
*/
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 (group == 0xfffe)
// Delimiters have no associated value:
return;
-
void *voidArea;
voidArea = tag->GetVoidArea();
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, "\\");
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.clear();
return;
- }
-
+ }
fwrite (tag->GetValue().c_str(), (size_t)lgr ,(size_t)1, _fp); // Elem value
}
* @return false if file is not ACR-NEMA / DICOM
*/
bool gdcmParser::ParseHeader(bool exception_on_error) throw(gdcmFormatError) {
-
+ (void)exception_on_error;
rewind(fp);
if (!CheckSwap())
return false;
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 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();
}
}
}
+ // 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();
*/
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 ( (filetype == ExplicitVR) && (! Entry->IsImplicitVR()) )
{
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;
*/
void gdcmParser::FixHeaderEntryFoundLength(gdcmHeaderEntry *Entry, guint32 FoundLength)
{
- Entry->SetReadLength(FoundLength); // will be updated only if a bug is found
-
+ Entry->SetReadLength(FoundLength); // will be updated only if a bug is found
if ( FoundLength == 0xffffffff) {
FoundLength = 0;
}
}
// Sorry for the patch!
- // XMedCom did the trick to read some nasty GE images ...
+ // 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...
FoundLength =0; // ReadLength is unchanged
}
- // a SeQuence Element is beginning
- // fffe|e000 is just a marker, its length *should be* zero
+ // we found a 'delimiter' element
+ // fffe|xxxx is just a marker, we don't take its length into account
else if(Entry->GetGroup() == 0xfffe)
- {
+ {
// *normally, fffe|0000 doesn't exist !
if( Entry->GetElement() != 0x0000 ) // gdcm-MR-PHILIPS-16-Multi-Seq.dcm
- // causes extra troubles :-(
- FoundLength =0;
- }
+ // causes extra troubles :-(
+ FoundLength =0;
+ }
+
Entry->SetUsableLength(FoundLength);
}
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff