+2003-03-12 Eric Boix <Eric.Boix@creatis.insa-lyon.fr>
+ * gdcmPython/__init__.py fix of GDCM_DICT_PATH which was not
+ to exported to the environement (see gdcmPython/testSuite.py
+ for usage).
+ * src/gdcmElValSet.[cxx/h], gdcmElValue.[cxx/h], gdcmFile.[cxx/h],
+ gdcmHeader.[cxx/h]: ElValSet class renamed to gdcmElValSet, and
+ ElValue class renamed to gdcmElValue for obvious consistency reasons.
+
2003-03-10 Eric Boix <Eric.Boix@creatis.insa-lyon.fr>
* gdcmPython/__init__.py doesn't crash anymore when running in
in InstallMode or PreInstallMode but with an environement given
+* gdcmElValSet::SetElValueLengthByNumber IMNSHO should be trashed.
+ It's only purpose is a onliner substitute to calling GetElValueByNumber
+ and then SetLength. This only obfuscates the caller code more than
+ clarifying it.
+ Besides the definition of gdcmElValSet::SetElValueLengthByNumber itself
+ it quite poor since it is a almost exact copy of
+ gdcmElValSet::GetElValueByNumber except for the returned code.
+ gdcmHeader::SetPubElValLengthByNumber (which is based on
+ gdcmElValSet::SetElValueLengthByNumber) is used nowhere...
* The declarations commented out and starting with "TODO Swig" (try
grep "TODO Swig" *.h) needed to be temporarily removed for swig to
proceed correctly (in fact problems appears at loading of _gdcm.[so/dll]).
-// gdcmElValSet.cxx
+// $Header: /cvs/public/gdcm/src/Attic/gdcmElValSet.cxx,v 1.17 2003/03/12 21:33:20 frog Exp $
#include "gdcmUtil.h"
#include "gdcmElValSet.h"
static void Tokenize (const string& str, vector<string>& tokens, const string& delimiters = " ");
-TagElValueHT & ElValSet::GetTagHt(void) {
+TagElValueHT & gdcmElValSet::GetTagHt(void) {
return tagHt;
}
-void ElValSet::Add(ElValue * newElValue) {
+void gdcmElValSet::Add(gdcmElValue * newElValue) {
tagHt [newElValue->GetKey()] = newElValue;
NameHt[newElValue->GetName()] = newElValue;
}
-void ElValSet::Print(ostream & os) {
+void gdcmElValSet::Print(ostream & os) {
for (TagElValueHT::iterator tag = tagHt.begin();
tag != tagHt.end();
++tag){
}
}
-void ElValSet::PrintByName(ostream & os) {
+void gdcmElValSet::PrintByName(ostream & os) {
for (TagElValueNameHT::iterator tag = NameHt.begin();
tag != NameHt.end();
++tag){
}
}
-ElValue* ElValSet::GetElementByNumber(guint32 group, guint32 element) {
+gdcmElValue* gdcmElValSet::GetElementByNumber(guint32 group, guint32 element) {
TagKey key = gdcmDictEntry::TranslateToKey(group, element);
if ( ! tagHt.count(key))
- return (ElValue*)0;
+ return (gdcmElValue*)0;
if (tagHt.count(key) > 1)
- dbg.Verbose(0, "ElValSet::GetElementByNumber",
+ dbg.Verbose(0, "gdcmElValSet::GetElementByNumber",
"multiple entries for this key (FIXME) !");
return tagHt.find(key)->second;
}
-ElValue* ElValSet::GetElementByName(string TagName) {
+gdcmElValue* gdcmElValSet::GetElementByName(string TagName) {
if ( ! NameHt.count(TagName))
- return (ElValue*)0;
+ return (gdcmElValue*)0;
if (NameHt.count(TagName) > 1)
- dbg.Verbose(0, "ElValSet::GetElement",
+ dbg.Verbose(0, "gdcmElValSet::GetElement",
"multipe entries for this key (FIXME) !");
return NameHt.find(TagName)->second;
}
-string ElValSet::GetElValueByNumber(guint32 group, guint32 element) {
+string gdcmElValSet::GetElValueByNumber(guint32 group, guint32 element) {
TagKey key = gdcmDictEntry::TranslateToKey(group, element);
if ( ! tagHt.count(key))
return "gdcm::Unfound";
if (tagHt.count(key) > 1)
- dbg.Verbose(0, "ElValSet::GetElValueByNumber",
+ dbg.Verbose(0, "gdcmElValSet::GetElValueByNumber",
"multiple entries for this key (FIXME) !");
return tagHt.find(key)->second->GetValue();
}
-string ElValSet::GetElValueByName(string TagName) {
+string gdcmElValSet::GetElValueByName(string TagName) {
if ( ! NameHt.count(TagName))
return "gdcm::Unfound";
if (NameHt.count(TagName) > 1)
- dbg.Verbose(0, "ElValSet::GetElValue",
+ dbg.Verbose(0, "gdcmElValSet::GetElValue",
"multipe entries for this key (FIXME) !");
return NameHt.find(TagName)->second->GetValue();
}
-int ElValSet::SetElValueByNumber(string content, guint32 group, guint32 element) {
+int gdcmElValSet::SetElValueByNumber(string content,
+ guint32 group, guint32 element) {
TagKey key = gdcmDictEntry::TranslateToKey(group, element);
if ( ! tagHt.count(key))
return 0;
if (tagHt.count(key) > 1) {
- dbg.Verbose(0, "ElValSet::SetElValueByNumber",
+ dbg.Verbose(0, "gdcmElValSet::SetElValueByNumber",
"multiple entries for this key (FIXME) !");
return (0);
}
return(1);
}
-int ElValSet::SetElValueByName(string content, string TagName) {
+int gdcmElValSet::SetElValueByName(string content, string TagName) {
if ( ! NameHt.count(TagName))
return 0;
if (NameHt.count(TagName) > 1) {
- dbg.Verbose(0, "ElValSet::SetElValueByName",
+ dbg.Verbose(0, "gdcmElValSet::SetElValueByName",
"multipe entries for this key (FIXME) !");
return 0;
}
}
-int ElValSet::SetElValueLengthByNumber(guint32 l, guint32 group, guint32 element) {
+int gdcmElValSet::SetElValueLengthByNumber(guint32 l,
+ guint32 group, guint32 element) {
TagKey key = gdcmDictEntry::TranslateToKey(group, element);
if ( ! tagHt.count(key))
return 0;
if (tagHt.count(key) > 1) {
- dbg.Verbose(0, "ElValSet::SetElValueLengthByNumber",
+ dbg.Verbose(0, "gdcmElValSet::SetElValueLengthByNumber",
"multiple entries for this key (FIXME) !");
return (0);
}
+ // FIXME JPR: comments in English please !
// m à j LgrElem
tagHt[key]->SetLength(l);
return(1);
}
-int ElValSet::SetElValueLengthByName(guint32 l, string TagName) {
+int gdcmElValSet::SetElValueLengthByName(guint32 l, string TagName) {
if ( ! NameHt.count(TagName))
return 0;
if (NameHt.count(TagName) > 1) {
- dbg.Verbose(0, "ElValSet::SetElValueByName",
+ dbg.Verbose(0, "gdcmElValSet::SetElValueByName",
"multipe entries for this key (FIXME) !");
return 0;
}
}
-int ElValSet::Write(FILE * _fp) {
+int gdcmElValSet::Write(FILE * _fp) {
// ATTENTION : fonction non terminée (commitée a titre de precaution)
// Utilisées pour le calcul Group Length
int deja = 0;
guint32 lgrCalcGroupe=0;
- ElValue *elem, *elemZ, *elemZPrec;
+ gdcmElValue *elem, *elemZ, *elemZPrec;
guint16 grCourant = 0;
// Question :
if(elemZ->GetElement() != 0x0000) { // pas d'element 'Lgr groupe'
// On crée
gdcmDictEntry * tagZ = new gdcmDictEntry(grCourant, 0x0000, "UL");
- elemZ = new ElValue(tagZ); // on le cree
+ elemZ = new gdcmElValue(tagZ); // on le cree
elemZ->SetLength(4);
Add(elemZ); // On l'accroche à sa place
}
-int ElValSet::WriteAcr(FILE * _fp) {
+int gdcmElValSet::WriteAcr(FILE * _fp) {
// ATTENTION : fonction non terminée (commitée a titre de precaution)
// Utilisées pour le calcul Group Length
int deja = 0;
guint32 lgrCalcGroupe=0;
- ElValue *elem, *elemZ, *elemZPrec;
+ gdcmElValue *elem, *elemZ, *elemZPrec;
guint16 grCourant = 0;
// Question :
if(elemZ->GetElement() != 0x0000) { // pas d'element 'Lgr groupe'
// On crée
gdcmDictEntry * tagZ = new gdcmDictEntry(grCourant, 0x0000, "UL");
- elemZ = new ElValue(tagZ); // on le cree
+ elemZ = new gdcmElValue(tagZ); // on le cree
elemZ->SetLength(4);
Add(elemZ); // On l'accroche à sa place
}
-// gdcmElValSet.h
+// $Header: /cvs/public/gdcm/src/Attic/gdcmElValSet.h,v 1.3 2003/03/12 21:33:20 frog Exp $
#ifndef GDCMELVALSET_H
#define GDCMELVALSET_H
////////////////////////////////////////////////////////////////////////////
// Container for a set of successfully parsed ElValues.
-typedef map<TagKey, ElValue*> TagElValueHT;
-typedef map<string, ElValue*> TagElValueNameHT;
+typedef map<TagKey, gdcmElValue*> TagElValueHT;
+typedef map<string, gdcmElValue*> TagElValueNameHT;
-class GDCM_EXPORT ElValSet {
+class GDCM_EXPORT gdcmElValSet {
TagElValueHT tagHt; // Both accesses with a TagKey or with a
TagElValueNameHT NameHt; // the DictEntry.Name are required.
public:
- void Add(ElValue*);
+ void Add(gdcmElValue*);
void Print(ostream &);
void PrintByName(ostream &);
int Write(FILE *fp);
int WriteAcr(FILE *fp);
- ElValue* GetElementByNumber(guint32 group, guint32 element);
- ElValue* GetElementByName (string);
+ gdcmElValue* GetElementByNumber(guint32 group, guint32 element);
+ gdcmElValue* GetElementByName (string);
string GetElValueByNumber(guint32 group, guint32 element);
string GetElValueByName (string);
* @param in Pointer to existing dictionary entry
*/
-ElValue::ElValue(gdcmDictEntry* in) {
+gdcmElValue::gdcmElValue(gdcmDictEntry* in) {
ImplicitVr = false;
entry = in;
}
-// gdcmElValue.h
+// $Header: /cvs/public/gdcm/src/Attic/gdcmElValue.h,v 1.2 2003/03/12 21:33:20 frog Exp $
#ifndef GDCMELVALUE_H
#define GDCMELVALUE_H
#include "gdcmDictEntry.h"
+class gdcmHeader;
///////////////////////////////////////////////////////////////////////////
// The dicom header of a Dicom file contains a set of such ELement VALUES
// (when successfuly parsed against a given Dicom dictionary)
-class GDCM_EXPORT ElValue {
+class GDCM_EXPORT gdcmElValue {
private:
gdcmDictEntry *entry;
guint32 LgrElem;
// elements happen to be implicit. Flag them here
// since we can't use the entry->vr without breaking
// the underlying dictionary.
+ void SetOffset(size_t of){ Offset = of; };
+ // FIXME: In fact we should be more specific and use :
+ //friend gdcmElValue * gdcmHeader::ReadNextElement(void);
+ friend class gdcmHeader;
public:
string value;
size_t Offset; // Offset from the begining of file for direct user access
- ElValue(gdcmDictEntry*);
+ gdcmElValue(gdcmDictEntry*);
void SetDictEntry(gdcmDictEntry *NewEntry) { entry = NewEntry; };
bool IsVrUnknown(void) { return entry->IsVrUnknown(); };
void SetImplicitVr(void) { ImplicitVr = true; };
void SetLength(guint32 l){ LgrElem = l; };
guint32 GetLength(void) { return LgrElem; };
- // Question : SetLength est public
- // (sinon, on ne pourrait pas l'appeler dans ElValSet)
- // alors que *personne* ne devrait s'en servir !
- // c'est *forcément* la lgr de la string 'value', non?
-
void SetValue(string val){ value = val; };
string GetValue(void) { return value;};
- void SetOffset(size_t of){ Offset = of; };
size_t GetOffset(void) { return Offset;};
- // Question : SetOffset est public ...
- // Quel utilisateur serait ammené à modifier l'Offset ?
};
+
#endif
/**
* \ingroup gdcmFile
* \brief Constructor dedicated to writing a new DICOMV3 part10 compliant
- * \file (see SetFileName, SetDcmTag and Write)
- * \Opens (in read only and when possible) an existing file and checks
- * \for DICOM compliance. Returns NULL on failure.
- * \Note: the in-memory representation of all available tags found in
- * \the DICOM header is post-poned to first header information access.
- * \This avoid a double parsing of public part of the header when
- * \one sets an a posteriori shadow dictionary (efficiency can be
- * \seen as a side effect).
+ * file (see SetFileName, SetDcmTag and Write)
+ * Opens (in read only and when possible) an existing file and checks
+ * for DICOM compliance. Returns NULL on failure.
+ * \Note the in-memory representation of all available tags found in
+ * the DICOM header is post-poned to first header information access.
+ * This avoid a double parsing of public part of the header when
+ * one sets an a posteriori shadow dictionary (efficiency can be
+ * seen as a side effect).
*
- * @param
+ * @param filename file to be opened for parsing
*
* @return
*/
/////////////////////////////////////////////////////////////////
+// FIXME JPR: comments in English please !
/**
* \ingroup gdcmFile
* \brief Renvoie la longueur A ALLOUER pour recevoir les pixels de l'image
fwrite("DICM",4,1,fp1);
// un accesseur de + est obligatoire ???
- // pourtant le ElValSet contenu dans le gdcmHeader
+ // pourtant le gdcmElValSet contenu dans le gdcmHeader
// ne devrait pas être visible par l'utilisateur final (?)
GetPubElVals().Write(fp1);
}
// un accesseur de + est obligatoire ???
- // pourtant le ElValSet contenu dans le gdcmHeader
+ // pourtant le gdcmElValSet contenu dans le gdcmHeader
// ne devrait pas être visible par l'utilisateur final (?)
GetPubElVals().WriteAcr(fp1);
* \ingroup gdcmHeader
* \brief Find the value representation of the current tag.
*/
-void gdcmHeader::FindVR( ElValue *ElVal) {
+void gdcmHeader::FindVR( gdcmElValue *ElVal) {
if (filetype != ExplicitVR)
return;
* @return True when ImplicitVRLittleEndian found. False in all other cases.
*/
bool gdcmHeader::IsImplicitVRLittleEndianTransferSyntax(void) {
- ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
* @return True when ExplicitVRLittleEndian found. False in all other cases.
*/
bool gdcmHeader::IsExplicitVRLittleEndianTransferSyntax(void) {
- ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
* @return True when DeflatedExplicitVRLittleEndian found. False in all other cases.
*/
bool gdcmHeader::IsDeflatedExplicitVRLittleEndianTransferSyntax(void) {
- ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
* @return True when big endian found. False in all other cases.
*/
bool gdcmHeader::IsExplicitVRBigEndianTransferSyntax(void) {
- ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
* @return True when JPEGBaseLineProcess1found. False in all other cases.
*/
bool gdcmHeader::IsJPEGBaseLineProcess1TransferSyntax(void) {
- ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
// faire qq chose d'intelligent a la place de ça
bool gdcmHeader::IsJPEGLossless(void) {
- ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
* @return True when JPEGExtendedProcess2-4 found. False in all other cases.
*/
bool gdcmHeader::IsJPEGExtendedProcess2_4TransferSyntax(void) {
- ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
* @return True when JPEGExtendedProcess3-5 found. False in all other cases.
*/
bool gdcmHeader::IsJPEGExtendedProcess3_5TransferSyntax(void) {
- ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
* other cases.
*/
bool gdcmHeader::IsJPEGSpectralSelectionProcess6_8TransferSyntax(void) {
- ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ gdcmElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
* the parser went Jabberwocky) one can hope improving things by
* applying this heuristic.
*/
-void gdcmHeader::FixFoundLength(ElValue * ElVal, guint32 FoundLength) {
+void gdcmHeader::FixFoundLength(gdcmElValue * ElVal, guint32 FoundLength) {
if ( FoundLength == 0xffffffff)
FoundLength = 0;
ElVal->SetLength(FoundLength);
return TotalLength;
}
-void gdcmHeader::FindLength(ElValue * ElVal) {
+void gdcmHeader::FindLength(gdcmElValue * ElVal) {
guint16 element = ElVal->GetElement();
string vr = ElVal->GetVR();
guint16 length16;
(void)fseek(fp, (long)NBytes, SEEK_CUR);
}
-void gdcmHeader::SkipElementValue(ElValue * ElVal) {
+void gdcmHeader::SkipElementValue(gdcmElValue * ElVal) {
SkipBytes(ElVal->GetLength());
}
* than the value specified with
* gdcmHeader::SetMaxSizeLoadElementValue()
*/
-void gdcmHeader::LoadElementValue(ElValue * ElVal) {
+void gdcmHeader::LoadElementValue(gdcmElValue * ElVal) {
size_t item_read;
guint16 group = ElVal->GetGroup();
guint16 elem = ElVal->GetElement();
* @param ElVal Element whose value shall be loaded.
* @return
*/
-void gdcmHeader::LoadElementValueSafe(ElValue * ElVal) {
+void gdcmHeader::LoadElementValueSafe(gdcmElValue * ElVal) {
long PositionOnEntry = ftell(fp);
LoadElementValue(ElVal);
fseek(fp, PositionOnEntry, SEEK_SET);
* @param Group group of the underlying DictEntry
* @param Elem element of the underlying DictEntry
*/
-ElValue* gdcmHeader::NewElValueByKey(guint16 Group, guint16 Elem) {
+gdcmElValue* gdcmHeader::NewElValueByKey(guint16 Group, guint16 Elem) {
// Find out if the tag we encountered is in the dictionaries:
gdcmDictEntry * NewTag = GetDictEntryByKey(Group, Elem);
if (!NewTag)
NewTag = new gdcmDictEntry(Group, Elem);
- ElValue* NewElVal = new ElValue(NewTag);
+ gdcmElValue* NewElVal = new gdcmElValue(NewTag);
if (!NewElVal) {
dbg.Verbose(1, "gdcmHeader::NewElValueByKey",
- "failed to allocate ElValue");
- return (ElValue*)0;
+ "failed to allocate gdcmElValue");
+ return (gdcmElValue*)0;
}
return NewElVal;
}
* a default one when absent.
* @param Name Name of the underlying DictEntry
*/
-ElValue* gdcmHeader::NewElValueByName(string Name) {
+gdcmElValue* gdcmHeader::NewElValueByName(string Name) {
gdcmDictEntry * NewTag = GetDictEntryByName(Name);
if (!NewTag)
NewTag = new gdcmDictEntry(0xffff, 0xffff, "LO", "Unknown", Name);
- ElValue* NewElVal = new ElValue(NewTag);
+ gdcmElValue* NewElVal = new gdcmElValue(NewTag);
if (!NewElVal) {
dbg.Verbose(1, "gdcmHeader::ObtainElValueByName",
- "failed to allocate ElValue");
- return (ElValue*)0;
+ "failed to allocate gdcmElValue");
+ return (gdcmElValue*)0;
}
return NewElVal;
}
* \brief Read the next tag but WITHOUT loading it's value
* @return On succes the newly created ElValue, NULL on failure.
*/
-ElValue * gdcmHeader::ReadNextElement(void) {
+gdcmElValue * gdcmHeader::ReadNextElement(void) {
guint16 g;
guint16 n;
- ElValue * NewElVal;
+ gdcmElValue * NewElVal;
g = ReadInt16();
n = ReadInt16();
if (errno == 1)
// We reached the EOF (or an error occured) and header parsing
// has to be considered as finished.
- return (ElValue *)0;
+ return (gdcmElValue *)0;
NewElVal = NewElValueByKey(g, n);
FindVR(NewElVal);
FindLength(NewElVal);
if (errno == 1)
// Call it quits
- return (ElValue *)0;
+ return (gdcmElValue *)0;
NewElVal->SetOffset(ftell(fp));
return NewElVal;
}
* @param ElVal The element value on which to apply the predicate.
* @return The result of the heuristical predicate.
*/
-bool gdcmHeader::IsAnInteger(ElValue * ElVal) {
+bool gdcmHeader::IsAnInteger(gdcmElValue * ElVal) {
guint16 group = ElVal->GetGroup();
guint16 element = ElVal->GetElement();
string vr = ElVal->GetVR();
numPixel = 0x1010;
else
numPixel = 0x0010;
- ElValue* PixelElement = PubElVals.GetElementByNumber(grPixel, numPixel);
+ gdcmElValue* PixelElement = PubElVals.GetElementByNumber(grPixel, numPixel);
if (PixelElement)
return PixelElement->GetOffset();
else
* and the string "gdcm::Unfound" otherwise.
*/
string gdcmHeader::GetPubElValRepByNumber(guint16 group, guint16 element) {
- ElValue* elem = PubElVals.GetElementByNumber(group, element);
+ gdcmElValue* elem = PubElVals.GetElementByNumber(group, element);
if ( !elem )
return "gdcm::Unfound";
return elem->GetVR();
* and the string "gdcm::Unfound" otherwise.
*/
string gdcmHeader::GetPubElValRepByName(string TagName) {
- ElValue* elem = PubElVals.GetElementByName(TagName);
+ gdcmElValue* elem = PubElVals.GetElementByName(TagName);
if ( !elem )
return "gdcm::Unfound";
return elem->GetVR();
* and the string "gdcm::Unfound" otherwise.
*/
string gdcmHeader::GetShaElValRepByNumber(guint16 group, guint16 element) {
- ElValue* elem = ShaElVals.GetElementByNumber(group, element);
+ gdcmElValue* elem = ShaElVals.GetElementByNumber(group, element);
if ( !elem )
return "gdcm::Unfound";
return elem->GetVR();
* and the string "gdcm::Unfound" otherwise.
*/
string gdcmHeader::GetShaElValRepByName(string TagName) {
- ElValue* elem = ShaElVals.GetElementByName(TagName);
+ gdcmElValue* elem = ShaElVals.GetElementByName(TagName);
if ( !elem )
return "gdcm::Unfound";
return elem->GetVR();
/**
* \ingroup gdcmHeader
- * \brief Accesses an existing ElValue in the PubElVals of this instance
+ * \brief Accesses an existing gdcmElValue in the PubElVals of this instance
* through it's (group, element) and modifies it's content with
* the given value.
* @param content new value to substitute with
/**
* \ingroup gdcmHeader
- * \brief Accesses an existing ElValue in the PubElVals of this instance
+ * \brief Accesses an existing gdcmElValue in the PubElVals of this instance
* through tag name and modifies it's content with the given value.
* @param content new value to substitute with
* @param TagName name of the tag to be modified
/**
* \ingroup gdcmHeader
- * \brief Accesses an existing ElValue in the PubElVals of this instance
+ * \brief Accesses an existing gdcmElValue in the PubElVals of this instance
* through it's (group, element) and modifies it's length with
* the given value.
* NOT FOR BOZOs !
/**
* \ingroup gdcmHeader
- * \brief Accesses an existing ElValue in the ShaElVals of this instance
+ * \brief Accesses an existing gdcmElValue in the ShaElVals of this instance
* through it's (group, element) and modifies it's content with
* the given value.
* @param content new value to substitute with
return ( ShaElVals.SetElValueByNumber (content, group, element) );
}
-
-
-
/**
* \ingroup gdcmHeader
- * \brief Accesses an existing ElValue in the ShaElVals of this instance
+ * \brief Accesses an existing gdcmElValue in the ShaElVals of this instance
* through tag name and modifies it's content with the given value.
* @param content new value to substitute with
* @param TagName name of the tag to be modified
* \brief Parses the header of the file but WITHOUT loading element values.
*/
void gdcmHeader::ParseHeader(bool exception_on_error) throw(gdcmFormatError) {
- ElValue * newElValue = (ElValue *)0;
+ gdcmElValue * newElValue = (gdcmElValue *)0;
rewind(fp);
CheckSwap();
/**
* \ingroup gdcmHeader
* \brief Once the header is parsed add some gdcm convenience/helper elements
- * in the ElValSet. For example add:
+ * in the gdcmElValSet. For example add:
* - gdcmImageType which is an entry containing a short for the
* type of image and whose value ranges in
* I8 (unsigned 8 bit image)
* the ones of the official DICOM fields Rows, Columns and Planes.
*/
void gdcmHeader::AddAndDefaultElements(void) {
- ElValue* NewEntry = (ElValue*)0;
+ gdcmElValue* NewEntry = (gdcmElValue*)0;
NewEntry = NewElValueByName("gdcmXSize");
NewEntry->SetValue(GetElValByName("Rows"));
gdcmDict* RefShaDict;
/// ELement VALueS parsed with the PUBlic dictionary.
- ElValSet PubElVals;
+ gdcmElValSet PubElVals;
/// ELement VALueS parsed with the SHAdow dictionary.
- ElValSet ShaElVals;
+ gdcmElValSet ShaElVals;
/// Refering underlying filename.
string filename;
FILE * fp;
gdcmDictEntry * GetDictEntryByName(string name);
// ElValue related utilities
- ElValue * ReadNextElement(void);
- ElValue * NewElValueByKey(guint16 group, guint16 element);
- ElValue * NewElValueByName(string name);
- void FindLength(ElValue *);
- void FindVR(ElValue *);
- void LoadElementValue(ElValue *);
- void LoadElementValueSafe(ElValue *);
- void SkipElementValue(ElValue *);
- void FixFoundLength(ElValue*, guint32);
- bool IsAnInteger(ElValue *);
+ gdcmElValue * ReadNextElement(void);
+ gdcmElValue * NewElValueByKey(guint16 group, guint16 element);
+ gdcmElValue * NewElValueByName(string name);
+ void FindLength(gdcmElValue *);
+ void FindVR(gdcmElValue *);
+ void LoadElementValue(gdcmElValue *);
+ void LoadElementValueSafe(gdcmElValue *);
+ void SkipElementValue(gdcmElValue *);
+ void FixFoundLength(gdcmElValue*, guint32);
+ bool IsAnInteger(gdcmElValue *);
bool IsImplicitVRLittleEndianTransferSyntax(void);
bool IsExplicitVRLittleEndianTransferSyntax(void);
int gdcmHeader::SetPubElValLengthByNumber(guint32 lgr, guint16 group,
guint16 element);
- ElValSet GetPubElVals() { return(PubElVals); }
+ gdcmElValSet GetPubElVals() { return(PubElVals); }
};
#endif
projects / gdcm.git / commitdiff