+// $Header: /cvs/public/gdcm/src/Attic/gdcmHeader.cxx,v 1.96 2003/10/09 13:22:54 jpr Exp $
-// $Header: /cvs/public/gdcm/src/Attic/gdcmHeader.cxx,v 1.80 2003/07/28 12:21:09 malaterre Exp $
+#include "gdcmHeader.h"
#include <stdio.h>
#include <cerrno>
#include <cctype> // for isalpha
#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()
void gdcmHeader::Initialise(void) {
dicom_vr = gdcmGlobal::GetVR();
dicom_ts = gdcmGlobal::GetTS();
- Dicts = gdcmGlobal::GetDicts();
+ Dicts = gdcmGlobal::GetDicts();
RefPubDict = Dicts->GetDefaultPubDict();
RefShaDict = (gdcmDict*)0;
}
* \brief Canonical destructor.
*/
gdcmHeader::~gdcmHeader (void) {
- dicom_vr = (gdcmVR*)0;
- Dicts = (gdcmDictSet*)0;
- RefPubDict = (gdcmDict*)0;
- RefShaDict = (gdcmDict*)0;
- return;
+ dicom_vr = (gdcmVR*)0;
+ Dicts = (gdcmDictSet*)0;
+ RefPubDict = (gdcmDict*)0;
+ RefShaDict = (gdcmDict*)0;
+ return;
}
// Fourth semantics:
+//
+// ---> Warning : This fourth fiels 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
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
// 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());
+ sprintf(msg,"Falsely explicit vr file (%04x,%04x)\n",
+ ElVal->GetGroup(),ElVal->GetElement());
dbg.Verbose(1, "gdcmHeader::FindVR: ",msg);
fseek(fp, PositionOnEntry, SEEK_SET);
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;
const char * Transfert = Element->GetValue().c_str();
if ( memcmp(Transfert+strlen(Transfert)-2 ,"70",2)==0) return true;
if ( memcmp(Transfert+strlen(Transfert)-2 ,"55",2)==0) return true;
+ if (Element->GetValue() == "1.2.840.10008.1.2.4.57") 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::FixFoundLength(gdcmElValue * ElVal, guint32 FoundLength) {
if ( FoundLength == 0xffffffff)
FoundLength = 0;
+ // Sorry for the patch!
+ // XMedCom did the trick to read some nasty GE images ...
+ if (FoundLength == 13)
+ // The following 'if' will be removed when there is no more
+ // images on Creatis HD with a 13 length for Manufacturer...
+ if ( (ElVal->GetGroup() != 0x0008) || (ElVal->GetElem() )
+ // end of remove area
+ FoundLength =10;
+
ElVal->SetLength(FoundLength);
}
FoundSequenceDelimiter = true;
else if ( n != 0xe000 ){
char msg[100]; // for sprintf. Sorry
- sprintf(msg,"wrong element (%04x) for an item sequence (%04x,%04x)\n",n, g,n);
+ sprintf(msg,"wrong element (%04x) for an item sequence (%04x,%04x)\n",
+ n, g,n);
dbg.Verbose(1, "gdcmHeader::FindLengthOB: ",msg);
errno = 1;
return 0;
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);
dbg.Verbose(2, "gdcmHeader::FindLength: ",
- "on est sur 7fe0 0010");
+ "we reached 7fe0 0010");
}
if ( (filetype == ExplicitVR) && ! ElVal->IsImplicitVr() ) {
fseek(fp, 2L, SEEK_CUR);
guint32 length32 = ReadInt32();
+
if ( (vr == "OB") && (length32 == 0xffffffff) ) {
ElVal->SetLength(FindLengthOB());
return;
// Heuristic: well some files are really ill-formed.
if ( length16 == 0xffff) {
length16 = 0;
- dbg.Verbose(0, "gdcmHeader::FindLength",
- "Erroneous element length fixed.");
+ //dbg.Verbose(0, "gdcmHeader::FindLength",
+ // "Erroneous element length fixed.");
+ // Actually, length= 0xffff means that we deal with
+ // Unknown Sequence Length
}
+
FixFoundLength(ElVal, (guint32)length16);
return;
}
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;
// are not loaded. Instead we leave a short notice of the offset of
// the element content and it's length.
if (length > MaxSizeLoadElementValue) {
- ostringstream s;
+ std::ostringstream s;
s << "gdcm::NotLoaded.";
s << " Address:" << (long)ElVal->GetOffset();
s << " Length:" << ElVal->GetLength();
if ( IsAnInteger(ElVal) ) {
guint32 NewInt;
- ostringstream s;
+ std::ostringstream s;
int nbInt;
if (vr == "US" || vr == "SS") {
nbInt = length / 2;
* @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 ?
// on l'ajoute au ElValSet
// on affecte une valeur a cette ElValue a l'interieur du ElValSet
// --> devrait pouvoir etre fait + simplement ???
-
- gdcmElValue* nvElValue=NewElValueByNumber(Group, Elem);
- PubElValSet.Add(nvElValue);
+ if (CheckIfExistByNumber(Group, Elem) == 0) {
+ gdcmElValue* a =NewElValueByNumber(Group, Elem);
+ if (a == NULL)
+ return 0;
+ PubElValSet.Add(a);
+ }
PubElValSet.SetElValueByNumber(Value, Group, Elem);
return(1);
}
/**
* \ingroup gdcmHeader
- * \brief Modify or (Creates if not found) an element
+ * \brief Modify (or Creates if not found) an element
* @param Value new value
* @param Group
* @param Elem
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)
g = ReadInt16();
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
// has to be considered as finished.
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");
+ //if ( (g==0x7fe0) && (n==0x0010) )
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");
- if ( ImageLocation == "gdcm::Unfound" ) {
+ std::string ImageLocation = GetPubElValByName("Image Location");
+ if ( ImageLocation == GDCM_UNFOUND ) {
grPixel = 0x7fe0;
} else {
grPixel = (guint16) atoi( ImageLocation.c_str() );
* @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",
* @param group Group of the researched tag.
* @param element Element of the researched tag.
* @return Corresponding element value when it exists, and the string
- * "gdcm::Unfound" otherwise.
+ * 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);
}
* @param group Group of the researched tag.
* @param element Element of the researched tag.
* @return Corresponding element value representation when it exists,
- * and the string "gdcm::Unfound" otherwise.
+ * 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 GDCM_UNFOUND;
return elem->GetVR();
}
* a given tag.
* @param TagName name of the researched element.
* @return Corresponding element value when it exists, and the string
- * "gdcm::Unfound" otherwise.
+ * GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetPubElValByName(string TagName) {
+std::string gdcmHeader::GetPubElValByName(std::string TagName) {
return PubElValSet.GetElValueByName(TagName);
}
* of semantics than just the native C++ type.
* @param TagName name of the researched element.
* @return Corresponding element value representation when it exists,
- * and the string "gdcm::Unfound" otherwise.
+ * 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 GDCM_UNFOUND;
return elem->GetVR();
}
* @param group Group of the researched tag.
* @param element Element of the researched tag.
* @return Corresponding element value representation when it exists,
- * and the string "gdcm::Unfound" otherwise.
+ * 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);
}
* @param group Group of the researched tag.
* @param element Element of the researched tag.
* @return Corresponding element value representation when it exists,
- * and the string "gdcm::Unfound" otherwise.
+ * 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 GDCM_UNFOUND;
return elem->GetVR();
}
* for an element value of given tag.
* @param TagName name of the researched element.
* @return Corresponding element value when it exists, and the string
- * "gdcm::Unfound" otherwise.
+ * GDCM_UNFOUND ("gdcm::Unfound") otherwise.
*/
-string gdcmHeader::GetShaElValByName(string TagName) {
+std::string gdcmHeader::GetShaElValByName(std::string TagName) {
return ShaElValSet.GetElValueByName(TagName);
}
* of semantics than just the native C++ type.
* @param TagName name of the researched element.
* @return Corresponding element value representation when it exists,
- * and the string "gdcm::Unfound" otherwise.
+ * 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 GDCM_UNFOUND;
return elem->GetVR();
}
* @param group Group of the researched tag.
* @param element Element of the researched tag.
* @return Corresponding element value representation when it exists,
- * and the string "gdcm::Unfound" otherwise.
+ * 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);
* @param group Group of the researched tag.
* @param element Element of the researched tag.
* @return Corresponding element value representation when it exists,
- * and the string "gdcm::Unfound" otherwise.
+ * 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);
* for the element value of a given tag.
* @param TagName name of the researched element.
* @return Corresponding element value when it exists,
- * and the string "gdcm::Unfound" otherwise.
+ * 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);
* of semantics than just the native C++ type.
* @param TagName name of the researched element.
* @return Corresponding element value representation when it exists,
- * and the string "gdcm::Unfound" otherwise.
+ * 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
+//TODO : homogeneiser les noms : SetPubElValByNumber
+// qui appelle PubElValSet.SetElValueByNumber
// pourquoi pas SetPubElValueByNumber ??
{
* @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) );
}
* false otherwise.
*/
bool gdcmHeader::IsReadable(void) {
- if ( GetElValByName("Image Dimensions") != "gdcm::Unfound"
+ if ( GetElValByName("Image Dimensions") != GDCM_UNFOUND
&& atoi(GetElValByName("Image Dimensions").c_str()) > 4 ) {
return false;
}
- if ( GetElValByName("Bits Allocated") == "gdcm::Unfound" )
+ if ( GetElValByName("Bits Allocated") == GDCM_UNFOUND )
return false;
- if ( GetElValByName("Bits Stored") == "gdcm::Unfound" )
+ if ( GetElValByName("Bits Stored") == GDCM_UNFOUND )
return false;
- if ( GetElValByName("High Bit") == "gdcm::Unfound" )
+ if ( GetElValByName("High Bit") == GDCM_UNFOUND )
return false;
- if ( GetElValByName("Pixel Representation") == "gdcm::Unfound" )
+ if ( GetElValByName("Pixel Representation") == GDCM_UNFOUND )
return false;
return true;
}
* @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;
for (TagElValueHT::iterator tag = ht.begin(); tag != ht.end(); ++tag) {
LoadElementValue(tag->second);
}
- // Load 'non string' values
- rewind(fp);
- string PhotometricInterpretation = GetPubElValByNumber(0x0028,0x0004);
+ rewind(fp);
+
+ // Load 'non string' values
+ std::string PhotometricInterpretation = GetPubElValByNumber(0x0028,0x0004);
if( PhotometricInterpretation == "PALETTE COLOR " ){
LoadElementVoidArea(0x0028,0x1200); // gray LUT
LoadElementVoidArea(0x0028,0x1201); // R LUT
LoadElementVoidArea(0x0028,0x1222); // Segmented Green Palette Color LUT Data
LoadElementVoidArea(0x0028,0x1223); // Segmented Blue Palette Color LUT Data
}
+
+ // --------------------------------------------------------------
+ // Special Patch to allow gdcm to read ACR-LibIDO formated images
+ //
+ // if recognition code tells us we deal with a LibIDO image
+ // we switch lineNumber and columnNumber
+ //
+ std::string RecCode;
+ RecCode = GetPubElValByNumber(0x0008, 0x0010);
+ if (RecCode == "ACRNEMA_LIBIDO_1.1" ||
+ RecCode == "CANRME_AILIBOD1_1." ) {
+ filetype = ACR_LIBIDO;
+ std::string rows = GetPubElValByNumber(0x0028, 0x0010);
+ std::string columns = GetPubElValByNumber(0x0028, 0x0011);
+ SetPubElValByNumber(columns, 0x0028, 0x0010);
+ SetPubElValByNumber(rows , 0x0028, 0x0011);
+ }
+ // ----------------- End of Special Patch ----------------
}
/**
* @return
*/
int gdcmHeader::Write(FILE * fp, FileType type) {
+
+
+ // TODO : move the following lines (and a lot of others)
+ // to a future function CheckAndCorrectHeader
+
+ if (type == ImplicitVR) {
+ std::string implicitVRTransfertSyntax = "1.2.840.10008.1.2";
+ ReplaceOrCreateByNumber(implicitVRTransfertSyntax,0x0002, 0x0010);
+
+ //FIXME Refer to standards on page 21, chapter 6.2 "Value representation":
+ // values with a VR of UI shall be padded with a single trailing null
+ // Dans le cas suivant on doit pader manuellement avec un 0
+
+ PubElValSet.SetElValueLengthByNumber(18, 0x0002, 0x0010);
+ }
+
+ if (type == ExplicitVR) {
+ std::string explicitVRTransfertSyntax = "1.2.840.10008.1.2.1";
+ ReplaceOrCreateByNumber(explicitVRTransfertSyntax,0x0002, 0x0010);
+
+ //FIXME Refer to standards on page 21, chapter 6.2 "Value representation":
+ // values with a VR of UI shall be padded with a single trailing null
+ // Dans le cas suivant on doit pader manuellement avec un 0
+
+ PubElValSet.SetElValueLengthByNumber(20, 0x0002, 0x0010);
+ }
+
return PubElValSet.Write(fp, type);
}
int l=Element->GetLength();
void * a = malloc(l);
if(!a) {
- cout << "Big Broblem (LoadElementVoidArea, malloc) "
- << hex << Group << " " << Elem << "\n";
+ std::cout << "Big Broblem (LoadElementVoidArea, malloc) "
+ << std::hex << Group << " " << Elem << std::endl;
return NULL;
}
int res = PubElValSet.SetVoidAreaByNumber(a, Group, Elem);
// TODO check the result
size_t l2 = fread(a, 1, l ,fp);
if(l != l2) {
- cout << "Big Broblem (LoadElementVoidArea, fread) "
- << hex << Group << " " << Elem << "\n";
+ std::cout << "Big Broblem (LoadElementVoidArea, fread) "
+ << std::hex << Group << " " << Elem << std::endl;
free(a);
return NULL;
}
gdcmElValue* elValue = PubElValSet.GetElementByNumber(Group, Elem);
if (!elValue) {
dbg.Verbose(1, "gdcmHeader::GetElValueByNumber",
- "failed to Locate gdcmElValue");
+ "failed to Locate gdcmElValue");
return (size_t)0;
}
return elValue->GetOffset();
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);
- if (StrSize == "gdcm::Unfound")
+ 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);
- if (StrSize != "gdcm::Unfound")
+ std::string StrSize = GetPubElValByNumber(0x0028,0x0010);
+ if (StrSize != GDCM_UNFOUND)
return atoi(StrSize.c_str());
if ( IsDicomV3() )
return 0;
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);
- if (StrSize != "gdcm::Unfound")
+ std::string StrSize = GetPubElValByNumber(0x0028,0x0008);
+ if (StrSize != GDCM_UNFOUND)
return atoi(StrSize.c_str());
// We then consider the "Planes" entry as the third dimension [we
// cannot retrieve by name since "Planes tag is present both in
// IMG (0028,0012) and OLY (6000,0012) sections of the dictionary].
StrSize = GetPubElValByNumber(0x0028,0x0012);
- if (StrSize != "gdcm::Unfound")
+ if (StrSize != GDCM_UNFOUND)
return atoi(StrSize.c_str());
return 1;
}
* @return The encountered number of Bits Stored, 0 by default.
*/
int gdcmHeader::GetBitsStored(void) {
- string StrSize = GetPubElValByNumber(0x0028,0x0101);
- if (StrSize == "gdcm::Unfound")
+ 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);
- if (StrSize == "gdcm::Unfound")
+ 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);
- if (StrSize == "gdcm::Unfound")
+ 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") {
+ 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") {
+ 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);
}
-/**
- * \ingroup gdcmHeader
- * \brief gets the info from 0028,0030 : Pixel Spacing
- * \ else 1.
- * @return X dimension of a pixel
- */
-float gdcmHeader::GetXSpacing(void) {
- float xspacing, yspacing;
- string StrSpacing = GetPubElValByNumber(0x0028,0x0030);
-
- if (StrSpacing == "gdcm::Unfound") {
- dbg.Verbose(0, "gdcmHeader::GetXSpacing: unfound Pixel Spacing (0028,0030)");
- return 1.;
- }
- if( sscanf( StrSpacing.c_str(), "%f\\%f", &xspacing, &yspacing) != 2)
- return 0.;
- //else
- return xspacing;
-}
-
-/**
- * \ingroup gdcmHeader
- * \brief gets the info from 0028,0030 : Pixel Spacing
- * \ else 1.
- * @return Y dimension of a pixel
- */
-float gdcmHeader::GetYSpacing(void) {
- float xspacing, yspacing;
- string StrSpacing = GetPubElValByNumber(0x0028,0x0030);
-
- if (StrSpacing == "gdcm::Unfound") {
- dbg.Verbose(0, "gdcmHeader::GetYSpacing: unfound Pixel Spacing (0028,0030)");
- return 1.;
- }
- if( sscanf( StrSpacing.c_str(), "%f\\%f", &xspacing, &yspacing) != 2)
- return 0.;
- if (yspacing == 0.) {
- dbg.Verbose(0, "gdcmHeader::GetYSpacing: gdcmData/CT-MONO2-8-abdo.dcm problem");
- // seems to be a bug in the header ...
- sscanf( StrSpacing.c_str(), "%f\\0\\%f", &xspacing, &yspacing);
- }
- return yspacing;
-}
-
-
-/**
- *\ingroup gdcmHeader
- *\brief gets the info from 0018,0088 : Space Between Slices
- *\ else from 0018,0050 : Slice Thickness
- *\ else 1.
- * @return Z dimension of a voxel-to be
- */
-float gdcmHeader::GetZSpacing(void) {
- // TODO : translate into English
- // Spacing Between Slices : distance entre le milieu de chaque coupe
- // Les coupes peuvent etre :
- // jointives (Spacing between Slices = Slice Thickness)
- // chevauchantes (Spacing between Slices < Slice Thickness)
- // disjointes (Spacing between Slices > Slice Thickness)
- // Slice Thickness : epaisseur de tissus sur laquelle est acquis le signal
- // ca interesse le physicien de l'IRM, pas le visualisateur de volumes ...
- // Si le Spacing Between Slices est absent,
- // on suppose que les coupes sont jointives
-
- string StrSpacingBSlices = GetPubElValByNumber(0x0018,0x0088);
-
- if (StrSpacingBSlices == "gdcm::Unfound") {
- dbg.Verbose(0, "gdcmHeader::GetZSpacing: unfound StrSpacingBSlices");
- string StrSliceThickness = GetPubElValByNumber(0x0018,0x0050);
- if (StrSliceThickness == "gdcm::Unfound")
- return 1.;
- else
- // if no 'Spacing Between Slices' is found,
- // we assume slices join together
- // (no overlapping, no interslice gap)
- // if they don't, we're fucked up
- return atof(StrSliceThickness.c_str());
- } else {
- return atof(StrSpacingBSlices.c_str());
- }
-}
-
-//
-// Image Position Patient (0020,0032):
-// If not found (ACR_NEMA) we try Image Position (0020,0030)
-// If not found (ACR-NEMA), we consider Slice Location (0020,1041)
-// or Location (0020,0050)
-// as the Z coordinate,
-// 0. for all the coordinates if nothing is found
-
-// TODO : find a way to inform the caller nothing was found
-// TODO : How to tell the caller a wrong number of values was found?
-
-/**
- * \ingroup gdcmHeader
- * \brief gets the info from 0020,0032 : Image Position Patient
- *\ else from 0020,0030 : Image Position (RET)
- *\ else 0.
- * @return up-left image corner position
- */
-float gdcmHeader::GetXImagePosition(void) {
- float xImPos, yImPos, zImPos;
- string StrImPos = GetPubElValByNumber(0x0020,0x0032);
-
- if (StrImPos == "gdcm::Unfound") {
- dbg.Verbose(0, "gdcmHeader::GetXImagePosition: unfound Image Position Patient (0020,0032)");
- StrImPos = GetPubElValByNumber(0x0020,0x0030); // For ACR-NEMA images
- if (StrImPos == "gdcm::Unfound") {
- dbg.Verbose(0, "gdcmHeader::GetXImagePosition: unfound Image Position (RET) (0020,0030)");
- // How to tell the caller nothing was found ?
- return 0.;
- }
- }
- if( sscanf( StrImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3)
- return 0.;
- return xImPos;
-}
-
-/**
- * \ingroup gdcmHeader
- * \brief gets the info from 0020,0032 : Image Position Patient
- * \ else from 0020,0030 : Image Position (RET)
- * \ else 0.
- * @return up-left image corner position
- */
-float gdcmHeader::GetYImagePosition(void) {
- float xImPos, yImPos, zImPos;
- string StrImPos = GetPubElValByNumber(0x0020,0x0032);
-
- if (StrImPos == "gdcm::Unfound") {
- dbg.Verbose(0, "gdcmHeader::GetYImagePosition: unfound Image Position Patient (0020,0032)");
- StrImPos = GetPubElValByNumber(0x0020,0x0030); // For ACR-NEMA images
- if (StrImPos == "gdcm::Unfound") {
- dbg.Verbose(0, "gdcmHeader::GetYImagePosition: unfound Image Position (RET) (0020,0030)");
- // How to tell the caller nothing was found ?
- return 0.;
- }
- }
- if( sscanf( StrImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3)
- return 0.;
- return yImPos;
-}
-
-/**
- * \ingroup gdcmHeader
- * \brief gets the info from 0020,0032 : Image Position Patient
- * \ else from 0020,0030 : Image Position (RET)
- * \ else from 0020,1041 : Slice Location
- * \ else from 0020,0050 : Location
- * \ else 0.
- * @return up-left image corner position
- */
-float gdcmHeader::GetZImagePosition(void) {
- float xImPos, yImPos, zImPos;
- string StrImPos = GetPubElValByNumber(0x0020,0x0032);
- if (StrImPos != "gdcm::Unfound") {
- if( sscanf( StrImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3) {
- dbg.Verbose(0, "gdcmHeader::GetZImagePosition: wrong Image Position Patient (0020,0032)");
- return 0.; // bug in the element 0x0020,0x0032
- } else {
- return zImPos;
- }
- }
- StrImPos = GetPubElValByNumber(0x0020,0x0030); // For ACR-NEMA images
- if (StrImPos != "gdcm::Unfound") {
- if( sscanf( StrImPos.c_str(), "%f\\%f\\%f", &xImPos, &yImPos, &zImPos) != 3) {
- dbg.Verbose(0, "gdcmHeader::GetZImagePosition: wrong Image Position (RET) (0020,0030)");
- return 0.; // bug in the element 0x0020,0x0032
- } else {
- return zImPos;
- }
- }
- string StrSliceLocation = GetPubElValByNumber(0x0020,0x1041);// for *very* old ACR-NEMA images
- if (StrSliceLocation != "gdcm::Unfound") {
- if( sscanf( StrSliceLocation.c_str(), "%f", &zImPos) !=1) {
- dbg.Verbose(0, "gdcmHeader::GetZImagePosition: wrong Slice Location (0020,1041)");
- return 0.; // bug in the element 0x0020,0x1041
- } else {
- return zImPos;
- }
- }
- dbg.Verbose(0, "gdcmHeader::GetZImagePosition: unfound Slice Location (0020,1041)");
- string StrLocation = GetPubElValByNumber(0x0020,0x0050);
- if (StrLocation != "gdcm::Unfound") {
- if( sscanf( StrLocation.c_str(), "%f", &zImPos) !=1) {
- dbg.Verbose(0, "gdcmHeader::GetZImagePosition: wrong Location (0020,0050)");
- return 0.; // bug in the element 0x0020,0x0050
- } else {
- return zImPos;
- }
- }
- dbg.Verbose(0, "gdcmHeader::GetYImagePosition: unfound Location (0020,0050)");
- return 0.; // Hopeless
-}
-
-
/**
* \ingroup gdcmHeader
* \brief gets the info from 0002,0010 : Transfert Syntax
* \ else 1.
* @return Transfert Syntax Name (as oposite to Transfert Syntax UID)
*/
-string gdcmHeader::GetTransferSyntaxName(void) {
- string TransfertSyntax = GetPubElValByNumber(0x0002,0x0010);
- if (TransfertSyntax == "gdcm::Unfound") {
+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;
+ std::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);
- if (LutDescriptionR == "gdcm::Unfound")
+ std::string LutDescriptionR = GetPubElValByNumber(0x0028,0x1101);
+ if (LutDescriptionR == GDCM_UNFOUND)
return 0;
- string LutDescriptionG = GetPubElValByNumber(0x0028,0x1102);
- if (LutDescriptionG == "gdcm::Unfound")
+ std::string LutDescriptionG = GetPubElValByNumber(0x0028,0x1102);
+ if (LutDescriptionG == GDCM_UNFOUND)
return 0;
- string LutDescriptionB = GetPubElValByNumber(0x0028,0x1103);
- if (LutDescriptionB == "gdcm::Unfound")
+ 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";
+ std::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;
+ std::vector<std::string> tokens;
//int LutLength;
//int LutDepth;
int LutNbits;
- // Just hope Lookup Table Desc-Red = Lookup Table Desc-Red = Lookup Table Desc-Blue
+ //Just hope Lookup Table Desc-Red = Lookup Table Desc-Red = Lookup Table Desc-Blue
// Consistency already checked in GetLUTLength
- string LutDescription = GetPubElValByNumber(0x0028,0x1101);
- if (LutDescription == "gdcm::Unfound")
+ std::string LutDescription = GetPubElValByNumber(0x0028,0x1101);
+ if (LutDescription == GDCM_UNFOUND)
return 0;
tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
Tokenize (LutDescription, tokens, "\\");
// http://www.barre.nom.fr/medical/dicom2/limitations.html#Color%20Lookup%20Tables
// and OT-PAL-8-face.dcm
- if (GetPubElValByNumber(0x0028,0x0004) == "gdcm::Unfound") {
+ if (GetPubElValByNumber(0x0028,0x0004) == GDCM_UNFOUND) {
dbg.Verbose(0, "gdcmHeader::GetLUTRGB: unfound Photometric Interpretation");
return NULL;
}
if(l==0)
return (NULL);
int nBits=GetLUTNbits();
+
// a virer quand on aura trouve UNE image
// qui correspond VRAIMENT à la definition !
- cout << "l " << l << " nBits " << nBits;
+ std::cout << "l " << l << " nBits " << nBits;
l= l/(nBits/8);
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";
+ //std::cout << "lut16 " << i << " : " << *r << " " << *g << " " << *b
+ // << std::endl;
printf("lut 8 %d : %d %d %d \n",i,*r,*g,*b);
*rgb++ = *r++;
*rgb++ = *g++;
free(LutR); free(LutB); free(LutG);
return(LUTRGB);
}
+
+/* Sorry for the comments. The code will be moved in a fonction
+
+ std::string x=GetPubElValByNumber(0x0028,0x1201);
+ unsigned short int * lutR = (unsigned short int *)malloc((size_t)200*sizeof(short int));
+ unsigned short int * lutG = (unsigned short int *)malloc((size_t)200*sizeof(short int));
+ unsigned short int * lutB = (unsigned short int *)malloc((size_t)200*sizeof(short int));
+
+ std::vector<std::string> tokens;
+ tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
+ Tokenize ((const std::string)x, tokens, "\\");
+ for (unsigned int i=0; i<tokens.size();i++) {
+ lutR[i] = atoi(tokens[i].c_str());
+ printf("%d (%x)\n",lutR[i],lutR[i]);
+ }
+
+ std::string y=GetPubElValByNumber(0x0028,0x1202);
+ tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
+ Tokenize ((const std::string)y, tokens, "\\");
+ for (unsigned int i=0; i<tokens.size();i++) {
+ lutG[i] = atoi(tokens[i].c_str());
+ }
+
+ std::string z=GetPubElValByNumber(0x0028,0x1203);
+ tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
+ Tokenize ((const std::string)z, tokens, "\\");
+ for (unsigned int i=0; i<tokens.size();i++) {
+ lutB[i] = atoi(tokens[i].c_str());
+ }
+ tokens.erase(tokens.begin(),tokens.end()); // clean any previous value
+ Tokenize ((const std::string)x, tokens, "\\");
+ for (unsigned int i=0; i<tokens.size();i++) {
+ lutB[i] = atoi(tokens[i].c_str());
+ }
+
+ */
+
+//int lgth=GetLUTLength();
+//cout << "lgth " << lgth << std::endl;;
+//for (int j=0;j<lgth;j++){
+//printf ("%d : %d (%x) %d (%x) %d (%x)\n",j,lutR[j],lutR[j],lutG[j],lutG[j],lutB[j],lutB[j]);
+//}
+
+
}
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff