-// $Header: /cvs/public/gdcm/src/Attic/gdcmHeader.cxx,v 1.84 2003/09/18 09:32:15 regrain Exp $
+// $Header: /cvs/public/gdcm/src/Attic/gdcmHeader.cxx,v 1.86 2003/09/24 13:00:59 jpr Exp $
//This is needed when compiling in debug mode
#ifdef _MSC_VER
#include <sstream>
#include "gdcmUtil.h"
#include "gdcmHeader.h"
-using namespace std;
#include "gdcmTS.h"
-
-// TODO : remove DEBUG
-#define DEBUG 0
-
// Refer to gdcmHeader::CheckSwap()
#define HEADER_LENGTH_TO_READ 256
// Refer to gdcmHeader::SetMaxSizeLoadElementValue()
return;
char VR[3];
- string vr;
+ std::string vr;
int lgrLue;
char msg[100]; // for sprintf. Sorry
lgrLue=fread (&VR, (size_t)2,(size_t)1, fp);
VR[2]=0;
- vr = string(VR);
+ vr = std::string(VR);
// 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
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2" )
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2.1" )
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2.1.99" )
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2.2" ) //1.2.2 ??? A verifier !
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2.4.50" )
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2.4.51" )
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2.4.52" )
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2.4.53" )
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( Transfer == "1.2.840.10008.1.2.5" )
return true;
return false;
if ( !Element )
return false;
LoadElementValueSafe(Element);
- string Transfer = Element->GetValue();
+ std::string Transfer = Element->GetValue();
if ( (Transfer == "1.2.840.10008.1.2.4.90")
|| (Transfer == "1.2.840.10008.1.2.4.91") )
return true;
void gdcmHeader::FindLength (gdcmElValue * ElVal) {
guint16 element = ElVal->GetElement();
guint16 group = ElVal->GetGroup();
- string vr = ElVal->GetVR();
+ std::string vr = ElVal->GetVR();
guint16 length16;
if( (element == 0x0010) && (group == 0x7fe0) ) {
dbg.SetDebug(0);
void gdcmHeader::LoadElementValue(gdcmElValue * ElVal) {
size_t item_read;
guint16 group = ElVal->GetGroup();
- string vr = ElVal->GetVR();
+ std::string vr = ElVal->GetVR();
guint32 length = ElVal->GetLength();
bool SkipLoad = false;
* @param Elem
* \return integer acts as a boolean
*/
-int gdcmHeader::ReplaceOrCreateByNumber(string Value, guint16 Group, guint16 Elem ) {
+int gdcmHeader::ReplaceOrCreateByNumber(std::string Value, guint16 Group, guint16 Elem ) {
// TODO : FIXME JPRx
// curieux, non ?
gdcmElValue* nvElValue=NewElValueByNumber(Group, Elem);
PubElValSet.Add(nvElValue);
- string v = Value;
+ std::string v = Value;
PubElValSet.SetElValueByNumber(v, Group, Elem);
return(1);
}
int gdcmHeader::ReplaceIfExistByNumber(char* Value, guint16 Group, guint16 Elem ) {
gdcmElValue* elValue = PubElValSet.GetElementByNumber(Group, Elem);
- string v = Value;
+ std::string v = Value;
PubElValSet.SetElValueByNumber(v, Group, Elem);
return 1;
}
* a default one when absent.
* @param Name Name of the underlying DictEntry
*/
-gdcmElValue* gdcmHeader::NewElValueByName(string Name) {
+gdcmElValue* gdcmHeader::NewElValueByName(std::string Name) {
gdcmDictEntry * NewTag = GetDictEntryByName(Name);
if (!NewTag)
n = ReadInt16();
if ( (g==0x7fe0) && (n==0x0010) )
- if (DEBUG)
- printf("in gdcmHeader::ReadNextElement try to read 7fe0 0010 \n");
if (errno == 1)
// We reached the EOF (or an error occured) and header parsing
FindLength(NewElVal);
if (errno == 1) {
// Call it quits
- if (DEBUG) printf("in gdcmHeader::ReadNextElement : g %04x n %04x errno %d\n",g, n, errno);
return (gdcmElValue *)0;
}
NewElVal->SetOffset(ftell(fp));
if ( (g==0x7fe0) && (n==0x0010) )
- if (DEBUG)
- printf("sortie de gdcmHeader::ReadNextElement 7fe0 0010 \n");
return NewElVal;
}
bool gdcmHeader::IsAnInteger(gdcmElValue * ElVal) {
guint16 group = ElVal->GetGroup();
guint16 element = ElVal->GetElement();
- string vr = ElVal->GetVR();
+ std::string vr = ElVal->GetVR();
guint32 length = ElVal->GetLength();
// When we have some semantics on the element we just read, and if we
if (length == 4)
return true;
else {
- if (DEBUG) printf("Erroneous Group Length element length (%04x , %04x) : %d\n",
- group, element,length);
-
dbg.Error("gdcmHeader::IsAnInteger",
"Erroneous Group Length element length.");
}
// When the "Image Location" is absent we default to group 0x7fe0.
guint16 grPixel;
guint16 numPixel;
- string ImageLocation = GetPubElValByName("Image Location");
+ std::string ImageLocation = GetPubElValByName("Image Location");
if ( ImageLocation == GDCM_UNFOUND ) {
grPixel = 0x7fe0;
} else {
* @param Name name of the searched DictEntry
* @return Corresponding DictEntry when it exists, NULL otherwise.
*/
-gdcmDictEntry * gdcmHeader::GetDictEntryByName(string Name) {
+gdcmDictEntry * gdcmHeader::GetDictEntryByName(std::string Name) {
gdcmDictEntry * found = (gdcmDictEntry*)0;
if (!RefPubDict && !RefShaDict) {
dbg.Verbose(0, "gdcmHeader::GetDictEntry",
* @return Corresponding element value when it exists, and the string
* GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetPubElValByNumber(guint16 group, guint16 element) {
+std::string gdcmHeader::GetPubElValByNumber(guint16 group, guint16 element) {
return PubElValSet.GetElValueByNumber(group, element);
}
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetPubElValRepByNumber(guint16 group, guint16 element) {
+std::string gdcmHeader::GetPubElValRepByNumber(guint16 group, guint16 element) {
gdcmElValue* elem = PubElValSet.GetElementByNumber(group, element);
if ( !elem )
return GDCM_UNFOUND;
* @return Corresponding element value when it exists, and the string
* GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetPubElValByName(string TagName) {
+std::string gdcmHeader::GetPubElValByName(std::string TagName) {
return PubElValSet.GetElValueByName(TagName);
}
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetPubElValRepByName(string TagName) {
+std::string gdcmHeader::GetPubElValRepByName(std::string TagName) {
gdcmElValue* elem = PubElValSet.GetElementByName(TagName);
if ( !elem )
return GDCM_UNFOUND;
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetShaElValByNumber(guint16 group, guint16 element) {
+std::string gdcmHeader::GetShaElValByNumber(guint16 group, guint16 element) {
return ShaElValSet.GetElValueByNumber(group, element);
}
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetShaElValRepByNumber(guint16 group, guint16 element) {
+std::string gdcmHeader::GetShaElValRepByNumber(guint16 group, guint16 element) {
gdcmElValue* elem = ShaElValSet.GetElementByNumber(group, element);
if ( !elem )
return GDCM_UNFOUND;
* @return Corresponding element value when it exists, and the string
* GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetShaElValByName(string TagName) {
+std::string gdcmHeader::GetShaElValByName(std::string TagName) {
return ShaElValSet.GetElValueByName(TagName);
}
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetShaElValRepByName(string TagName) {
+std::string gdcmHeader::GetShaElValRepByName(std::string TagName) {
gdcmElValue* elem = ShaElValSet.GetElementByName(TagName);
if ( !elem )
return GDCM_UNFOUND;
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetElValByNumber(guint16 group, guint16 element) {
- string pub = GetPubElValByNumber(group, element);
+std::string gdcmHeader::GetElValByNumber(guint16 group, guint16 element) {
+ std::string pub = GetPubElValByNumber(group, element);
if (pub.length())
return pub;
return GetShaElValByNumber(group, element);
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetElValRepByNumber(guint16 group, guint16 element) {
- string pub = GetPubElValRepByNumber(group, element);
+std::string gdcmHeader::GetElValRepByNumber(guint16 group, guint16 element) {
+ std::string pub = GetPubElValRepByNumber(group, element);
if (pub.length())
return pub;
return GetShaElValRepByNumber(group, element);
* @return Corresponding element value when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetElValByName(string TagName) {
- string pub = GetPubElValByName(TagName);
+std::string gdcmHeader::GetElValByName(std::string TagName) {
+ std::string pub = GetPubElValByName(TagName);
if (pub.length())
return pub;
return GetShaElValByName(TagName);
* @return Corresponding element value representation when it exists,
* and the string GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetElValRepByName(string TagName) {
- string pub = GetPubElValRepByName(TagName);
+std::string gdcmHeader::GetElValRepByName(std::string TagName) {
+ std::string pub = GetPubElValRepByName(TagName);
if (pub.length())
return pub;
return GetShaElValRepByName(TagName);
* @param group group of the ElVal to modify
* @param element element of the ElVal to modify
*/
-int gdcmHeader::SetPubElValByNumber(string content, guint16 group,
+int gdcmHeader::SetPubElValByNumber(std::string content, guint16 group,
guint16 element)
//TODO : homogeneiser les noms : SetPubElValByNumber qui appelle PubElValSet.SetElValueByNumber
* @param content new value to substitute with
* @param TagName name of the tag to be modified
*/
-int gdcmHeader::SetPubElValByName(string content, string TagName) {
+int gdcmHeader::SetPubElValByName(std::string content, std::string TagName) {
return ( PubElValSet.SetElValueByName (content, TagName) );
}
* @param element element of the ElVal to modify
* @return 1 on success, 0 otherwise.
*/
-int gdcmHeader::SetShaElValByNumber(string content,
+int gdcmHeader::SetShaElValByNumber(std::string content,
guint16 group, guint16 element) {
return ( ShaElValSet.SetElValueByNumber (content, group, element) );
}
* @param content new value to substitute with
* @param ShadowTagName name of the tag to be modified
*/
-int gdcmHeader::SetShaElValByName(string content, string ShadowTagName) {
+int gdcmHeader::SetShaElValByName(std::string content, std::string ShadowTagName) {
return ( ShaElValSet.SetElValueByName (content, ShadowTagName) );
}
* @param VR The Value Representation to be given to this new tag.
* @ return The newly hand crafted Element Value.
*/
-gdcmElValue* gdcmHeader::NewManualElValToPubDict(string NewTagName, string VR) {
+gdcmElValue* gdcmHeader::NewManualElValToPubDict(std::string NewTagName, std::string VR) {
gdcmElValue* NewElVal = (gdcmElValue*)0;
guint32 StuffGroup = 0xffff; // Group to be stuffed with additional info
guint32 FreeElem = 0;
rewind(fp);
// Load 'non string' values
- string PhotometricInterpretation = GetPubElValByNumber(0x0028,0x0004);
+ std::string PhotometricInterpretation = GetPubElValByNumber(0x0028,0x0004);
if( PhotometricInterpretation == "PALETTE COLOR " ){
LoadElementVoidArea(0x0028,0x1200); // gray LUT
LoadElementVoidArea(0x0028,0x1201); // R LUT
// if recognition code tells us we deal with a LibIDO image
// we switch lineNumber and columnNumber
//
- string RecCode;
+ std::string RecCode;
RecCode = GetPubElValByNumber(0x0008, 0x0010);
if (RecCode == "ACRNEMA_LIBIDO_1.1" ||
RecCode == "CANRME_AILIBOD1_1." ) {
void * a = malloc(l);
if(!a) {
cout << "Big Broblem (LoadElementVoidArea, malloc) "
- << hex << Group << " " << Elem << "\n";
+ << hex << Group << " " << Elem << std::endl;
return NULL;
}
int res = PubElValSet.SetVoidAreaByNumber(a, Group, Elem);
size_t l2 = fread(a, 1, l ,fp);
if(l != l2) {
cout << "Big Broblem (LoadElementVoidArea, fread) "
- << hex << Group << " " << Elem << "\n";
+ << hex << Group << " " << Elem << std::endl;
free(a);
return NULL;
}
int gdcmHeader::GetXSize(void) {
// We cannot check for "Columns" because the "Columns" tag is present
// both in IMG (0028,0011) and OLY (6000,0011) sections of the dictionary.
- string StrSize = GetPubElValByNumber(0x0028,0x0011);
+ std::string StrSize = GetPubElValByNumber(0x0028,0x0011);
if (StrSize == GDCM_UNFOUND)
return 0;
return atoi(StrSize.c_str());
int gdcmHeader::GetYSize(void) {
// We cannot check for "Rows" because the "Rows" tag is present
// both in IMG (0028,0010) and OLY (6000,0010) sections of the dictionary.
- string StrSize = GetPubElValByNumber(0x0028,0x0010);
+ std::string StrSize = GetPubElValByNumber(0x0028,0x0010);
if (StrSize != GDCM_UNFOUND)
return atoi(StrSize.c_str());
if ( IsDicomV3() )
int gdcmHeader::GetZSize(void) {
// Both in DicomV3 and ACR/Nema the consider the "Number of Frames"
// as the third dimension.
- string StrSize = GetPubElValByNumber(0x0028,0x0008);
+ std::string StrSize = GetPubElValByNumber(0x0028,0x0008);
if (StrSize != GDCM_UNFOUND)
return atoi(StrSize.c_str());
* @return The encountered number of Bits Stored, 0 by default.
*/
int gdcmHeader::GetBitsStored(void) {
- string StrSize = GetPubElValByNumber(0x0028,0x0101);
+ std::string StrSize = GetPubElValByNumber(0x0028,0x0101);
if (StrSize == GDCM_UNFOUND)
return 1;
return atoi(StrSize.c_str());
* @return The encountered number of Samples Per Pixel, 1 by default.
*/
int gdcmHeader::GetSamplesPerPixel(void) {
- string StrSize = GetPubElValByNumber(0x0028,0x0002);
+ std::string StrSize = GetPubElValByNumber(0x0028,0x0002);
if (StrSize == GDCM_UNFOUND)
return 1; // Well, it's supposed to be mandatory ...
return atoi(StrSize.c_str());
* @return The encountered Planar Configuration, 0 by default.
*/
int gdcmHeader::GetPlanarConfiguration(void) {
- string StrSize = GetPubElValByNumber(0x0028,0x0006);
+ std::string StrSize = GetPubElValByNumber(0x0028,0x0006);
if (StrSize == GDCM_UNFOUND)
return 0;
return atoi(StrSize.c_str());
*
*/
int gdcmHeader::GetPixelSize(void) {
- string PixelType = GetPixelType();
+ std::string PixelType = GetPixelType();
if (PixelType == "8U" || PixelType == "8S")
return 1;
if (PixelType == "16U" || PixelType == "16S")
* \warning 12 bit images appear as 16 bit.
* @return
*/
-string gdcmHeader::GetPixelType(void) {
- string BitsAlloc;
+std::string gdcmHeader::GetPixelType(void) {
+ std::string BitsAlloc;
BitsAlloc = GetElValByName("Bits Allocated");
if (BitsAlloc == GDCM_UNFOUND) {
dbg.Verbose(0, "gdcmHeader::GetPixelType: unfound Bits Allocated");
- BitsAlloc = string("16");
+ BitsAlloc = std::string("16");
}
if (BitsAlloc == "12")
- BitsAlloc = string("16");
+ BitsAlloc = std::string("16");
- string Signed;
+ std::string Signed;
Signed = GetElValByName("Pixel Representation");
if (Signed == GDCM_UNFOUND) {
dbg.Verbose(0, "gdcmHeader::GetPixelType: unfound Pixel Representation");
- BitsAlloc = string("0");
+ BitsAlloc = std::string("0");
}
if (Signed == "0")
- Signed = string("U");
+ Signed = std::string("U");
else
- Signed = string("S");
+ Signed = std::string("S");
return( BitsAlloc + Signed);
}
* \ else 1.
* @return Transfert Syntax Name (as oposite to Transfert Syntax UID)
*/
-string gdcmHeader::GetTransferSyntaxName(void) {
- string TransfertSyntax = GetPubElValByNumber(0x0002,0x0010);
+std::string gdcmHeader::GetTransferSyntaxName(void) {
+ std::string TransfertSyntax = GetPubElValByNumber(0x0002,0x0010);
if (TransfertSyntax == GDCM_UNFOUND) {
dbg.Verbose(0, "gdcmHeader::GetTransferSyntaxName: unfound Transfert Syntax (0002,0010)");
return "Uncompressed ACR-NEMA";
}
// we do it only when we need it
gdcmTS * ts = gdcmGlobal::GetTS();
- string tsName=ts->GetValue(TransfertSyntax);
+ std::string tsName=ts->GetValue(TransfertSyntax);
//delete ts; // Seg Fault when deleted ?!
return tsName;
}
*/
int gdcmHeader::GetLUTLength(void) {
- vector<string> tokens;
+ vector<std::string> tokens;
int LutLength;
//int LutDepth;
//int LutNbits;
// Just hope Lookup Table Desc-Red = Lookup Table Desc-Red = Lookup Table Desc-Blue
- string LutDescriptionR = GetPubElValByNumber(0x0028,0x1101);
+ std::string LutDescriptionR = GetPubElValByNumber(0x0028,0x1101);
if (LutDescriptionR == GDCM_UNFOUND)
return 0;
- string LutDescriptionG = GetPubElValByNumber(0x0028,0x1102);
+ std::string LutDescriptionG = GetPubElValByNumber(0x0028,0x1102);
if (LutDescriptionG == GDCM_UNFOUND)
return 0;
- string LutDescriptionB = GetPubElValByNumber(0x0028,0x1103);
+ std::string LutDescriptionB = GetPubElValByNumber(0x0028,0x1103);
if (LutDescriptionB == GDCM_UNFOUND)
return 0;
if( (LutDescriptionR != LutDescriptionG) || (LutDescriptionR != LutDescriptionB) ) {
dbg.Verbose(0, "gdcmHeader::GetLUTLength: The CLUT R,G,B are not equal");
return 0;
}
- cout << "Lut Description " << LutDescriptionR <<"\n";
+ cout << "Lut Description " << LutDescriptionR <<std::endl;
tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
Tokenize (LutDescriptionR, tokens, "\\");
LutLength=atoi(tokens[0].c_str());
*/
int gdcmHeader::GetLUTNbits(void) {
- vector<string> tokens;
+ vector<std::string> tokens;
//int LutLength;
//int LutDepth;
int LutNbits;
// Just hope Lookup Table Desc-Red = Lookup Table Desc-Red = Lookup Table Desc-Blue
// Consistency already checked in GetLUTLength
- string LutDescription = GetPubElValByNumber(0x0028,0x1101);
+ std::string LutDescription = GetPubElValByNumber(0x0028,0x1101);
if (LutDescription == GDCM_UNFOUND)
return 0;
tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
unsigned char * g = (unsigned char *)LutG;
unsigned char * b = (unsigned char *)LutB;
for(int i=0;i<l;i++) {
- //cout << "lut16 " << i << " : " << *r << " " << *g << " " << *b << "\n";
+ //cout << "lut16 " << i << " : " << *r << " " << *g << " " << *b << std::endl;
printf("lut 8 %d : %d %d %d \n",i,*r,*g,*b);
*rgb++ = *r++;
*rgb++ = *g++;
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff