-// gdcmHeader.cxx
+// gdcmParser.cxx
//-----------------------------------------------------------------------------
#include "gdcmParser.h"
#include "gdcmUtil.h"
// 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
- * @param InFilename
- * @param exception_on_error
+ * \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
* with a FALSE value for the 'enable_sequence' param.
* ('public elements' may be embedded in 'shadow Sequences')
*/
-gdcmParser::gdcmParser(const char *InFilename,
+gdcmParser::gdcmParser(const char *inFilename,
bool exception_on_error,
bool enable_sequences,
bool ignore_shadow) {
ignoreShadow =ignore_shadow;
SetMaxSizeLoadEntry(MAX_SIZE_LOAD_ELEMENT_VALUE);
- filename = InFilename;
+ filename = inFilename;
Initialise();
if ( !OpenFile(exception_on_error))
/**
* \ingroup gdcmParser
- * \brief
+ * \brief constructor
* @param exception_on_error
*/
gdcmParser::gdcmParser(bool exception_on_error) {
* \ingroup gdcmParser
* \brief Determines if the Transfer Syntax was already encountered
* and if it corresponds to a ImplicitVRLittleEndian one.
- *
* @return True when ImplicitVRLittleEndian found. False in all other cases.
*/
bool gdcmParser::IsImplicitVRLittleEndianTransferSyntax(void) {
* \ingroup gdcmParser
* \brief Determines if the Transfer Syntax was already encountered
* and if it corresponds to a ExplicitVRLittleEndian one.
- *
* @return True when ExplicitVRLittleEndian found. False in all other cases.
*/
bool gdcmParser::IsExplicitVRLittleEndianTransferSyntax(void) {
* \ingroup gdcmParser
* \brief Determines if the Transfer Syntax was already encountered
* and if it corresponds to a DeflatedExplicitVRLittleEndian one.
- *
* @return True when DeflatedExplicitVRLittleEndian found. False in all other cases.
*/
bool gdcmParser::IsDeflatedExplicitVRLittleEndianTransferSyntax(void) {
* \ingroup gdcmParser
* \brief Determines if the Transfer Syntax was already encountered
* and if it corresponds to a Explicit VR Big Endian one.
- *
* @return True when big endian found. False in all other cases.
*/
bool gdcmParser::IsExplicitVRBigEndianTransferSyntax(void) {
* \ingroup gdcmParser
* \brief returns the File Type
* (ACR, ACR_LIBIDO, ExplicitVR, ImplicitVR, Unknown)
- * @return
+ * @return the FileType code
*/
FileType gdcmParser::GetFileType(void) {
return(filetype);
/**
* \ingroup gdcmParser
- * \brief
+ * \brief writes on disc 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
* (ACR-NEMA, ExplicitVR, ImplicitVR)
* \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
- * @param Elem
- * \return boolean
+ * @param Group group of the Entry
+ * @param Elem element of the Entry
+ * \return pointer to the created Header Entry
+ * NULL if creation failed
*/
-bool gdcmParser::ReplaceOrCreateByNumber(std::string Value,
+gdcmHeaderEntry * gdcmParser::ReplaceOrCreateByNumber(
+ std::string Value,
guint16 Group,
- guint16 Elem ){
- if (CheckIfEntryExistByNumber(Group, Elem) == 0) {
+ guint16 Elem ){
+ gdcmHeaderEntry* a;
+ a = GetHeaderEntryByNumber( Group, Elem);
+ if (a == NULL) {
gdcmHeaderEntry *a =NewHeaderEntryByNumber(Group, Elem);
if (a == NULL)
- return false;
+ return NULL;
AddHeaderEntry(a);
}
- SetEntryByNumber(Value, Group, Elem);
- return(true);
+ //SetEntryByNumber(Value, Group, Elem);
+ a->SetValue(Value);
+ return(a);
}
/**
* \brief Modifies the value of a given Header Entry (Dicom Element)
* if it exists; Creates it with the given value if it doesn't
* @param Value passed as a char*
- * @param Group
- * @param Elem
- * \return boolean
+ * @param Group group of the Entry
+ * @param Elem element of the Entry
+ * \return pointer to the created Header Entry
+ * NULL if creation failed
*
*/
-bool gdcmParser::ReplaceOrCreateByNumber(char* Value, guint16 Group, guint16 Elem ) {
+gdcmHeaderEntry * gdcmParser::ReplaceOrCreateByNumber(
+ char* Value,
+ guint16 Group,
+ guint16 Elem ) {
gdcmHeaderEntry* nvHeaderEntry=NewHeaderEntryByNumber(Group, Elem);
if(!nvHeaderEntry)
- return(false);
+ return(NULL);
AddHeaderEntry(nvHeaderEntry);
std::string v = Value;
SetEntryByNumber(v, Group, Elem);
- return(true);
+ return(nvHeaderEntry);
}
/**
* \ingroup gdcmParser
* \brief Set a new value if the invoked element exists
* Seems to be useless !!!
- * @param Value
- * @param Group
- * @param Elem
+ * @param Value new element value
+ * @param Group group of the Entry
+ * @param Elem element of the Entry
* \return boolean
*/
bool gdcmParser::ReplaceIfExistByNumber(char* Value, guint16 Group, guint16 Elem )
//-----------------------------------------------------------------------------
// Protected
+
/**
* \ingroup gdcmParser
* \brief Checks if a given Dicom Element exists
- * \ within the H table
+ * within the H table
* @param group Group number of the searched Dicom Element
* @param element Element number of the searched Dicom Element
* @return number of occurences
return elem->GetVR();
}
+
/**
* \ingroup gdcmParser
* \brief Searches within Header Entries (Dicom Elements) parsed with
return elem->GetVR();
}
+/**
+ * \ingroup gdcmParser
+ * \brief Searches within Header Entries (Dicom Elements) parsed with
+ * the public and private dictionaries
+ * for the value length of a given tag..
+ * @param group Group of the searched tag.
+ * @param element Element of the searched tag.
+ * @return Corresponding element length; -2 if not found
+ */
+int gdcmParser::GetEntryLengthByNumber(guint16 group, guint16 element) {
+ gdcmHeaderEntry* elem = GetHeaderEntryByNumber(group, element);
+ if ( !elem )
+ return -2;
+ return elem->GetLength();
+}
/**
* \ingroup gdcmParser
* \brief Sets the value (string) of the Header Entry (Dicom Element)
if ( ! tagHT.count(key))
return false;
int l = content.length();
- if(l%2) // Odd length are padded with a space (020H).
+ if(l%2) // Non even length are padded with a space (020H).
{
l++;
content = content + '\0';
* through it's (group, element) and modifies it's length with
* the given value.
* \warning Use with extreme caution.
- * @param length new length to substitute with
- * @param group group of the entry to modify
- * @param element element of the Entry to modify
- * @return 1 on success, 0 otherwise.
+ * @param l new length to substitute with
+ * @param group group of the Entry to modify
+ * @param element element of the Entry to modify
+ * @return true on success, false otherwise.
*/
-
-bool gdcmParser::SetEntryLengthByNumber(guint32 length,
+bool gdcmParser::SetEntryLengthByNumber(guint32 l,
guint16 group,
guint16 element)
{
TagKey key = gdcmDictEntry::TranslateToKey(group, element);
if ( ! tagHT.count(key))
return false;
- if (length%2) length++; // length must be even
- ( ((tagHT.equal_range(key)).first)->second )->SetLength(length);
+ if (l%2) l++; // length must be even
+ ( ((tagHT.equal_range(key)).first)->second )->SetLength(l);
return true ;
}
/**
* \ingroup gdcmParser
* \brief Gets (from Header) the offset of a 'non string' element value
- * \ (LoadElementValues has already be executed)
- * @param Group
- * @param Elem
+ * (LoadElementValues has already be executed)
+ * @param Group group of the Entry
+ * @param Elem element of the Entry
* @return File Offset of the Element Value
*/
size_t gdcmParser::GetEntryOffsetByNumber(guint16 Group, guint16 Elem)
/**
* \ingroup gdcmParser
* \brief Gets (from Header) a 'non string' element value
- * \ (LoadElementValues has already be executed)
- * @param Group
- * @param Elem
+ * (LoadElementValues has already be executed)
+ * @param Group group of the Entry
+ * @param Elem element of the Entry
* @return Pointer to the 'non string' area
*/
void * gdcmParser::GetEntryVoidAreaByNumber(guint16 Group, guint16 Elem)
* \ingroup gdcmParser
* \brief Loads (from disk) the element content
* when a string is not suitable
- * @param Group
- * @param Elem
+ * @param Group group of the Entry
+ * @param Elem element of the Entry
*/
void *gdcmParser::LoadEntryVoidArea(guint16 Group, guint16 Elem)
{
/**
* \ingroup gdcmParser
- * \brief Update the entries with the shadow dictionary. Only odd entries are
- * analized
+ * \brief Update the entries with the shadow dictionary.
+ * Only non even entries are analyzed
*/
void gdcmParser::UpdateShaEntries(void) {
gdcmDictEntry *entry;
/**
* \ingroup gdcmParser
* \brief retrieves a Dicom Element (the first one) using (group, element)
- * \ warning (group, element) IS NOT an identifier inside the Dicom Header
+ * \warning (group, element) IS NOT an identifier inside the Dicom Header
* if you think it's NOT UNIQUE, check the count number
* and use iterators to retrieve ALL the Dicoms Elements within
* a given couple (group, element)
*/
gdcmHeaderEntry* gdcmParser::GetHeaderEntryByNumber(guint16 group, guint16 element)
{
- TagKey key = gdcmDictEntry::TranslateToKey(group, element);
+ TagKey key = gdcmDictEntry::TranslateToKey(group, element);
if ( ! tagHT.count(key))
return NULL;
return tagHT.find(key)->second;
/**
* \ingroup gdcmParser
* \brief writes on disc according to the requested format
- * \ (ACR-NEMA, ExplicitVR, ImplicitVR) the image
- * \ warning does NOT add the missing elements in the header :
- * \ it's up to the user doing it !
- * \ (function CheckHeaderCoherence to be written)
- * \ warning DON'T try, right now, to write a DICOM image
- * \ from an ACR Header (meta elements will be missing!)
+ * (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
*/
-void gdcmParser::WriteEntries(FILE *_fp,FileType type)
+void gdcmParser::WriteEntry(gdcmHeaderEntry *tag, FILE *_fp,FileType type)
{
guint16 gr, el;
guint32 lgr;
+ std::string value;
const char * val;
std::string vr;
guint32 val_uint32;
guint16 valZero =0;
void *voidArea;
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;
-
+ int ff=0xffffffff;
// 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)->GetReadLength();
- val = (*tag2)->GetValue().c_str();
- vr = (*tag2)->GetVR();
- voidArea = (*tag2)->GetVoidArea();
+ itsTimeToWritePixels = false;
+
+ gr = tag->GetGroup();
+ el = tag->GetElement();
+ lgr = tag->GetReadLength();
+ val = tag->GetValue().c_str();
+ vr = tag->GetVR();
+ voidArea = tag->GetVoidArea();
+
+ // === Deal with the length
+ // --------------------
+ if((tag->GetLength())%2==1)
+ {
+ tag->SetValue(tag->GetValue()+"\0");
+ tag->SetLength(tag->GetReadLength()+1);
+ }
if ( type == ACR )
{
- if (gr < 0x0008) continue; // ignore pure DICOM V3 groups
- if (gr %2) continue; // ignore shadow groups
- if (vr == "SQ" ) continue; // ignore Sequences
+ 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 ) continue; // ignore delimiters
+ if (gr == 0xfffe ) return; // ignore delimiters
}
fwrite ( &gr,(size_t)2 ,(size_t)1 ,_fp); //group
fwrite ( &el,(size_t)2 ,(size_t)1 ,_fp); //element
- // === Deal with the length
- // --------------------
-
- // if ( (type == ExplicitVR) && (gr <= 0x0002) ) // ?!? < 2
- if ( (type == ExplicitVR) || (type == DICOMDIR) )
- {
+ if ( (type == ExplicitVR) || (type == DICOMDIR) ) {
// EXPLICIT VR
guint16 z=0, shortLgr;
- if (vr == "unkn") { // 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 == "unkn") // 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)
- {
- 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);
- }
+ if (gr == 0xfffe) { // NO Value Representation for 'delimiters'
+ // no length : write ffffffff
+
+ // special patch to make some MR PHILIPS
+ if (el == 0x0000) return; // images e-film readable // see gdcmData/gdcm-MR-PHILIPS-16-Multi-Seq.dcm
+ // from Hospital Guy de Chauliac,
+ // Montpellier
+ // we just ignore spurious fffe|0000 tag !
+
+ 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);
+ 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 ( &shortLgr,(size_t)2 ,(size_t)1 ,_fp);
+ }
+ }
}
else // IMPLICIT VR
{
// === Deal with the value
// -------------------
- if (vr == "SQ") continue; // no "value" to write for the SEQuences
- if (gr == 0xfffe)continue;
+ if (vr == "SQ") return; // no "value" to write for the SEQuences
+ if (gr == 0xfffe)return; // no "value" to write for the delimiters
- if (voidArea != NULL) { // there is a 'non string' LUT, overlay, etc
+ if (voidArea != NULL)
+ { // there is a 'non string' LUT, overlay, etc
fwrite ( voidArea,(size_t)lgr ,(size_t)1 ,_fp); // Elem value
- continue;
+ return;
}
if (vr == "US" || vr == "SS")
{
tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
- Tokenize ((*tag2)->GetValue(), tokens, "\\");
+ Tokenize (tag->GetValue(), tokens, "\\");
for (unsigned int i=0; i<tokens.size();i++)
{
val_uint16 = atoi(tokens[i].c_str());
fwrite ( ptr,(size_t)2 ,(size_t)1 ,_fp);
}
tokens.clear();
- continue;
+ return;
}
if (vr == "UL" || vr == "SL")
{
tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
- Tokenize ((*tag2)->GetValue(), tokens, "\\");
+ Tokenize (tag->GetValue(), tokens, "\\");
for (unsigned int i=0; i<tokens.size();i++)
{
val_uint32 = atoi(tokens[i].c_str());
fwrite ( ptr,(size_t)4 ,(size_t)1 ,_fp);
}
tokens.clear();
- continue;
+ return;
}
// Pixels are never loaded in the element !
if ((gr == GrPixel) && (el == NumPixel) ) {
compte++;
- if (compte == countGrPixel) // we passed *all* the GrPixel,NumPixel
- break;
+ if (compte == countGrPixel) {// we passed *all* the GrPixel,NumPixel
+ itsTimeToWritePixels = true;
+ return;
+ }
}
fwrite ( val,(size_t)lgr ,(size_t)1 ,_fp); // Elem value
+}
+
+/**
+ * \ingroup gdcmParser
+ * \brief writes on disc according to the requested format
+ * (ACR-NEMA, ExplicitVR, ImplicitVR) the image
+ * using the Chained List
+ * \warning does NOT add the missing elements in the header :
+ * it's up to the user doing it !
+ * (function CheckHeaderCoherence to be written)
+ * \warning DON'T try, right now, to write a DICOM image
+ * from an ACR Header (meta elements will be missing!)
+ * \sa WriteEntriesDeprecated (Special temporary method for Theralys)
+ * @param type type of the File to be written
+ * (ACR-NEMA, ExplicitVR, ImplicitVR)
+ * @param _fp already open file pointer
+ */
+
+void gdcmParser::WriteEntries(FILE *_fp,FileType type)
+{
+ // TODO (?) tester les echecs en ecriture (apres chaque fwrite)
+
+ for (ListTag::iterator tag2=listEntries.begin();
+ tag2 != listEntries.end();
+ ++tag2)
+ {
+ WriteEntry(*tag2,_fp,type);
+ if (itsTimeToWritePixels)
+ break;
+ }
+}
+
+/**
+ * \ingroup gdcmParser
+ * \brief writes on disc according to the requested format
+ * (ACR-NEMA, ExplicitVR, ImplicitVR) the image,
+ * using only the last synonym of each mutimap H Table post.
+ * \warning Uses the H Table, instead of the Chained List
+ * in order to be compliant with the old way to proceed
+ * (added elements taken in to account)
+ * Only THERALYS, during a transitory phase is supposed
+ * to use this method !!!
+ * \warning DON'T try, right now, to write a DICOM image
+ * from an ACR Header (meta elements will be missing!)
+ * \sa WriteEntries
+ * @param _fp already open file pointer
+ * @param type type of the File to be written
+ * (ACR-NEMA, ExplicitVR, ImplicitVR)
+ */
+void gdcmParser::WriteEntriesDeprecated(FILE *_fp,FileType type) {
+
+ // restent a tester les echecs en ecriture (apres chaque fwrite)
+
+ for (TagHeaderEntryHT::iterator tag2=tagHT.begin();
+ tag2 != tagHT.end();
+ ++tag2){
+ WriteEntry(tag2->second,_fp,type);
+ if (itsTimeToWritePixels)
+ break;
}
}
/**
* \ingroup gdcmParser
* \brief add a new Dicom Element pointer to
- * the H Table and to the chained List
+ * the H Table and at the end of the chained List
* \warning push_bash in listEntries ONLY during ParseHeader
- * \TODO something to allow further Elements addition,
- * \ when position to be taken care of
+ * \todo something to allow further Elements addition,
+ * (at their right place in the chained list)
+ * when position to be taken care of
* @param newHeaderEntry
*/
void gdcmParser::AddHeaderEntry(gdcmHeaderEntry *newHeaderEntry) {
/**
* \ingroup gdcmParser
- * \brief
- * @param Entry Header Entry whose length of the value shall be loaded.
-
- * @return
+ * \brief Find the value Length of the passed Header Entry
+ * @param Entry Header Entry whose length of the value shall be loaded.
*/
void gdcmParser::FindHeaderEntryLength (gdcmHeaderEntry *Entry) {
guint16 element = Entry->GetElement();
guint16 group = Entry->GetGroup();
std::string vr = Entry->GetVR();
guint16 length16;
+
if( (element == NumPixel) && (group == GrPixel) )
{
- dbg.SetDebug(-1);
+ dbg.SetDebug(GDCM_DEBUG);
dbg.Verbose(2, "gdcmParser::FindLength: ",
"we reached (GrPixel,NumPixel)");
}
// Actually, length= 0xffff means that we deal with
// Unknown Sequence Length
}
-
FixHeaderEntryFoundLength(Entry, (guint32)length16);
return;
}
else
{
- // Either implicit VR or a non DICOM conformal (see not below) explicit
+ // Either implicit VR or a non DICOM conformal (see note below) explicit
// VR that ommited the VR of (at least) this element. Farts happen.
// [Note: according to the part 5, PS 3.5-2001, section 7.1 p25
// on Data elements "Implicit and Explicit VR Data Elements shall
// not coexist in a Data Set and Data Sets nested within it".]
// Length is on 4 bytes.
+
FixHeaderEntryFoundLength(Entry, ReadInt32());
return;
}
* \brief Check the correspondance between the VR of the header entry
* and the taken VR. If they are different, the header entry is
* updated with the new VR.
- * @param Entry
- * @param VR
+ * @param Entry Header Entry to check
+ * @param vr Dicom Value Representation
* @return false if the VR is incorrect of if the VR isn't referenced
* otherwise, it returns true
*/
guint16 el =Entry->GetElement();
if (FoundLength%2) {
- std::cout << "Warning : Tag with uneven length " << FoundLength
- << " in x(" << std::hex << gr << "," << el <<")" << std::endl;
+ std::ostringstream s;
+ s << "Warning : Tag with uneven length " << FoundLength
+ << " in x(" << std::hex << gr << "," << el <<")" << std::dec;
+ dbg.Verbose(0,s.str().c_str());
}
// Sorry for the patch!
}
// 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)
{
- // sometimes, length seems to be wrong
- FoundLength =0; // some more clever checking to be done !
- // I give up!
- // only gdcm-MR-PHILIPS-16-Multi-Seq.dcm
- // causes troubles :-(
- }
-
+ // *normally, fffe|0000 doesn't exist !
+ if( Entry->GetElement() != 0x0000 ) // gdcm-MR-PHILIPS-16-Multi-Seq.dcm
+ // causes extra troubles :-(
+ FoundLength =0;
+ }
Entry->SetUsableLength(FoundLength);
}
/**
* \ingroup gdcmParser
- * \brief Apply some heuristics to predict wether the considered
+ * \brief Apply some heuristics to predict whether the considered
* element value contains/represents an integer or not.
* @param Entry The element value on which to apply the predicate.
* @return The result of the heuristical predicate.
return false;
}
-
/**
* \ingroup gdcmParser
- * \brief
- *
+ * \brief Find the Length till the next sequence delimiter
+ * \warning NOT end user intended method !
* @return
*/
+
guint32 gdcmParser::FindHeaderEntryLengthOB(void) {
// See PS 3.5-2001, section A.4 p. 49 on encapsulation of encoded pixel data.
guint16 g;
/**
* \ingroup gdcmParser
* \brief Reads a supposed to be 16 Bits integer
- * \ (swaps it depending on processor endianity)
- *
+ * (swaps it depending on processor endianity)
* @return read value
*/
guint16 gdcmParser::ReadInt16(void) {
/**
* \ingroup gdcmParser
* \brief Reads a supposed to be 32 Bits integer
- * \ (swaps it depending on processor endianity)
- *
+ * (swaps it depending on processor endianity)
* @return read value
*/
guint32 gdcmParser::ReadInt32(void) {
/**
* \ingroup gdcmParser
- * \brief
- *
+ * \brief skips bytes inside the source file
+ * \warning NOT end user intended method !
* @return
*/
void gdcmParser::SkipBytes(guint32 NBytes) {
/**
* \ingroup gdcmParser
- * \brief
+ * \brief Loads all the needed Dictionaries
+ * \warning NOT end user intended method !
*/
void gdcmParser::Initialise(void)
{
/**
* \ingroup gdcmParser
- * \brief
+ * \brief Restore the unproperly loaded values i.e. the group, the element
+ * and the dictionary entry depending on them.
*/
void gdcmParser::SwitchSwapToBigEndian(void)
{
/**
* \ingroup gdcmParser
- * \brief
+ * \brief during parsing, Header Elements too long are not loaded in memory
* @param NewSize
*/
void gdcmParser::SetMaxSizeLoadEntry(long NewSize)
/**
* \ingroup gdcmParser
- * \brief
- * \warning TODO : not yet usable
+ * \brief Header Elements too long will not be printed
+ * \warning
+ * \todo : not yet usable
* (see MAX_SIZE_PRINT_ELEMENT_VALUE
* in gdcmHeaderEntry gdcmLoadEntry)
*
gdcmHeaderEntry *gdcmParser::ReadNextHeaderEntry(void) {
guint16 g,n;
gdcmHeaderEntry *NewEntry;
-
g = ReadInt16();
n = ReadInt16();
* \ingroup gdcmParser
* \brief Request a new virtual dict entry to the dict set
* @param group group of the underlying DictEntry
- * @param elem element of the underlying DictEntry
+ * @param element element of the underlying DictEntry
* @param vr VR of the underlying DictEntry
* @param fourth owner group
* @param name english name
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff