+// gdcmHeader.cxx
+
#include "gdcm.h"
#include <stdio.h>
// For nthos:
#include <sstream>
#include "gdcmUtil.h"
-#define HEADER_LENGHT_TO_READ 256 // on ne lit plus que le debut
+#define HEADER_LENGTH_TO_READ 256 // on ne lit plus que le debut
+#define _MaxSizeLoadElementValue_ 1024 // longueur au dela de laquelle on ne charge plus les valeurs
namespace Error {
struct FileReadError {
}
//FIXME: this looks dirty to me...
+
#define str2num(str, typeNum) *((typeNum *)(str))
+// str est un pointeur dans un tableau de caractères, qui doit contenir,
+// à cet endroit la, la représentation binaire d'un entier (16 ou 32 bits)
+// je veux récupérer ça ... dans un entier.
+// s'il y a une autre solution, évitant des cast et les indirections,
+// je suis preneur
+
VRHT * gdcmHeader::dicom_vr = (VRHT*)0;
gdcmDictSet* gdcmHeader::Dicts = new gdcmDictSet();
}
gdcmHeader::gdcmHeader (const char* InFilename) {
- SetMaxSizeLoadElementValue(1024);
+ SetMaxSizeLoadElementValue(_MaxSizeLoadElementValue_);
filename = InFilename;
Initialise();
fp=fopen(InFilename,"rw");
/**
* \ingroup gdcmHeader
- * \brief La seule maniere sure que l'on aie pour determiner
- * si on est en LITTLE_ENDIAN, BIG-ENDIAN,
- * BAD-LITTLE-ENDIAN, BAD-BIG-ENDIAN
- * est de trouver l'element qui donne la longueur d'un 'GROUP'
- * (on sait que la longueur de cet element vaut 0x00000004)
- * et de regarder comment cette longueur est codee en memoire
- *
- * Le probleme vient de ce que parfois, il n'y en a pas ...
- *
- * On fait alors le pari qu'on a a faire a du LITTLE_ENDIAN propre.
- * (Ce qui est la norme -pas respectee- depuis ACR-NEMA)
- * Si ce n'est pas le cas, on ne peut rien faire.
+ * \brief Discover what the swap code is (among little endian, big endian,
+ * bad little endian, bad big endian).
*
- * (il faudrait avoir des fonctions auxquelles
- * on passe le code Swap en parametre, pour faire des essais 'manuels')
*/
void gdcmHeader::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 : pour ntohs
bool net2host; // true when HostByteOrder is the same as NetworkByteOrder
int lgrLue;
char * entCur;
- char deb[HEADER_LENGHT_TO_READ];
+ char deb[HEADER_LENGTH_TO_READ];
// First, compare HostByteOrder and NetworkByteOrder in order to
// determine if we shall need to swap bytes (i.e. the Endian type).
net2host = false;
// The easiest case is the one of a DICOM header, since it possesses a
- // file preamble where it suffice to look for the sting "DICM".
- lgrLue = fread(deb, 1, HEADER_LENGHT_TO_READ, fp);
+ // 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) {
return;
default :
dbg.Verbose(0, "gdcmHeader::CheckSwap:",
- "ACE/NEMA unfound swap info (time to raise bets)");
+ "ACR/NEMA unfound swap info (time to raise bets)");
}
// 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.
- //FIXME Si c'est du RAW, ca degagera + tard
-
if (! net2host )
sw = 0;
else
sw = 3412;
}
+void gdcmHeader::GetPixels(size_t lgrTotale, void* _Pixels) {
+ size_t pixelsOffset;
+ pixelsOffset = GetPixelOffset();
+ fseek(fp, pixelsOffset, SEEK_SET);
+ fread(_Pixels, 1, lgrTotale, fp);
+}
+
+
+
/**
* \ingroup gdcmHeader
- * \brief recupere la longueur d'un champ DICOM.
- * Preconditions:
- * 1/ le fichier doit deja avoir ete ouvert,
- * 2/ CheckSwap() doit avoir ete appele
- * 3/ la partie 'group' ainsi que la partie 'elem'
- * de l'acr_element doivent avoir ete lues.
- *
- * ACR-NEMA : we allways get
- * GroupNumber (2 Octets)
- * ElementNumber (2 Octets)
- * ElementSize (4 Octets)
- * DICOM en implicit Value Representation :
- * GroupNumber (2 Octets)
- * ElementNumber (2 Octets)
- * ElementSize (4 Octets)
- *
- * DICOM en explicit Value Representation :
- * GroupNumber (2 Octets)
- * ElementNumber (2 Octets)
- * ValueRepresentation (2 Octets)
- * ElementSize (2 Octets)
- *
- * ATTENTION : dans le cas ou ValueRepresentation = OB, OW, SQ, UN
- * GroupNumber (2 Octets)
- * ElementNumber (2 Octets)
- * ValueRepresentation (2 Octets)
- * zone reservee (2 Octets)
- * ElementSize (4 Octets)
+ * \brief Find the value representation of the current tag.
*
* @param sw code swap
* @param skippedLength pointeur sur nombre d'octets que l'on a saute qd
* effectivement lue
* @return longueur retenue pour le champ
*/
+
+// -->
+// --> Oops
+// --> C'etait la description de quoi, ca?
+// -->
void gdcmHeader::FindVR( ElValue *ElVal) {
if (filetype != ExplicitVR)
// 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)
// the dicom_vr dictionary with oddities like "\004\0" which crashes
- // both GCC and VC++ implentations of the STL map. Hence when the
+ // both GCC and VC++ implementations of the STL map. Hence when the
// expected VR read happens to be non-ascii characters we consider
// we hit falsely explicit VR tag.
/**
* \ingroup gdcmHeader
* \brief Determines if the Transfer Syntax was allready encountered
- * and if it corresponds to a Big Endian one.
+ * and if it corresponds to a ImplicitVRLittleEndian one.
+ *
+ * @return True when ImplicitVRLittleEndian found. False in all other cases.
+ */
+bool gdcmHeader::IsImplicitVRLittleEndianTransferSyntax(void) {
+ ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ if ( !Element )
+ return false;
+ LoadElementValueSafe(Element);
+ string Transfer = Element->GetValue();
+ if ( Transfer == "1.2.840.10008.1.2" )
+ return true;
+ return false;
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Determines if the Transfer Syntax was allready encountered
+ * and if it corresponds to a ExplicitVRLittleEndian one.
+ *
+ * @return True when ExplicitVRLittleEndian found. False in all other cases.
+ */
+bool gdcmHeader::IsExplicitVRLittleEndianTransferSyntax(void) {
+ ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ if ( !Element )
+ return false;
+ LoadElementValueSafe(Element);
+ string Transfer = Element->GetValue();
+ if ( Transfer == "1.2.840.10008.1.2.1" )
+ return true;
+ return false;
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Determines if the Transfer Syntax was allready encountered
+ * and if it corresponds to a DeflatedExplicitVRLittleEndian one.
+ *
+ * @return True when DeflatedExplicitVRLittleEndian found. False in all other cases.
+ */
+bool gdcmHeader::IsDeflatedExplicitVRLittleEndianTransferSyntax(void) {
+ ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ if ( !Element )
+ return false;
+ LoadElementValueSafe(Element);
+ string Transfer = Element->GetValue();
+ if ( Transfer == "1.2.840.10008.1.2.1.99" )
+ return true;
+ return false;
+}
+
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Determines if the Transfer Syntax was allready encountered
+ * and if it corresponds to a Explicit VR Big Endian one.
*
* @return True when big endian found. False in all other cases.
*/
-bool gdcmHeader::IsBigEndianTransferSyntax(void) {
- ElValue* Element = PubElVals.GetElement(0x0002, 0x0010);
+bool gdcmHeader::IsExplicitVRBigEndianTransferSyntax(void) {
+ ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
if ( !Element )
return false;
LoadElementValueSafe(Element);
return false;
}
-void gdcmHeader::FixFoundLength(ElValue * ElVal, guint32 FoudLength) {
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Determines if the Transfer Syntax was allready encountered
+ * and if it corresponds to a JPEGBaseLineProcess1 one.
+ *
+ * @return True when JPEGBaseLineProcess1found. False in all other cases.
+ */
+bool gdcmHeader::IsJPEGBaseLineProcess1TransferSyntax(void) {
+ ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ if ( !Element )
+ return false;
+ LoadElementValueSafe(Element);
+ string Transfer = Element->GetValue();
+ if ( Transfer == "1.2.840.10008.1.2.4.50" )
+ return true;
+ return false;
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Determines if the Transfer Syntax was allready encountered
+ * and if it corresponds to a JPEGExtendedProcess2-4 one.
+ *
+ * @return True when JPEGExtendedProcess2-4 found. False in all other cases.
+ */
+bool gdcmHeader::IsJPEGExtendedProcess2_4TransferSyntax(void) {
+ ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ if ( !Element )
+ return false;
+ LoadElementValueSafe(Element);
+ string Transfer = Element->GetValue();
+ if ( Transfer == "1.2.840.10008.1.2.4.51" )
+ return true;
+ return false;
+}
+
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Determines if the Transfer Syntax was allready encountered
+ * and if it corresponds to a JPEGExtendeProcess3-5 one.
+ *
+ * @return True when JPEGExtendedProcess3-5 found. False in all other cases.
+ */
+bool gdcmHeader::IsJPEGExtendedProcess3_5TransferSyntax(void) {
+ ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ if ( !Element )
+ return false;
+ LoadElementValueSafe(Element);
+ string Transfer = Element->GetValue();
+ if ( Transfer == "1.2.840.10008.1.2.4.52" )
+ return true;
+ return false;
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Determines if the Transfer Syntax was allready encountered
+ * and if it corresponds to a JPEGSpectralSelectionProcess6-8 one.
+ *
+ * @return True when JPEGSpectralSelectionProcess6-8 found. False in all other cases.
+ */
+bool gdcmHeader::IsJPEGSpectralSelectionProcess6_8TransferSyntax(void) {
+ ElValue* Element = PubElVals.GetElementByNumber(0x0002, 0x0010);
+ if ( !Element )
+ return false;
+ LoadElementValueSafe(Element);
+ string Transfer = Element->GetValue();
+ if ( Transfer == "1.2.840.10008.1.2.4.53" )
+ return true;
+ return false;
+}
+
+//
+// Euhhhhhhh
+// Il y en a encore DIX-SEPT, comme ça.
+// Il faudrait trouver qq chose + rusé ...
+//
+// --> probablement TOUS les supprimer (Eric dixit)
+//
+
+
+void gdcmHeader::FixFoundLength(ElValue * ElVal, guint32 FoundLength) {
// Heuristic: a final fix.
- if ( FoudLength == 0xffffffff)
- FoudLength = 0;
- ElVal->SetLength(FoudLength);
+ if ( FoundLength == 0xffffffff)
+ FoundLength = 0;
+ ElVal->SetLength(FoundLength);
+}
+
+guint32 gdcmHeader::FindLengthOB(void) {
+ // See PS 3.5-2001, section A.4 p. 49 on encapsulation of encoded pixel data.
+ guint16 g;
+ guint16 n;
+ long PositionOnEntry = ftell(fp);
+ bool FoundSequenceDelimiter = false;
+ guint32 TotalLength = 0;
+ guint32 ItemLength;
+
+ while ( ! FoundSequenceDelimiter) {
+ g = ReadInt16();
+ n = ReadInt16();
+ TotalLength += 4; // We even have to decount the group and element
+ if ( g != 0xfffe ) {
+ dbg.Verbose(1, "gdcmHeader::FindLengthOB: ",
+ "wrong group for an item sequence.");
+ throw Error::FileReadError(fp, "gdcmHeader::FindLengthOB");
+ }
+ if ( n == 0xe0dd )
+ FoundSequenceDelimiter = true;
+ else if ( n != 0xe000) {
+ dbg.Verbose(1, "gdcmHeader::FindLengthOB: ",
+ "wrong element for an item sequence.");
+ throw Error::FileReadError(fp, "gdcmHeader::FindLengthOB");
+ }
+ ItemLength = ReadInt32();
+ TotalLength += ItemLength + 4; // We add 4 bytes since we just read
+ // the ItemLength with ReadInt32
+ SkipBytes(ItemLength);
+ }
+ fseek(fp, PositionOnEntry, SEEK_SET);
+ return TotalLength;
}
-void gdcmHeader::FindLength( ElValue * ElVal) {
+void gdcmHeader::FindLength(ElValue * ElVal) {
guint16 element = ElVal->GetElement();
string vr = ElVal->GetVR();
guint16 length16;
// 7.1.2 Data element structure with explicit vr p27) must be
// skipped before proceeding on reading the length on 4 bytes.
fseek(fp, 2L, SEEK_CUR);
- FixFoundLength(ElVal, ReadInt32());
+ guint32 length32 = ReadInt32();
+ if ( (vr == "OB") && (length32 == 0xffffffff) ) {
+ ElVal->SetLength(FindLengthOB());
+ return;
+ }
+ FixFoundLength(ElVal, length32);
return;
}
// We can tell the current file is encoded in big endian (like
// Data/US-RGB-8-epicard) when we find the "Transfer Syntax" tag
- // and it's value is the one of the encoding of a bie endian file.
+ // and it's value is the one of the encoding of a big endian file.
// In order to deal with such big endian encoded files, we have
// (at least) two strategies:
// * when we load the "Transfer Syntax" tag with value of big endian
// in little endian, and big endian coding only starts at the next
// group. The corresponding code can be hard to analyse and adds
// many additional unnecessary tests for regular tags.
- // * the second strategy consist to wait for trouble, that shall appear
+ // * the second strategy consists in waiting for trouble, that shall appear
// when we find the first group with big endian encoding. This is
// easy to detect since the length of a "Group Length" tag (the
// ones with zero as element number) has to be of 4 (0x0004). When we
// endian encoding". When this is the case, chances are we got our
// hands on a big endian encoded file: we switch the swap code to
// big endian and proceed...
- if ( (element == 0) && (length16 == 1024) ) {
- if ( ! IsBigEndianTransferSyntax() )
+ if ( (element == 0x000) && (length16 == 0x0400) ) {
+ if ( ! IsExplicitVRBigEndianTransferSyntax() )
throw Error::FileReadError(fp, "gdcmHeader::FindLength");
length16 = 4;
SwitchSwapToBigEndian();
return (a);
}
-void gdcmHeader::SkipElementValue(ElValue * ElVal) {
+void gdcmHeader::SkipBytes(guint32 NBytes) {
//FIXME don't dump the returned value
- (void)fseek(fp, (long)ElVal->GetLength(), SEEK_CUR);
+ (void)fseek(fp, (long)NBytes, SEEK_CUR);
+}
+
+void gdcmHeader::SkipElementValue(ElValue * ElVal) {
+ SkipBytes(ElVal->GetLength());
}
void gdcmHeader::SetMaxSizeLoadElementValue(long NewSize) {
fseek(fp, (long)ElVal->GetOffset(), SEEK_SET);
// Sequences not treated yet !
+ //
+ // Ne faudrait-il pas au contraire trouver immediatement
+ // une maniere 'propre' de traiter les sequences (vr = SQ)
+ // car commencer par les ignorer risque de conduire a qq chose
+ // qui pourrait ne pas etre generalisable
+ //
if( vr == "SQ" )
SkipLoad = true;
// The group length doesn't represent data to be loaded in memory, since
// each element of the group shall be loaded individualy.
if( elem == 0 )
- SkipLoad = true;
+ //SkipLoad = true; // modif sauvage JPR
+ // On charge la longueur du groupe
+ // quand l'element 0x0000 est présent !
if ( SkipLoad ) {
// FIXME the following skip is not necessary
}
// Values bigger than specified are not loaded.
+ //
+ // En fait, c'est les elements dont la longueur est superieure
+ // a celle fixee qui ne sont pas charges
+ //
if (length > MaxSizeLoadElementValue) {
ostringstream s;
s << "gdcm::NotLoaded.";
}
// FIXME The exact size should be length if we move to strings or whatever
- char* NewValue = (char*)g_malloc(length+1);
+
+ //
+ // QUESTION : y a-t-il une raison pour ne pas utiliser g_malloc ici ?
+ //
+
+ char* NewValue = (char*)malloc(length+1);
if( !NewValue) {
dbg.Verbose(1, "LoadElementValue: Failed to allocate NewValue");
return;
item_read = fread(NewValue, (size_t)length, (size_t)1, fp);
if ( item_read != 1 ) {
- g_free(NewValue);
+ free(NewValue);
Error::FileReadError(fp, "gdcmHeader::LoadElementValue");
ElVal->SetValue("gdcm::UnRead");
return;
if ( (group == 0x0028) && (element == 0x0005) )
// This tag is retained from ACR/NEMA
// CHECKME Why should "Image Dimensions" be a single integer ?
+ //
+ // "Image Dimensions", c'est en fait le 'nombre de dimensions'
+ // de l'objet ACR-NEMA stocké
+ // 1 : Signal
+ // 2 : Image
+ // 3 : Volume
+ // 4 : Sequence
+ //
+ // DICOM V3 ne retient pas cette information
+ // Par defaut, tout est 'Image',
+ // C'est a l'utilisateur d'explorer l'ensemble des entetes
+ // pour savoir à quoi il a a faire
+ //
+ // Le Dicom Multiframe peut etre utilise pour stocker,
+ // dans un seul fichier, une serie temporelle (cardio vasculaire GE, p.ex)
+ // ou un volume (medecine Nucleaire, p.ex)
+ //
return true;
if ( (group == 0x0028) && (element == 0x0200) )
guint16 grPixel;
guint16 numPixel;
string ImageLocation = GetPubElValByName("Image Location");
- if ( ImageLocation == "UNFOUND" ) {
- grPixel = 0x7FE0;
+ if ( ImageLocation == "gdcm::Unfound" ) {
+ grPixel = 0x7fe0;
} else {
grPixel = (guint16) atoi( ImageLocation.c_str() );
}
numPixel = 0x1010;
else
numPixel = 0x0010;
- ElValue* PixelElement = PubElVals.GetElement(grPixel, numPixel);
+ ElValue* PixelElement = PubElVals.GetElementByNumber(grPixel, numPixel);
if (PixelElement)
return PixelElement->GetOffset();
else
}
gdcmDictEntry * gdcmHeader::IsInDicts(guint32 group, guint32 element) {
+ //
+ // Y a-t-il une raison de lui passer des guint32
+ // alors que group et element sont des guint16?
+ //
gdcmDictEntry * found = (gdcmDictEntry*)0;
if (!RefPubDict && !RefShaDict) {
//FIXME build a default dictionary !
return found;
}
+list<string> * gdcmHeader::GetPubTagNames(void) {
+ list<string> * Result = new list<string>;
+ TagHT entries = RefPubDict->GetEntries();
+
+ for (TagHT::iterator tag = entries.begin(); tag != entries.end(); ++tag){
+ Result->push_back( tag->second->GetName() );
+ }
+ return Result;
+}
+
+map<string, list<string> > * gdcmHeader::GetPubTagNamesByCategory(void) {
+ map<string, list<string> > * Result = new map<string, list<string> >;
+ TagHT entries = RefPubDict->GetEntries();
+
+ for (TagHT::iterator tag = entries.begin(); tag != entries.end(); ++tag){
+ (*Result)[tag->second->GetFourth()].push_back(tag->second->GetName());
+ }
+ return Result;
+}
+
string gdcmHeader::GetPubElValByNumber(guint16 group, guint16 element) {
- return PubElVals.GetElValue(group, element);
+ return PubElVals.GetElValueByNumber(group, element);
+}
+
+string gdcmHeader::GetPubElValRepByNumber(guint16 group, guint16 element) {
+ ElValue* elem = PubElVals.GetElementByNumber(group, element);
+ if ( !elem )
+ return "gdcm::Unfound";
+ return elem->GetVR();
}
string gdcmHeader::GetPubElValByName(string TagName) {
- return PubElVals.GetElValue(TagName);
+ return PubElVals.GetElValueByName(TagName);
+}
+
+string gdcmHeader::GetPubElValRepByName(string TagName) {
+ ElValue* elem = PubElVals.GetElementByName(TagName);
+ if ( !elem )
+ return "gdcm::Unfound";
+ return elem->GetVR();
+}
+
+string gdcmHeader::GetShaElValByNumber(guint16 group, guint16 element) {
+ return ShaElVals.GetElValueByNumber(group, element);
+}
+
+string gdcmHeader::GetShaElValRepByNumber(guint16 group, guint16 element) {
+ ElValue* elem = ShaElVals.GetElementByNumber(group, element);
+ if ( !elem )
+ return "gdcm::Unfound";
+ return elem->GetVR();
+}
+
+string gdcmHeader::GetShaElValByName(string TagName) {
+ return ShaElVals.GetElValueByName(TagName);
+}
+
+string gdcmHeader::GetShaElValRepByName(string TagName) {
+ ElValue* elem = ShaElVals.GetElementByName(TagName);
+ if ( !elem )
+ return "gdcm::Unfound";
+ return elem->GetVR();
+}
+
+
+string gdcmHeader::GetElValByNumber(guint16 group, guint16 element) {
+ string pub = GetPubElValByNumber(group, element);
+ if (pub.length())
+ return pub;
+ return GetShaElValByNumber(group, element);
+}
+
+string gdcmHeader::GetElValRepByNumber(guint16 group, guint16 element) {
+ string pub = GetPubElValRepByNumber(group, element);
+ if (pub.length())
+ return pub;
+ return GetShaElValRepByNumber(group, element);
+}
+
+string gdcmHeader::GetElValByName(string TagName) {
+ string pub = GetPubElValByName(TagName);
+ if (pub.length())
+ return pub;
+ return GetShaElValByName(TagName);
+}
+
+string gdcmHeader::GetElValRepByName(string TagName) {
+ string pub = GetPubElValRepByName(TagName);
+ if (pub.length())
+ return pub;
+ return GetShaElValRepByName(TagName);
+}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Modifie la valeur d'un ElValue déja existant
+ * \ dans le PubElVals du gdcmHeader,
+ * \ accédé par ses numero de groupe et d'element.
+ */
+int gdcmHeader::SetPubElValByNumber(string content, guint16 group, guint16 element) {
+ //TagKey key = gdcmDictEntry::TranslateToKey(group, element);
+ //PubElVals.tagHt[key]->SetValue(content);
+
+ return ( PubElVals.SetElValueByNumber (content, group, element) );
+}
+
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Modifie la valeur d'un ElValue déja existant
+ * \ dans le PubElVals du gdcmHeader,
+ * \ accédé par son nom
+ */
+int gdcmHeader::SetPubElValByName(string content, string TagName) {
+ //TagKey key = gdcmDictEntry::TranslateToKey(group, element);
+ //PubElVals.tagHt[key]->SetValue(content);
+
+ return ( PubElVals.SetElValueByName (content, TagName) );
}
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Modifie la valeur d'un ElValue déja existant
+ * \ dans le ShaElVals du gdcmHeader,
+ * \ accédé par ses numero de groupe et d'element.
+ */
+int gdcmHeader::SetShaElValByNumber(string content, guint16 group, guint16 element) {
+
+ return ( ShaElVals.SetElValueByNumber (content, group, element) );
+}
+
+
+/**
+ * \ingroup gdcmHeader
+ * \brief Modifie la valeur d'un ElValue déja existant
+ * \ dans le ShaElVals du gdcmHeader,
+ * \ accédé par son nom
+ */
+int gdcmHeader::SetShaElValByName(string content, string TagName) {
+
+ return ( ShaElVals.SetElValueByName (content, TagName) );
+}
/**
* \ingroup gdcmHeader
* \brief Parses the header of the file but does NOT load element values.
* public tag based hash table.
*/
void gdcmHeader::LoadElements(void) {
- rewind(fp);
+
+ rewind(fp);
+
TagElValueHT ht = PubElVals.GetTagHt();
- for (TagElValueHT::iterator tag = ht.begin(); tag != ht.end(); ++tag)
+
+ for (TagElValueHT::iterator tag = ht.begin(); tag != ht.end(); ++tag) {
LoadElementValue(tag->second);
+ }
}
void gdcmHeader::PrintPubElVal(ostream & os) {