# 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_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
+ //
//-----------------------------------------------------------------------------
// 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;
+// Refer to gdcmParser::SetMaxSizePrintEntry()
+// TODO : Right now, better see "define, in gdcmHederEntry.cxx
+const unsigned int gdcmParser::MAX_SIZE_PRINT_ELEMENT_VALUE = 64;
+
//-----------------------------------------------------------------------------
// Constructor / Destructor
/**
* @param enable_sequences = true to allow the header
* to be parsed *inside* the SeQuences,
* when they have an actual length
- *\TODO may be we need one more bool,
- * to allow skipping the private elements while parsing the header
- * in order to save space
+ * @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 enable_sequences,
+ bool ignore_shadow) {
enableSequences=enable_sequences;
+ ignoreShadow =ignore_shadow;
SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
filename = InFilename;
if ( !OpenFile(exception_on_error))
return;
- Parse();
- LoadHeaderEntries();
+ if (ParseHeader()) {
+ LoadHeaderEntries();
+ }
CloseFile();
wasUpdated = 0; // will be set to 1 if user adds an entry
- printLevel = 1; // 'Heavy' header print by default
+ printLevel = 1; // 'Medium' print level by default
}
/**
* \brief
* @param exception_on_error
*/
-gdcmParser::gdcmParser(bool exception_on_error)
-{
+gdcmParser::gdcmParser(bool exception_on_error) {
enableSequences=0;
SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
Initialise();
wasUpdated = 0; // will be set to 1 if user adds an entry
- printLevel = 1; // 'Heavy' header print by default
+ printLevel = 1; // 'Medium' print level by default
}
/**
* \ingroup gdcmParser
* \brief Canonical destructor.
*/
-gdcmParser::~gdcmParser (void)
-{
+gdcmParser::~gdcmParser (void) {
RefPubDict = NULL;
RefShaDict = NULL;
}
* both from the H Table and the chained list
* @return
*/
-void gdcmParser::PrintPubEntry(std::ostream & os)
-{
+void gdcmParser::PrintEntry(std::ostream & os) {
std::ostringstream s;
- s << "------------ using listEntries ----------------" << std::endl;
for (ListTag::iterator i = listEntries.begin();
i != listEntries.end();
++i)
* \brief Prints The Dict Entries of THE public Dicom Dictionnry
* @return
*/
-void gdcmParser::PrintPubDict(std::ostream & os)
-{
+void gdcmParser::PrintPubDict(std::ostream & os) {
RefPubDict->Print(os);
}
* \brief Prints The Dict Entries of THE shadow Dicom Dictionnry
* @return
*/
-void gdcmParser::PrintShaDict(std::ostream & os)
-{
+void gdcmParser::PrintShaDict(std::ostream & os) {
RefShaDict->Print(os);
}
* \ingroup gdcmParser
* \brief Get the public dictionary used
*/
-gdcmDict *gdcmParser::GetPubDict(void)
-{
+gdcmDict *gdcmParser::GetPubDict(void) {
return(RefPubDict);
}
* \ingroup gdcmParser
* \brief Get the shadow dictionary used
*/
-gdcmDict *gdcmParser::GetShaDict(void)
-{
+gdcmDict *gdcmParser::GetShaDict(void) {
return(RefShaDict);
}
* \brief Set the shadow dictionary used
* \param dict dictionary to use in shadow
*/
-bool gdcmParser::SetShaDict(gdcmDict *dict)
-{
+bool gdcmParser::SetShaDict(gdcmDict *dict){
RefShaDict=dict;
return(!RefShaDict);
}
* \brief Set the shadow dictionary used
* \param dictName name of the dictionary to use in shadow
*/
-bool gdcmParser::SetShaDict(DictKey dictName)
-{
+bool gdcmParser::SetShaDict(DictKey dictName){
RefShaDict=gdcmGlobal::GetDicts()->GetDict(dictName);
return(!RefShaDict);
}
* @return true when gdcmParser is the one of a reasonable Dicom/Acr file,
* false otherwise.
*/
-bool gdcmParser::IsReadable(void)
-{
- std::string res = GetEntryByNumber(0x0028, 0x0005);
- if ( res != GDCM_UNFOUND && atoi(res.c_str()) > 4 )
- {
- return false; // Image Dimensions
+bool gdcmParser::IsReadable(void) {
+ if(filetype==Unknown) {
+ return(false);
+ }
+ if(listEntries.size()<=0) {
+ return(false);
}
- if ( !GetHeaderEntryByNumber(0x0028, 0x0100) )
- return false; // "Bits Allocated"
- if ( !GetHeaderEntryByNumber(0x0028, 0x0101) )
- return false; // "Bits Stored"
- if ( !GetHeaderEntryByNumber(0x0028, 0x0102) )
- return false; // "High Bit"
- if ( !GetHeaderEntryByNumber(0x0028, 0x0103) )
- return false; // "Pixel Representation"
- return true;
+ return(true);
}
/**
*
* @return True when ImplicitVRLittleEndian found. False in all other cases.
*/
-bool gdcmParser::IsImplicitVRLittleEndianTransferSyntax(void)
-{
+bool gdcmParser::IsImplicitVRLittleEndianTransferSyntax(void) {
gdcmHeaderEntry *Element = GetHeaderEntryByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadHeaderEntrySafe(Element);
std::string Transfer = Element->GetValue();
- if ( Transfer == "1.2.840.10008.1.2" )
+ if ( Transfer == UI1_2_840_10008_1_2 )
return true;
return false;
}
*
* @return True when ExplicitVRLittleEndian found. False in all other cases.
*/
-bool gdcmParser::IsExplicitVRLittleEndianTransferSyntax(void)
-{
+bool gdcmParser::IsExplicitVRLittleEndianTransferSyntax(void) {
gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadHeaderEntrySafe(Element);
std::string Transfer = Element->GetValue();
- if ( Transfer == "1.2.840.10008.1.2.1" )
+ if ( Transfer == UI1_2_840_10008_1_2_1 )
return true;
return false;
}
*
* @return True when DeflatedExplicitVRLittleEndian found. False in all other cases.
*/
-bool gdcmParser::IsDeflatedExplicitVRLittleEndianTransferSyntax(void)
-{
+bool gdcmParser::IsDeflatedExplicitVRLittleEndianTransferSyntax(void) {
gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadHeaderEntrySafe(Element);
std::string Transfer = Element->GetValue();
- if ( Transfer == "1.2.840.10008.1.2.1.99" )
+ if ( Transfer == UI1_2_840_10008_1_2_1_99 )
return true;
return false;
}
*
* @return True when big endian found. False in all other cases.
*/
-bool gdcmParser::IsExplicitVRBigEndianTransferSyntax(void)
-{
+bool gdcmParser::IsExplicitVRBigEndianTransferSyntax(void) {
gdcmHeaderEntry* Element = GetHeaderEntryByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadHeaderEntrySafe(Element);
std::string Transfer = Element->GetValue();
- if ( Transfer == "1.2.840.10008.1.2.2" ) //1.2.2 ??? A verifier !
+ if ( Transfer == UI1_2_840_10008_1_2_2 ) //1.2.2 ??? A verifier !
return true;
return false;
}
dbg.Verbose(0, "gdcmParser::gdcmParser not DICOM/ACR", filename.c_str());
}
else {
- std::cerr<<filename.c_str()<<std::endl;
dbg.Verbose(0, "gdcmParser::gdcmParser cannot open file", filename.c_str());
}
return(NULL);
* \brief closes the file
* @return TRUE if the close was successfull
*/
-bool gdcmParser::CloseFile(void)
-{
+bool gdcmParser::CloseFile(void) {
int closed = fclose(fp);
fp = (FILE *)0;
if (! closed)
return true;
}
-/**
- * \ingroup gdcmParser
- * \brief Parses the header of the file but WITHOUT loading element values.
- */
-void gdcmParser::Parse(bool exception_on_error) throw(gdcmFormatError)
-{
- gdcmHeaderEntry *newHeaderEntry = (gdcmHeaderEntry *)0;
-
- rewind(fp);
- CheckSwap();
- while ( (newHeaderEntry = ReadNextHeaderEntry()) )
- {
- SkipHeaderEntry(newHeaderEntry);
- AddHeaderEntry(newHeaderEntry);
- }
-}
-
/**
* \ingroup gdcmParser
* \brief
* (ACR-NEMA, ExplicitVR, ImplicitVR)
* @return always "True" ?!
*/
-bool gdcmParser::Write(FILE *fp, FileType type)
-{
+bool gdcmParser::Write(FILE *fp, FileType type) {
// ==============
-// TODO The stuff has been rewritten using the chained list instead
+// TODO The stuff was rewritten using the chained list instead
// of the H table
// so we could remove the GroupHT from the gdcmParser
// To be checked
if (type == ImplicitVR)
{
- std::string implicitVRTransfertSyntax = "1.2.840.10008.1.2";
+ 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":
if (type == ExplicitVR)
{
- std::string explicitVRTransfertSyntax = "1.2.840.10008.1.2.1";
+ 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":
SetEntryLengthByNumber(20, 0x0002, 0x0010);
}
+/* TODO : rewrite later
if ( (type == ImplicitVR) || (type == ExplicitVR) )
UpdateGroupLength(false,type);
if ( type == ACR)
UpdateGroupLength(true,ACR);
+*/
WriteEntries(type, fp);
return(true);
* \return boolean
*/
bool gdcmParser::ReplaceOrCreateByNumber(std::string Value,
- guint16 Group, guint16 Elem )
-{
+ guint16 Group,
+ guint16 Elem ){
if (CheckIfEntryExistByNumber(Group, Elem) == 0) {
gdcmHeaderEntry *a =NewHeaderEntryByNumber(Group, Elem);
if (a == NULL)
* \return boolean
*
*/
-bool gdcmParser::ReplaceOrCreateByNumber(char* Value, guint16 Group, guint16 Elem )
-{
+bool gdcmParser::ReplaceOrCreateByNumber(char* Value, guint16 Group, guint16 Elem ) {
gdcmHeaderEntry* nvHeaderEntry=NewHeaderEntryByNumber(Group, Elem);
if(!nvHeaderEntry)
* @param element Element number of the searched Dicom Element
* @return number of occurences
*/
-int gdcmParser::CheckIfEntryExistByNumber(guint16 group, guint16 element )
-{
+int gdcmParser::CheckIfEntryExistByNumber(guint16 group, guint16 element ) {
std::string key = gdcmDictEntry::TranslateToKey(group, element );
return (tagHT.count(key));
}
* @return Corresponding element value when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-std::string gdcmParser::GetEntryByName(std::string tagName)
-{
- gdcmDictEntry *dictEntry = RefPubDict->GetTagByName(tagName);
+std::string gdcmParser::GetEntryByName(std::string tagName) {
+ gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName);
if( dictEntry == NULL)
return GDCM_UNFOUND;
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-std::string gdcmParser::GetEntryVRByName(std::string tagName)
-{
- gdcmDictEntry *dictEntry = RefPubDict->GetTagByName(tagName);
+std::string gdcmParser::GetEntryVRByName(std::string tagName) {
+ gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName);
if( dictEntry == NULL)
return GDCM_UNFOUND;
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-std::string gdcmParser::GetEntryByNumber(guint16 group, guint16 element)
-{
+std::string gdcmParser::GetEntryByNumber(guint16 group, guint16 element){
TagKey key = gdcmDictEntry::TranslateToKey(group, element);
if ( ! tagHT.count(key))
return GDCM_UNFOUND;
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-std::string gdcmParser::GetEntryVRByNumber(guint16 group, guint16 element)
-{
+std::string gdcmParser::GetEntryVRByNumber(guint16 group, guint16 element) {
gdcmHeaderEntry* elem = GetHeaderEntryByNumber(group, element);
if ( !elem )
return GDCM_UNFOUND;
* @param tagName name of the searched Dicom Element.
* @return true when found
*/
-bool gdcmParser::SetEntryByName(std::string content,std::string tagName)
-{
- gdcmDictEntry *dictEntry = RefPubDict->GetTagByName(tagName);
+bool gdcmParser::SetEntryByName(std::string content,std::string tagName) {
+ gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName);
if( dictEntry == NULL)
return false;
content = content + '\0';
}
- //tagHT[key]->SetValue(content);
gdcmHeaderEntry * a;
IterHT p;
TagHeaderEntryHT::iterator p2;
a-> SetValue(content);
- //std::string vr = tagHT[key]->GetVR();
std::string vr = a->GetVR();
guint32 lgr;
else
lgr = l;
- //tagHT[key]->SetLength(lgr);
a->SetLength(lgr);
return true;
}
* the given value.
* \warning Use with extreme caution.
* @param length new length to substitute with
- * @param group group of the ElVal to modify
- * @param element element of the ElVal to modify
+ * @param group group of the entry to modify
+ * @param element element of the Entry to modify
* @return 1 on success, 0 otherwise.
*/
bool gdcmParser::SetEntryLengthByNumber(guint32 length,
- guint16 group, guint16 element)
+ guint16 group,
+ guint16 element)
{
TagKey key = gdcmDictEntry::TranslateToKey(group, element);
if ( ! tagHT.count(key))
return false;
if (length%2) length++; // length must be even
- //tagHT[key]->SetLength(length);
( ((tagHT.equal_range(key)).first)->second )->SetLength(length);
return true ;
* \ingroup gdcmParser
* \brief Loads (from disk) the element content
* when a string is not suitable
+ * @param Group
+ * @param Elem
*/
void *gdcmParser::LoadEntryVoidArea(guint16 Group, guint16 Elem)
{
* @param element Element number of the searched Dicom Element
* @return
*/
-bool gdcmParser::SetEntryVoidAreaByNumber(void * area,guint16 group, guint16 element)
+bool gdcmParser::SetEntryVoidAreaByNumber(void * area,
+ guint16 group,
+ guint16 element)
{
TagKey key = gdcmDictEntry::TranslateToKey(group, element);
if ( ! tagHT.count(key))
return false;
- //tagHT[key]->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
+ */
+void gdcmParser::UpdateShaEntries(void) {
+ gdcmDictEntry *entry;
+ std::string vr;
+
+ for(ListTag::iterator it=listEntries.begin();
+ it!=listEntries.end();
+ ++it)
+ {
+ // Odd group => from public dictionary
+ if((*it)->GetGroup()%2==0)
+ continue;
+
+ // Peer group => search the corresponding dict entry
+ if(RefShaDict)
+ entry=RefShaDict->GetDictEntryByNumber((*it)->GetGroup(),(*it)->GetElement());
+ else
+ entry=NULL;
+
+ if((*it)->IsImplicitVR())
+ vr="Implicit";
+ else
+ vr=(*it)->GetVR();
+
+ (*it)->SetValue(GetHeaderEntryUnvalue(*it));
+ if(entry){
+ // Set the new entry and the new value
+ (*it)->SetDictEntry(entry);
+ CheckHeaderEntryVR(*it,vr);
+
+ (*it)->SetValue(GetHeaderEntryValue(*it));
+ }
+ else
+ {
+ // Remove precedent value transformation
+ (*it)->SetDictEntry(NewVirtualDictEntry((*it)->GetGroup(),(*it)->GetElement(),vr));
+ }
+ }
+}
+
/**
* \ingroup gdcmParser
* \brief Searches within the Header Entries for a Dicom Element of
* @return Corresponding Dicom Element when it exists, and NULL
* otherwise.
*/
- gdcmHeaderEntry *gdcmParser::GetHeaderEntryByName(std::string tagName)
- {
- gdcmDictEntry *dictEntry = RefPubDict->GetTagByName(tagName);
+ gdcmHeaderEntry *gdcmParser::GetHeaderEntryByName(std::string tagName) {
+ gdcmDictEntry *dictEntry = RefPubDict->GetDictEntryByName(tagName);
if( dictEntry == NULL)
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.
+ * @return a range (i.e.pair<,>) containing all elements whose key is group|element)
+ */
+
+IterHT gdcmParser::GetHeaderEntrySameNumber(guint16 group, guint16 element){
+ TagKey key = gdcmDictEntry::TranslateToKey(group, element);
+ return (tagHT.equal_range(key));
+}
+
/**
* \ingroup gdcmParser
* \brief Loads the element while preserving the current
* @param entry Header Entry whose value shall be loaded.
* @return
*/
-void gdcmParser::LoadHeaderEntrySafe(gdcmHeaderEntry * entry)
-{
+void gdcmParser::LoadHeaderEntrySafe(gdcmHeaderEntry * entry) {
long PositionOnEntry = ftell(fp);
LoadHeaderEntry(entry);
fseek(fp, PositionOnEntry, SEEK_SET);
* @param SkipSequence TRUE if we don't want to write Sequences (ACR-NEMA Files)
* @param type Type of the File (ExplicitVR,ImplicitVR, ACR, ...)
*/
-void gdcmParser::UpdateGroupLength(bool SkipSequence, FileType type)
-{
+void gdcmParser::UpdateGroupLength(bool SkipSequence, FileType type) {
guint16 gr, el;
std::string vr;
* \ 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!)
* @param type type of the File to be written
* (ACR-NEMA, ExplicitVR, ImplicitVR)
* @param _fp already open file pointer
std::string vr;
guint32 val_uint32;
guint16 val_uint16;
-
+ guint16 valZero =0;
std::vector<std::string> tokens;
+ // TODO : function CheckHeaderCoherence to be written
+
// 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)
-
+ int compte =0;
+
for (ListTag::iterator tag2=listEntries.begin();
tag2 != listEntries.end();
++tag2)
{
gr = (*tag2)->GetGroup();
el = (*tag2)->GetElement();
- lgr = (*tag2)->GetLength();
+ lgr = (*tag2)->GetReadLength();
val = (*tag2)->GetValue().c_str();
vr = (*tag2)->GetVR();
-
if ( type == ACR )
{
if (gr < 0x0008) continue; // ignore pure DICOM V3 groups
fwrite ( &gr,(size_t)2 ,(size_t)1 ,_fp); //group
fwrite ( &el,(size_t)2 ,(size_t)1 ,_fp); //element
-
- if ( (type == ExplicitVR) && (gr <= 0x0002) )
+
+ // === Deal with the length
+ // --------------------
+
+ // if ( (type == ExplicitVR) && (gr <= 0x0002) ) // ?!? < 2
+ if ( (type == ExplicitVR) || (type == DICOMDIR) )
{
// EXPLICIT VR
guint16 z=0, shortLgr;
- 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
- {
+ if (vr == "Unknown") { // Unknown was 'written'
shortLgr=lgr;
fwrite ( &shortLgr,(size_t)2 ,(size_t)1 ,_fp);
- }
+ fwrite ( &z, (size_t)2 ,(size_t)1 ,_fp);
+ } else {
+ if (gr != 0xfffe) { // NO value for 'delimiters'
+ if (vr == "Unknown") // Unknown was 'written'
+ 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") || gr == 0xfffe) // JPR
+ {
+ if (gr != 0xfffe)
+ fwrite ( &z, (size_t)2 ,(size_t)1 ,_fp);
+ fwrite ( &lgr,(size_t)4 ,(size_t)1 ,_fp);
+ }
+ else
+ {
+ shortLgr=lgr;
+ fwrite ( &shortLgr,(size_t)2 ,(size_t)1 ,_fp);
+ }
+ }
}
- else // IMPLICIT VR
+ else // IMPLICIT VR
{
fwrite ( &lgr,(size_t)4 ,(size_t)1 ,_fp);
}
-
+
+ // === Deal with the value
+ // -------------------
+ if (vr == "SQ") continue; // no "value" to write for the SEQuences
+ if (gr == 0xfffe)continue;
+
if (vr == "US" || vr == "SS")
{
tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
}
tokens.clear();
continue;
- }
+ }
+
// Pixels are never loaded in the element !
- if ((gr == 0x7fe0) && (el == 0x0010) )
- break;
-
+ // 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
+ break;
+ }
fwrite ( val,(size_t)lgr ,(size_t)1 ,_fp); // Elem value
}
}
* processor order.
* @return The properly swaped 32 bits integer.
*/
-guint32 gdcmParser::SwapLong(guint32 a)
-{
- switch (sw)
- {
+guint32 gdcmParser::SwapLong(guint32 a) {
+ switch (sw) {
case 0 :
break;
case 4321 :
return(a);
}
+/**
+ * \ingroup gdcmParser
+ * \brief Unswaps back the bytes of 4-byte long integer accordingly to
+ * processor order.
+ * @return The properly unswaped 32 bits integer.
+ */
+guint32 gdcmParser::UnswapLong(guint32 a) {
+ return (SwapLong(a));
+}
+
/**
* \ingroup gdcmParser
* \brief Swaps the bytes so they agree with the processor order
* @return The properly swaped 16 bits integer.
*/
-guint16 gdcmParser::SwapShort(guint16 a)
-{
+guint16 gdcmParser::SwapShort(guint16 a) {
if ( (sw==4321) || (sw==2143) )
a =(((a<<8) & 0x0ff00) | ((a>>8)&0x00ff));
return (a);
}
+/**
+ * \ingroup gdcmParser
+ * \brief Unswaps the bytes so they agree with the processor order
+ * @return The properly unswaped 16 bits integer.
+ */
+guint16 gdcmParser::UnswapShort(guint16 a) {
+ return (SwapShort(a));
+}
+
//-----------------------------------------------------------------------------
// Private
+/**
+ * \ingroup gdcmParser
+ * \brief Parses the header of the file but WITHOUT loading element values.
+ * @return false if file is not ACR-NEMA / DICOM
+ */
+bool gdcmParser::ParseHeader(bool exception_on_error) throw(gdcmFormatError) {
+
+ rewind(fp);
+ if (!CheckSwap())
+ return false;
+
+ gdcmHeaderEntry *newHeaderEntry = (gdcmHeaderEntry *)0;
+ while ( (newHeaderEntry = ReadNextHeaderEntry()) ) {
+ SkipHeaderEntry(newHeaderEntry);
+ if ( (ignoreShadow==0) || (newHeaderEntry->GetGroup()%2) == 0) {
+ AddHeaderEntry(newHeaderEntry);
+ }
+ }
+ return true;
+}
+
/**
* \ingroup gdcmParser
* \brief Loads the element values of all the Header Entries pointed in the
* public Chained List.
*/
-void gdcmParser::LoadHeaderEntries(void)
-{
+void gdcmParser::LoadHeaderEntries(void) {
rewind(fp);
- for (ListTag::iterator i = GetPubListEntry().begin();
- i != GetPubListEntry().end();
+ for (ListTag::iterator i = GetListEntry().begin();
+ i != GetListEntry().end();
++i)
{
- LoadHeaderEntry(*i);
- }
+ LoadHeaderEntry(*i);
+ }
rewind(fp);
// Load 'non string' values
std::string PhotometricInterpretation = GetEntryByNumber(0x0028,0x0004);
- if( PhotometricInterpretation == "PALETTE COLOR " )
- {
+ if( PhotometricInterpretation == "PALETTE COLOR " ) {
LoadEntryVoidArea(0x0028,0x1200); // gray LUT
LoadEntryVoidArea(0x0028,0x1201); // R LUT
LoadEntryVoidArea(0x0028,0x1202); // G 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
- }
-
+ }
+
// --------------------------------------------------------------
// Special Patch to allow gdcm to read ACR-LibIDO formated images
//
/**
* \ingroup gdcmParser
- * \brief Loads the element content if it's length is not bigger
- * than the value specified with
- * gdcmParser::SetMaxSizeLoadEntry()
- * @param ElVal Header Entry (Dicom Element) to be dealt with
+ * \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 * ElVal)
-{
+void gdcmParser::LoadHeaderEntry(gdcmHeaderEntry *Entry) {
size_t item_read;
- guint16 group = ElVal->GetGroup();
- std::string vr= ElVal->GetVR();
- guint32 length = ElVal->GetLength();
+ guint16 group = Entry->GetGroup();
+ std::string vr= Entry->GetVR();
+ guint32 length = Entry->GetLength();
bool SkipLoad = false;
- fseek(fp, (long)ElVal->GetOffset(), SEEK_SET);
+ 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( group == 0xfffe )
SkipLoad = true;
- if ( SkipLoad )
- {
- ElVal->SetLength(0);
- ElVal->SetValue("gdcm::Skipped");
+ if ( SkipLoad ) {
+ Entry->SetLength(0);
+ Entry->SetValue("gdcm::Skipped");
return;
}
// When the length is zero things are easy:
- if ( length == 0 )
- {
- ElVal->SetValue("");
+ if ( length == 0 ) {
+ Entry->SetValue("");
return;
}
// The elements whose length is bigger than the specified upper bound
// are not loaded. Instead we leave a short notice of the offset of
// the element content and it's length.
- if (length > MaxSizeLoadEntry)
- {
+ if (length > MaxSizeLoadEntry) {
std::ostringstream s;
s << "gdcm::NotLoaded.";
- s << " Address:" << (long)ElVal->GetOffset();
- s << " Length:" << ElVal->GetLength();
- s << " x(" << std::hex << ElVal->GetLength() << ")";
- ElVal->SetValue(s.str());
+ s << " Address:" << (long)Entry->GetOffset();
+ s << " Length:" << Entry->GetLength();
+ s << " x(" << std::hex << Entry->GetLength() << ")";
+ 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.
+ // 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(ElVal) )
- {
+ if ( IsHeaderEntryAnInteger(Entry) ) {
guint32 NewInt;
std::ostringstream s;
int nbInt;
- if (vr == "US" || vr == "SS")
- {
+ if (vr == "US" || vr == "SS") {
nbInt = length / 2;
NewInt = ReadInt16();
s << NewInt;
- if (nbInt > 1)
- {
- for (int i=1; i < nbInt; i++)
- {
+ if (nbInt > 1){
+ for (int i=1; i < nbInt; i++) {
s << '\\';
NewInt = ReadInt16();
s << NewInt;
}
- }
-
- }
- else if (vr == "UL" || vr == "SL")
- {
+ }
+ }
+ else if (vr == "UL" || vr == "SL") {
nbInt = length / 4;
NewInt = ReadInt32();
s << NewInt;
- if (nbInt > 1)
- {
- for (int i=1; i < nbInt; i++)
- {
+ if (nbInt > 1) {
+ for (int i=1; i < nbInt; i++) {
s << '\\';
NewInt = ReadInt32();
s << NewInt;
}
}
- }
+ }
#ifdef GDCM_NO_ANSI_STRING_STREAM
s << std::ends; // to avoid oddities on Solaris
#endif //GDCM_NO_ANSI_STRING_STREAM
- ElVal->SetValue(s.str());
+
+ Entry->SetValue(s.str());
return;
}
// We need an additional byte for storing \0 that is not on disk
- char* NewValue = (char*)malloc(length+1);
- if( !NewValue)
- {
- dbg.Verbose(1, "LoadElementValue: Failed to allocate NewValue");
- return;
- }
- NewValue[length]= 0;
-
- item_read = fread(NewValue, (size_t)length, (size_t)1, fp);
- if ( item_read != 1 )
- {
- free(NewValue);
+ std::string NewValue(length,0);
+ item_read = fread(&(NewValue[0]), (size_t)length, (size_t)1, fp);
+ if ( item_read != 1 ) {
dbg.Verbose(1, "gdcmParser::LoadElementValue","unread element value");
- ElVal->SetValue("gdcm::UnRead");
+ Entry->SetValue("gdcm::UnRead");
return;
}
- ElVal->SetValue(NewValue);
- free(NewValue);
+
+ if( (vr == "UI") ) // Because of correspondance with the VR dic
+ Entry->SetValue(NewValue.c_str()); // ??? JPR ???
+ else
+ Entry->SetValue(NewValue);
}
/**
* \brief add a new Dicom Element pointer to
* the H Table and to the chained List
* \warning push_bash in listEntries ONLY during ParseHeader
- * \todo something to allow further Elements addition,
+ * \TODO something to allow further Elements addition,
* \ when position to be taken care of
* @param newHeaderEntry
*/
-void gdcmParser::AddHeaderEntry(gdcmHeaderEntry * newHeaderEntry)
-{
+void gdcmParser::AddHeaderEntry(gdcmHeaderEntry *newHeaderEntry) {
tagHT.insert( PairHT( newHeaderEntry->GetKey(),newHeaderEntry) );
listEntries.push_back(newHeaderEntry);
wasUpdated = 1;
/**
* \ingroup gdcmParser
* \brief
- * @param ElVal : Header Entry whose length of the value shall be loaded.
+ * @param Entry Header Entry whose length of the value shall be loaded.
* @return
*/
- void gdcmParser::FindHeaderEntryLength (gdcmHeaderEntry * ElVal)
- {
- guint16 element = ElVal->GetElement();
- guint16 group = ElVal->GetGroup();
- std::string vr = ElVal->GetVR();
+ void gdcmParser::FindHeaderEntryLength (gdcmHeaderEntry *Entry) {
+ guint16 element = Entry->GetElement();
+ guint16 group = Entry->GetGroup();
+ std::string vr = Entry->GetVR();
guint16 length16;
- if( (element == 0x0010) && (group == 0x7fe0) )
+ if( (element == NumPixel) && (group == GrPixel) )
{
dbg.SetDebug(-1);
dbg.Verbose(2, "gdcmParser::FindLength: ",
- "we reached 7fe0 0010");
+ "we reached (GrPixel,NumPixel)");
}
- if ( (filetype == ExplicitVR) && ! ElVal->IsImplicitVr() )
+ if ( (filetype == ExplicitVR) && (! Entry->IsImplicitVR()) )
{
if ( (vr=="OB") || (vr=="OW") || (vr=="SQ") || (vr=="UN") )
{
if ( (vr == "OB") && (length32 == 0xffffffff) )
{
- ElVal->SetLength(FindHeaderEntryLengthOB());
+ Entry->SetLength(FindHeaderEntryLengthOB());
return;
}
- FixHeaderEntryFoundLength(ElVal, length32);
+ FixHeaderEntryFoundLength(Entry, length32);
return;
}
SwitchSwapToBigEndian();
// Restore the unproperly loaded values i.e. the group, the element
// and the dictionary entry depending on them.
- guint16 CorrectGroup = SwapShort(ElVal->GetGroup());
- guint16 CorrectElem = SwapShort(ElVal->GetElement());
+ guint16 CorrectGroup = SwapShort(Entry->GetGroup());
+ guint16 CorrectElem = SwapShort(Entry->GetElement());
gdcmDictEntry * NewTag = GetDictEntryByNumber(CorrectGroup,
CorrectElem);
if (!NewTag)
}
// FIXME this can create a memory leaks on the old entry that be
// left unreferenced.
- ElVal->SetDictEntry(NewTag);
+ Entry->SetDictEntry(NewTag);
}
// Heuristic: well some files are really ill-formed.
// Unknown Sequence Length
}
- FixHeaderEntryFoundLength(ElVal, (guint32)length16);
+ FixHeaderEntryFoundLength(Entry, (guint32)length16);
+ return;
+ }
+ else
+ {
+ // Either implicit VR or a non DICOM conformal (see not 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;
}
-
- // Either implicit VR or a non DICOM conformal (see not 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(ElVal, ReadInt32());
- return;
}
/**
* \ingroup gdcmParser
* \brief Find the Value Representation of the current Dicom Element.
- * @param ElVal
+ * @param Entry
*/
-void gdcmParser::FindHeaderEntryVR( gdcmHeaderEntry *ElVal)
+void gdcmParser::FindHeaderEntryVR( gdcmHeaderEntry *Entry)
{
if (filetype != ExplicitVR)
return;
char VR[3];
- std::string vr;
int lgrLue;
- char msg[100]; // for sprintf. Sorry
long PositionOnEntry = ftell(fp);
// Warning: we believe this is explicit VR (Value Representation) because
// within an explicit VR file. Hence we make sure the present tag
// is in explicit VR and try to fix things if it happens not to be
// the case.
- bool RealExplicit = true;
lgrLue=fread (&VR, (size_t)2,(size_t)1, fp);
VR[2]=0;
- vr = std::string(VR);
-
+ if(!CheckHeaderEntryVR(Entry,VR))
+ {
+ fseek(fp, PositionOnEntry, SEEK_SET);
+ // When this element is known in the dictionary we shall use, e.g. for
+ // the semantics (see the usage of IsAnInteger), the VR proposed by the
+ // dictionary entry. Still we have to flag the element as implicit since
+ // we know now our assumption on expliciteness is not furfilled.
+ // avoid .
+ if ( Entry->IsVRUnknown() )
+ Entry->SetVR("Implicit");
+ Entry->SetImplicitVR();
+ }
+}
+
+/**
+ * \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
+ * @return false if the VR is incorrect of if the VR isn't referenced
+ * otherwise, it returns true
+*/
+bool gdcmParser::CheckHeaderEntryVR(gdcmHeaderEntry *Entry, VRKey vr)
+{
+ char msg[100]; // for sprintf
+ bool RealExplicit = true;
+
// Assume we are reading a falsely explicit VR file i.e. we reached
// a tag where we expect reading a VR but are in fact we read the
// first to bytes of the length. Then we will interogate (through find)
// expected VR read happens to be non-ascii characters we consider
// we hit falsely explicit VR tag.
- if ( (!isalpha(VR[0])) && (!isalpha(VR[1])) )
+ if ( (!isalpha(vr[0])) && (!isalpha(vr[1])) )
RealExplicit = false;
// CLEANME searching the dicom_vr at each occurence is expensive.
if ( RealExplicit && !gdcmGlobal::GetVR()->Count(vr) )
RealExplicit= false;
- if ( RealExplicit )
+ if ( !RealExplicit )
+ {
+ // We thought this was explicit VR, but we end up with an
+ // implicit VR tag. Let's backtrack.
+ sprintf(msg,"Falsely explicit vr file (%04x,%04x)\n",
+ Entry->GetGroup(),Entry->GetElement());
+ dbg.Verbose(1, "gdcmParser::FindVR: ",msg);
+
+ return(false);
+ }
+
+ if ( Entry->IsVRUnknown() )
+ {
+ // When not a dictionary entry, we can safely overwrite the VR.
+ Entry->SetVR(vr);
+ }
+ else if ( Entry->GetVR() != vr )
{
- if ( ElVal->IsVRUnknown() )
- {
- // When not a dictionary entry, we can safely overwrite the VR.
- ElVal->SetVR(vr);
- return;
- }
- if ( ElVal->GetVR() == vr )
- {
- // The VR we just read and the dictionary agree. Nothing to do.
- return;
- }
// The VR present in the file and the dictionary disagree. We assume
// the file writer knew best and use the VR of the file. Since it would
// be unwise to overwrite the VR of a dictionary (since it would
// compromise it's next user), we need to clone the actual DictEntry
// and change the VR for the read one.
- gdcmDictEntry* NewTag = NewVirtualDictEntry(ElVal->GetGroup(),
- ElVal->GetElement(),
- vr,
- "FIXME",
- ElVal->GetName());
- ElVal->SetDictEntry(NewTag);
- return;
+ gdcmDictEntry* NewEntry = NewVirtualDictEntry(
+ Entry->GetGroup(),Entry->GetElement(),
+ vr,"FIXME",Entry->GetName());
+ Entry->SetDictEntry(NewEntry);
}
-
- // We thought this was explicit VR, but we end up with an
- // implicit VR tag. Let's backtrack.
-
- sprintf(msg,"Falsely explicit vr file (%04x,%04x)\n",
- ElVal->GetGroup(),ElVal->GetElement());
- dbg.Verbose(1, "gdcmParser::FindVR: ",msg);
-
- fseek(fp, PositionOnEntry, SEEK_SET);
- // When this element is known in the dictionary we shall use, e.g. for
- // the semantics (see the usage of IsAnInteger), the VR proposed by the
- // dictionary entry. Still we have to flag the element as implicit since
- // we know now our assumption on expliciteness is not furfilled.
- // avoid .
- if ( ElVal->IsVRUnknown() )
- ElVal->SetVR("Implicit");
- ElVal->SetImplicitVr();
+ return(true);
}
/**
* \ingroup gdcmParser
- * \brief Skip a given Header Entry
+ * \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 !
- * @param entry
- * @return
+ * @param Entry
+ * @return Transformed entry value
*/
-void gdcmParser::SkipHeaderEntry(gdcmHeaderEntry * entry)
+std::string gdcmParser::GetHeaderEntryValue(gdcmHeaderEntry *Entry)
+{
+ if ( (IsHeaderEntryAnInteger(Entry)) && (Entry->IsImplicitVR()) )
+ {
+ std::string val=Entry->GetValue();
+ std::string vr=Entry->GetVR();
+ guint32 length = Entry->GetLength();
+ std::ostringstream s;
+ int nbInt;
+
+ if (vr == "US" || vr == "SS")
+ {
+ guint16 NewInt16;
+
+ nbInt = length / 2;
+ for (int i=0; i < nbInt; i++)
+ {
+ if(i!=0)
+ s << '\\';
+ NewInt16 = (val[2*i+0]&0xFF)+((val[2*i+1]&0xFF)<<8);
+ NewInt16 = SwapShort(NewInt16);
+ s << NewInt16;
+ }
+ }
+
+ else if (vr == "UL" || vr == "SL")
+ {
+ guint32 NewInt32;
+
+ nbInt = length / 4;
+ for (int i=0; i < nbInt; i++)
+ {
+ if(i!=0)
+ s << '\\';
+ NewInt32= (val[4*i+0]&0xFF)+((val[4*i+1]&0xFF)<<8)+
+ ((val[4*i+2]&0xFF)<<16)+((val[4*i+3]&0xFF)<<24);
+ NewInt32=SwapLong(NewInt32);
+ s << NewInt32;
+ }
+ }
+
+#ifdef GDCM_NO_ANSI_STRING_STREAM
+ s << std::ends; // to avoid oddities on Solaris
+#endif //GDCM_NO_ANSI_STRING_STREAM
+ return(s.str());
+ }
+
+ return(Entry->GetValue());
+}
+
+/**
+ * \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
+ * \warning NOT end user intended method !
+ * @param Entry
+ * @return Reverse transformed entry value
+ */
+std::string gdcmParser::GetHeaderEntryUnvalue(gdcmHeaderEntry *Entry)
+{
+ if ( (IsHeaderEntryAnInteger(Entry)) && (Entry->IsImplicitVR()) )
+ {
+ std::string vr=Entry->GetVR();
+ std::ostringstream s;
+ std::vector<std::string> tokens;
+
+ if (vr == "US" || vr == "SS")
+ {
+ guint16 NewInt16;
+
+ tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
+ Tokenize (Entry->GetValue(), tokens, "\\");
+ for (unsigned int i=0; i<tokens.size();i++)
+ {
+ NewInt16 = atoi(tokens[i].c_str());
+ s<<(NewInt16&0xFF)<<((NewInt16>>8)&0xFF);
+ }
+ tokens.clear();
+ }
+ if (vr == "UL" || vr == "SL")
+ {
+ guint32 NewInt32;
+
+ tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
+ Tokenize (Entry->GetValue(), tokens, "\\");
+ for (unsigned int i=0; i<tokens.size();i++)
+ {
+ NewInt32 = atoi(tokens[i].c_str());
+ s<<(char)(NewInt32&0xFF)<<(char)((NewInt32>>8)&0xFF)
+ <<(char)((NewInt32>>16)&0xFF)<<(char)((NewInt32>>24)&0xFF);
+ }
+ tokens.clear();
+ }
+
+#ifdef GDCM_NO_ANSI_STRING_STREAM
+ s << std::ends; // to avoid oddities on Solaris
+#endif //GDCM_NO_ANSI_STRING_STREAM
+ return(s.str());
+ }
+
+ return(Entry->GetValue());
+}
+
+/**
+ * \ingroup gdcmParser
+ * \brief Skip a given Header Entry
+ * \warning NOT end user intended method !
+ * @param entry
+ */
+void gdcmParser::SkipHeaderEntry(gdcmHeaderEntry *entry)
{
SkipBytes(entry->GetLength());
}
* the parser went Jabberwocky) one can hope improving things by
* applying this heuristic.
*/
-void gdcmParser::FixHeaderEntryFoundLength(gdcmHeaderEntry * ElVal, guint32 FoundLength)
+void gdcmParser::FixHeaderEntryFoundLength(gdcmHeaderEntry *Entry, guint32 FoundLength)
{
- ElVal->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)
- {
+ if ( FoundLength == 0xffffffff) {
FoundLength = 0;
}
+
+ guint16 gr =Entry->GetGroup();
+ guint16 el =Entry->GetElement();
+
+ if (FoundLength%2) {
+ std::cout << "Warning : Tag with uneven length " << FoundLength
+ << "in x(" << std::hex << gr << "," << el <<")" << std::endl;
+ }
// Sorry for the patch!
// XMedCom did the trick to read some nasty GE images ...
- else if (FoundLength == 13)
- {
+ 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 ( (ElVal->GetGroup() != 0x0008) ||
- ( (ElVal->GetElement() != 0x0070) && (ElVal->GetElement() != 0x0080) ) ) {
+ if ( (Entry->GetGroup() != 0x0008) ||
+ ( (Entry->GetElement() != 0x0070) && (Entry->GetElement() != 0x0080) ) ){
// end of remove area
FoundLength =10;
- ElVal->SetReadLength(10); // a bug is to be fixed
+ 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 ( (ElVal->GetGroup() == 0x0009) &&
- ( (ElVal->GetElement() == 0x1113) || (ElVal->GetElement() == 0x1114) ) )
- {
+ else if ( (Entry->GetGroup() == 0x0009) &&
+ ( (Entry->GetElement() == 0x1113) || (Entry->GetElement() == 0x1114) ) ){
FoundLength =4;
- ElVal->SetReadLength(4); // a bug is to be fixed
+ 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 ( ElVal->GetVR() == "SQ")
+ else if ( Entry->GetVR() == "SQ")
{
if (enableSequences) // only if the user does want to !
- FoundLength =0;
+ FoundLength =0; // ReadLength is unchanged
}
// a SeQuence Element is beginning
// if we set the length to zero IsHeaderEntryAnInteger() breaks...
// if we don't, we lost 28800 characters from the Header :-(
- else if(ElVal->GetGroup() == 0xfffe)
+ else if(Entry->GetGroup() == 0xfffe)
{
// sometimes, length seems to be wrong
FoundLength =0; // some more clever checking to be done !
// causes troubles :-(
}
- ElVal->SetUsableLength(FoundLength);
+ Entry->SetUsableLength(FoundLength);
}
/**
* \ingroup gdcmParser
* \brief Apply some heuristics to predict wether the considered
* element value contains/represents an integer or not.
- * @param ElVal The element value on which to apply the predicate.
+ * @param Entry The element value on which to apply the predicate.
* @return The result of the heuristical predicate.
*/
-bool gdcmParser::IsHeaderEntryAnInteger(gdcmHeaderEntry * ElVal)
-{
- guint16 element = ElVal->GetElement();
- guint16 group = ElVal->GetGroup();
- std::string vr = ElVal->GetVR();
- guint32 length = ElVal->GetLength();
-
+bool gdcmParser::IsHeaderEntryAnInteger(gdcmHeaderEntry *Entry) {
+ guint16 element = Entry->GetElement();
+ guint16 group = Entry->GetGroup();
+ std::string vr = Entry->GetVR();
+ guint32 length = Entry->GetLength();
// When we have some semantics on the element we just read, and if we
// a priori know we are dealing with an integer, then we shall be
// able to swap it's element value properly.
else
{
std::ostringstream s;
- s << "Erroneous Group Length element length on :" \
- << std::hex << group << " , " << element;
- dbg.Error("gdcmParser::IsAnInteger",
- s.str().c_str());
+ 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());
}
}
if ( (vr == "UL") || (vr == "US") || (vr == "SL") || (vr == "SS") )
*
* @return
*/
- guint32 gdcmParser::FindHeaderEntryLengthOB(void)
- {
+ guint32 gdcmParser::FindHeaderEntryLengthOB(void) {
// See PS 3.5-2001, section A.4 p. 49 on encapsulation of encoded pixel data.
guint16 g;
guint16 n;
* \brief Reads a supposed to be 16 Bits integer
* \ (swaps it depending on processor endianity)
*
- * @return integer acts as a boolean
+ * @return read value
*/
-guint16 gdcmParser::ReadInt16(void)
-{
+guint16 gdcmParser::ReadInt16(void) {
guint16 g;
size_t item_read;
item_read = fread (&g, (size_t)2,(size_t)1, fp);
- if ( item_read != 1 )
- {
+ if ( item_read != 1 ) {
if(ferror(fp))
dbg.Verbose(0, "gdcmParser::ReadInt16", " File Error");
errno = 1;
return 0;
}
errno = 0;
- g = SwapShort(g);
+ g = SwapShort(g);
return g;
}
* \brief Reads a supposed to be 32 Bits integer
* \ (swaps it depending on processor endianity)
*
- * @return
+ * @return read value
*/
-guint32 gdcmParser::ReadInt32(void)
-{
+guint32 gdcmParser::ReadInt32(void) {
guint32 g;
size_t item_read;
item_read = fread (&g, (size_t)4,(size_t)1, fp);
- if ( item_read != 1 )
- {
+ if ( item_read != 1 ) {
if(ferror(fp))
dbg.Verbose(0, "gdcmParser::ReadInt32", " File Error");
errno = 1;
*
* @return
*/
-void gdcmParser::SkipBytes(guint32 NBytes)
-{
+void gdcmParser::SkipBytes(guint32 NBytes) {
//FIXME don't dump the returned value
(void)fseek(fp, (long)NBytes, SEEK_CUR);
}
* \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()
-{
- // 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
- //
+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];
net2host = true;
else
net2host = false;
- //cout << net2host << endl;
// The easiest case is the one of a DICOM header, since it possesses a
// file preamble where it suffice to look for the string "DICM".
lgrLue = fread(deb, 1, HEADER_LENGTH_TO_READ, fp);
entCur = deb + 128;
- if(memcmp(entCur, "DICM", (size_t)4) == 0)
- {
+ if(memcmp(entCur, "DICM", (size_t)4) == 0) {
dbg.Verbose(1, "gdcmParser::CheckSwap:", "looks like DICOM Version3");
+
// Next, determine the value representation (VR). Let's skip to the
// first element (0002, 0000) and check there if we find "UL"
// - or "OB" if the 1st one is (0002,0001) -,
// 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) ||
+
+ // 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 !-
+
+ // The following test is *absolutely useless*, since everything *goes right*
+ // with a *100 % wrong* assumption !!!
+
+ if( (memcmp(entCur, "UL", (size_t)2) == 0) ||
(memcmp(entCur, "OB", (size_t)2) == 0) ||
- (memcmp(entCur, "UI", (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*
+ // group 0000
{
filetype = ExplicitVR;
dbg.Verbose(1, "gdcmParser::CheckSwap:",
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));
-
- switch (s)
- {
+ s32 = *((guint32 *)(entCur));
+
+ switch (s32) {
case 0x00040000 :
sw = 3412;
filetype = ACR;
- return;
+ return true;
case 0x04000000 :
sw = 4321;
filetype = ACR;
- return;
+ return true;
case 0x00000400 :
sw = 2143;
filetype = ACR;
- return;
+ return true;
case 0x00000004 :
sw = 0;
filetype = ACR;
- return;
+ 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,
+ // 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 = ACR;
+ return true;
+ case 0x0200 :
+ case 0x0400 :
+ case 0x0800 :
+ sw = 4321;
+ filetype = ACR;
+ return true;
default :
dbg.Verbose(0, "gdcmParser::CheckSwap:",
- "ACR/NEMA unfound swap info (time to raise bets)");
+ "ACR/NEMA unfound swap info (Really hopeless !)");
+ filetype = Unknown;
+ return false;
+ }
+
+ // Then the only info we have is the net2host one.
+ //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 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;
}
/**
* \ingroup gdcmParser
* \brief
* @param NewSize
- * @return
*/
void gdcmParser::SetMaxSizeLoadEntry(long NewSize)
{
MaxSizeLoadEntry = NewSize;
}
+
+/**
+ * \ingroup gdcmParser
+ * \brief
+ * \warning TODO : not yet usable
+ * (see MAX_SIZE_PRINT_ELEMENT_VALUE
+ * in gdcmHeaderEntry gdcmLoadEntry)
+ *
+ * @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
}
if (RefPubDict)
{
- found = RefPubDict->GetTagByName(Name);
+ found = RefPubDict->GetDictEntryByName(Name);
if (found)
return found;
}
if (RefShaDict)
{
- found = RefShaDict->GetTagByName(Name);
+ found = RefShaDict->GetDictEntryByName(Name);
if (found)
return found;
}
}
if (RefPubDict)
{
- found = RefPubDict->GetTagByNumber(group, element);
+ found = RefPubDict->GetDictEntryByNumber(group, element);
if (found)
return found;
}
if (RefShaDict)
{
- found = RefShaDict->GetTagByNumber(group, element);
+ found = RefShaDict->GetDictEntryByNumber(group, element);
if (found)
return found;
}
* \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)
-{
+gdcmHeaderEntry *gdcmParser::ReadNextHeaderEntry(void) {
guint16 g,n;
- gdcmHeaderEntry *NewElVal;
+ gdcmHeaderEntry *NewEntry;
g = ReadInt16();
n = ReadInt16();
if (errno == 1)
- // We reached the EOF (or an error occured) and header parsing
- // has to be considered as finished.
+ // We reached the EOF (or an error occured) therefore
+ // header parsing has to be considered as finished.
return (gdcmHeaderEntry *)0;
+
+/* Pb : how to propagate the element length (used in SkipHeaderEntry)
+// direct call to SkipBytes ?
- NewElVal = NewHeaderEntryByNumber(g, n);
- FindHeaderEntryVR(NewElVal);
- FindHeaderEntryLength(NewElVal);
+ if (ignoreShadow == 1 && g%2 ==1) //JPR
+ // 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
+*/
+ NewEntry = NewHeaderEntryByNumber(g, n);
+ FindHeaderEntryVR(NewEntry);
+ FindHeaderEntryLength(NewEntry);
- if (errno == 1)
- {
+ if (errno == 1) {
// Call it quits
return NULL;
}
- NewElVal->SetOffset(ftell(fp));
- //if ( (g==0x7fe0) && (n==0x0010) )
- return NewElVal;
+ NewEntry->SetOffset(ftell(fp));
+ return NewEntry;
}
/**
if (!NewTag)
NewTag = NewVirtualDictEntry(0xffff, 0xffff, "LO", "Unknown", Name);
- gdcmHeaderEntry* NewElVal = new gdcmHeaderEntry(NewTag);
- if (!NewElVal)
+ gdcmHeaderEntry* NewEntry = new gdcmHeaderEntry(NewTag);
+ if (!NewEntry)
{
dbg.Verbose(1, "gdcmParser::ObtainHeaderEntryByName",
"failed to allocate gdcmHeaderEntry");
return (gdcmHeaderEntry *)0;
}
- return NewElVal;
+ return 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 VR VR of the underlying DictEntry
- * @param Fourth owner group
- * @param Name english name
+ * @param group group of the underlying DictEntry
+ * @param elem element of the underlying DictEntry
+ * @param vr VR of the underlying DictEntry
+ * @param fourth owner group
+ * @param name english name
*/
gdcmDictEntry *gdcmParser::NewVirtualDictEntry(guint16 group, guint16 element,
std::string vr,
gdcmHeaderEntry *gdcmParser::NewHeaderEntryByNumber(guint16 Group, guint16 Elem)
{
// Find out if the tag we encountered is in the dictionaries:
- gdcmDictEntry *NewTag = GetDictEntryByNumber(Group, Elem);
- if (!NewTag)
- NewTag = NewVirtualDictEntry(Group, Elem);
+ gdcmDictEntry *DictEntry = GetDictEntryByNumber(Group, Elem);
+ if (!DictEntry)
+ DictEntry = NewVirtualDictEntry(Group, Elem);
- gdcmHeaderEntry* NewElVal = new gdcmHeaderEntry(NewTag);
- if (!NewElVal)
+ gdcmHeaderEntry *NewEntry = new gdcmHeaderEntry(DictEntry);
+ if (!NewEntry)
{
dbg.Verbose(1, "gdcmParser::NewHeaderEntryByNumber",
"failed to allocate gdcmHeaderEntry");
return NULL;
}
- return NewElVal;
+ return NewEntry;
}
+// Never used; commented out, waiting for removal.
/**
* \ingroup gdcmParser
* \brief Small utility function that creates a new manually crafted
* @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 *NewElVal = (gdcmHeaderEntry *)0;
- guint32 StuffGroup = 0xffff; // Group to be stuffed with additional info
- guint32 FreeElem = 0;
- gdcmDictEntry *NewEntry = (gdcmDictEntry *)0;
-
- FreeElem = GenerateFreeTagKeyInGroup(StuffGroup);
- if (FreeElem == UINT32_MAX)
- {
- dbg.Verbose(1, "gdcmHeader::NewManualElValToPubDict",
- "Group 0xffff in Public Dict is full");
- return NULL;
- }
-
- NewEntry = NewVirtualDictEntry(StuffGroup, FreeElem,
- VR, "GDCM", NewTagName);
- NewElVal = new gdcmHeaderEntry(NewEntry);
- AddHeaderEntry(NewElVal);
- return NewElVal;
-}
+//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
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff