-// $Header: /cvs/public/gdcm/src/Attic/gdcmHeaderHelper.cxx,v 1.5 2003/09/18 09:32:15 regrain Exp $
-
-//This is needed when compiling in debug mode
-#ifdef _MSC_VER
-#pragma warning ( disable : 4800 )
-// 'identifier' : class 'type' needs to have dll-interface to be used by
-// clients of class 'type2'
-#pragma warning ( disable : 4251 )
-// 'identifier' : identifier was truncated to 'number' characters in the
-// debug information
-#pragma warning ( disable : 4786 )
-#endif //_MSC_VER
+// $Header: /cvs/public/gdcm/src/Attic/gdcmHeaderHelper.cxx,v 1.16 2003/11/07 14:57:58 malaterre Exp $
#include "gdcmHeaderHelper.h"
+
#include "gdcmUtil.h" //for debug
#include <math.h>
#include <algorithm>
#include <string.h> //for bzero
-using namespace std;
//directory manipulation (os indep).
//cygwin ???? -> _WIN32 ??
#ifdef _MSC_VER
#include <windows.h>
-int GetDir(string dPath, list<string> &filenames)
+int GetDir(std::string dPath, std::list<std::string> &filenames)
{
//For now dPath should have an ending "\"
WIN32_FIND_DATA FileData;
#else
#include <dirent.h>
-int GetDir(string dPath, list<string> &filenames)
+int GetDir(std::string dPath, std::list<std::string> &filenames)
{
DIR *dir = opendir( dPath.c_str() );
struct dirent *entry;
*
*/
int gdcmHeaderHelper::GetPixelSize() {
- string PixelType = GetPixelType();
+
+ // 0028 0100 US IMG Bits Allocated
+ // (in order no to be messed up by old RGB images)
+ if (gdcmHeader::GetPubElValByNumber(0x0028,0x0100) == "24")
+ return 3;
+
+ std::string PixelType = GetPixelType();
if (PixelType == "8U" || PixelType == "8S")
return 1;
if (PixelType == "16U" || PixelType == "16S")
dbg.Verbose(0, "gdcmHeader::GetPixelSize: Unknown pixel type");
return 0;
}
+
+//----------------------------------------------------------------------------
+/**
+ * \ingroup gdcmHeaderHelper
+ * \brief This function is intended to user who doesn't whan
+ * \ to have to manage a LUT and expects to get an RBG Pixel image
+ * \ (or a monochrome one ...)
+ * \warning to be used with GetImagePixels()
+ * @return 1 if Gray level, 3 if Color (RGB, YBR or PALETTE COLOR)
+ */
+int gdcmHeaderHelper::GetNumberOfScalarComponents() {
+
+ if (GetSamplesPerPixel() ==3)
+ return 3;
+
+ // 0028 0100 US IMG Bits Allocated
+ // (in order no to be messed up by old RGB images)
+ if (gdcmHeader::GetPubElValByNumber(0x0028,0x0100) == "24")
+ return 3;
+
+ std::string PhotometricInterpretation =
+ gdcmHeader::GetPubElValByNumber(0x0028,0x0004);
+
+ if ( ( PhotometricInterpretation == "PALETTE COLOR ") ) {
+ if (HasLUT()) // PALETTE COLOR is NOT enough
+ return 3;
+ else
+ return 1;
+ }
+
+ //beware of trailing space at end of string
+ if (PhotometricInterpretation.find(GDCM_UNFOUND) <
+ PhotometricInterpretation.length() ||
+ PhotometricInterpretation.find("MONOCHROME1") <
+ PhotometricInterpretation.length() ||
+ PhotometricInterpretation.find("MONOCHROME2") <
+ PhotometricInterpretation.length() )
+ return 1;
+ else
+ // we assume that *all* kinds of YBR are dealt with
+ return 3;
+}
+
+//----------------------------------------------------------------------------
+/**
+ * \ingroup gdcmHeaderHelper
+ * \brief This function is intended to user that DOESN'T want
+ * \to get RGB pixels image when it's stored as a PALETTE COLOR image
+ * \ - the (vtk) user is supposed to know how deal with LUTs -
+ * \warning to be used with GetImagePixelsRaw()
+ * @return 1 if Gray level, 3 if Color (RGB or YBR - NOT 'PALETTE COLOR' -)
+ */
+int gdcmHeaderHelper::GetNumberOfScalarComponentsRaw() {
+
+ // 0028 0100 US IMG Bits Allocated
+ // (in order no to be messed up by old RGB images)
+ if (gdcmHeader::GetPubElValByNumber(0x0028,0x0100) == "24")
+ return 3;
+
+ // we assume that *all* kinds of YBR are dealt with
+ return GetSamplesPerPixel();
+}
+
//----------------------------------------------------------------------------
/**
* \ingroup gdcmHeaderHelper
* - 32U unsigned 32 bit,
* - 32S signed 32 bit,
* \warning 12 bit images appear as 16 bit.
+ * \ 24 bit images appear as 8 bit
* @return
*/
-string gdcmHeaderHelper::GetPixelType() {
- string BitsAlloc;
+std::string gdcmHeaderHelper::GetPixelType() {
+ 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");
-
- string Signed;
+ if (BitsAlloc == "12") // It will be unpacked
+ BitsAlloc = std::string("16");
+ else if (BitsAlloc == "24") // (in order no to be messed up
+ BitsAlloc = std::string("8"); // by old RGB images)
+
+ 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);
}
*/
float gdcmHeaderHelper::GetXSpacing() {
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;
+ std::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", &yspacing, &xspacing) != 2)
+ return 0.;
+ if (xspacing == 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", &yspacing, &xspacing);
+ }
+ return xspacing;
}
//----------------------------------------------------------------------------
/**
*/
float gdcmHeaderHelper::GetYSpacing() {
float xspacing, yspacing;
- string StrSpacing = GetPubElValByNumber(0x0028,0x0030);
+ std::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)
+ if( sscanf( StrSpacing.c_str(), "%f\\%f", &yspacing, &xspacing) != 2)
return 0.;
- if (yspacing == 0.) {
+ if (xspacing == 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);
+ sscanf( StrSpacing.c_str(), "%f\\0\\%f", &yspacing, &xspacing);
}
return yspacing;
}
// Si le Spacing Between Slices est absent,
// on suppose que les coupes sont jointives
- string StrSpacingBSlices = GetPubElValByNumber(0x0018,0x0088);
+ std::string StrSpacingBSlices = GetPubElValByNumber(0x0018,0x0088);
if (StrSpacingBSlices == GDCM_UNFOUND) {
dbg.Verbose(0, "gdcmHeader::GetZSpacing: unfound StrSpacingBSlices");
- string StrSliceThickness = GetPubElValByNumber(0x0018,0x0050);
+ std::string StrSliceThickness = GetPubElValByNumber(0x0018,0x0050);
if (StrSliceThickness == GDCM_UNFOUND)
return 1.;
else
*/
float gdcmHeaderHelper::GetXOrigin() {
float xImPos, yImPos, zImPos;
- string StrImPos = GetPubElValByNumber(0x0020,0x0032);
+ std::string StrImPos = GetPubElValByNumber(0x0020,0x0032);
if (StrImPos == GDCM_UNFOUND) {
dbg.Verbose(0, "gdcmHeader::GetXImagePosition: unfound Image Position Patient (0020,0032)");
*/
float gdcmHeaderHelper::GetYOrigin() {
float xImPos, yImPos, zImPos;
- string StrImPos = GetPubElValByNumber(0x0020,0x0032);
+ std::string StrImPos = GetPubElValByNumber(0x0020,0x0032);
if (StrImPos == GDCM_UNFOUND) {
dbg.Verbose(0, "gdcmHeader::GetYImagePosition: unfound Image Position Patient (0020,0032)");
*/
float gdcmHeaderHelper::GetZOrigin() {
float xImPos, yImPos, zImPos;
- string StrImPos = GetPubElValByNumber(0x0020,0x0032);
+ std::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 zImPos;
}
}
- string StrSliceLocation = GetPubElValByNumber(0x0020,0x1041);// for *very* old ACR-NEMA images
+ std::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)");
}
}
dbg.Verbose(0, "gdcmHeader::GetZImagePosition: unfound Slice Location (0020,1041)");
- string StrLocation = GetPubElValByNumber(0x0020,0x0050);
+ std::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)");
//binary conversion rules. This may be preferable to sscanf() since atoi() is a much smaller,
// simpler and faster function. sscanf() can do all possible conversions whereas atoi() can
//only do single decimal integer conversions.
- string StrImNumber = GetPubElValByNumber(0x0020,0x0013); //0020 0013 IS REL Image Number
+ std::string StrImNumber = GetPubElValByNumber(0x0020,0x0013); //0020 0013 IS REL Image Number
if (StrImNumber != GDCM_UNFOUND) {
return atoi( StrImNumber.c_str() );
}
* @return ModalityType
*/
ModalityType gdcmHeaderHelper::GetModality(void) {
- string StrModality = GetPubElValByNumber(0x0008,0x0060); //0008 0060 CS ID Modality
+ std::string StrModality = GetPubElValByNumber(0x0008,0x0060); //0008 0060 CS ID Modality
if (StrModality != GDCM_UNFOUND) {
if ( StrModality.find("AU") < StrModality.length()) return AU;
else if ( StrModality.find("AS") < StrModality.length()) return AS;
else if ( StrModality.find("PT") < StrModality.length()) return PT;
else if ( StrModality.find("RF") < StrModality.length()) return RF;
else if ( StrModality.find("RG") < StrModality.length()) return RG;
- else if ( StrModality.find("RTDOSE") < StrModality.length()) return RTDOSE;
- else if ( StrModality.find("RTIMAGE") < StrModality.length()) return RTIMAGE;
- else if ( StrModality.find("RTPLAN") < StrModality.length()) return RTPLAN;
- else if ( StrModality.find("RTSTRUCT") < StrModality.length()) return RTSTRUCT;
+ else if ( StrModality.find("RTDOSE") < StrModality.length()) return RTDOSE;
+ else if ( StrModality.find("RTIMAGE") < StrModality.length()) return RTIMAGE;
+ else if ( StrModality.find("RTPLAN") < StrModality.length()) return RTPLAN;
+ else if ( StrModality.find("RTSTRUCT")< StrModality.length()) return RTSTRUCT;
else if ( StrModality.find("SM") < StrModality.length()) return SM;
else if ( StrModality.find("ST") < StrModality.length()) return ST;
else if ( StrModality.find("TG") < StrModality.length()) return TG;
}
//----------------------------------------------------------------------------
-string gdcmHeaderHelper::GetStudyUID()
+std::string gdcmHeaderHelper::GetStudyUID()
{
- return GetPubElValByNumber(0x0020,0x000d); //!0020 000d UI REL Study Instance UID
+ return GetPubElValByNumber(0x0020,0x000d); //0020 000d UI REL Study Instance UID
}
//----------------------------------------------------------------------------
-string gdcmHeaderHelper::GetSeriesUID()
+std::string gdcmHeaderHelper::GetSeriesUID()
{
- return GetPubElValByNumber(0x0020,0x000e); //!0020 000e UI REL Series Instance UID
+ return GetPubElValByNumber(0x0020,0x000e); //0020 000e UI REL Series Instance UID
}
//----------------------------------------------------------------------------
-string gdcmHeaderHelper::GetClassUID()
+std::string gdcmHeaderHelper::GetClassUID()
{
- return GetPubElValByNumber(0x0008,0x0016); //!0008 0016 UI ID SOP Class UID
+ return GetPubElValByNumber(0x0008,0x0016); //0008 0016 UI ID SOP Class UID
}
//----------------------------------------------------------------------------
-string gdcmHeaderHelper::GetInstanceUID()
+std::string gdcmHeaderHelper::GetInstanceUID()
{
- return GetPubElValByNumber(0x0008,0x0018); //!0008 0018 UI ID SOP Instance UID
+ return GetPubElValByNumber(0x0008,0x0018); //0008 0018 UI ID SOP Instance UID
+}
+//----------------------------------------------------------------------------
+float gdcmHeaderHelper::GetRescaleIntercept()
+{
+ float resInter;
+ std::string StrRescInter = GetPubElValByNumber(0x0028,0x1052); //0028 1052 DS IMG Rescale Intercept
+ if (StrRescInter != GDCM_UNFOUND) {
+ if( sscanf( StrRescInter.c_str(), "%f", &resInter) != 1) {
+ dbg.Verbose(0, "gdcmHeader::GetRescaleIntercept: Rescale Slope is empty");
+ return 0.; // bug in the element 0x0028,0x1052
+ } else {
+ return resInter;
+ }
+ }
+}
+//----------------------------------------------------------------------------
+float gdcmHeaderHelper::GetRescaleSlope()
+{
+ float resSlope;
+ std::string StrRescSlope = GetPubElValByNumber(0x0028,0x1053); //0028 1053 DS IMG Rescale Slope
+ if (StrRescSlope != GDCM_UNFOUND) {
+ if( sscanf( StrRescSlope.c_str(), "%f", &resSlope) != 1) {
+ dbg.Verbose(0, "gdcmHeader::GetRescaleSlope: Rescale Slope is empty");
+ return 1.; // bug in the element 0x0028,0x1053
+ } else {
+ return resSlope;
+ }
+ }
+
}
gdcmSerieHeaderHelper::~gdcmSerieHeaderHelper()
{
//! \todo
- for (list<gdcmHeaderHelper*>::iterator it = CoherentGdcmFileList.begin();
+ for (std::list<gdcmHeaderHelper*>::iterator it = CoherentGdcmFileList.begin();
it != CoherentGdcmFileList.end(); it++)
{
delete *it;
//iop is supposed to be float[6]
iop[0] = iop[1] = iop[2] = iop[3] = iop[4] = iop[5] = 0;
- string StrImOriPat = GetPubElValByNumber(0x0020,0x0037); // 0020 0037 DS REL Image Orientation (Patient)
+ std::string StrImOriPat = GetPubElValByNumber(0x0020,0x0037); // 0020 0037 DS REL Image Orientation (Patient)
if (StrImOriPat != GDCM_UNFOUND) {
if( sscanf( StrImOriPat.c_str(), "%f\\%f\\%f\\%f\\%f\\%f",
&iop[0], &iop[1], &iop[2], &iop[3], &iop[4], &iop[5]) != 6) {
* \ingroup gdcmHeaderHelper
* \brief add a gdcmFile to the list based on file name
*/
-void gdcmSerieHeaderHelper::AddFileName(string filename)
+void gdcmSerieHeaderHelper::AddFileName(std::string filename)
{
gdcmHeaderHelper *GdcmFile = new gdcmHeaderHelper( filename.c_str() );
this->CoherentGdcmFileList.push_back( GdcmFile );
* \ingroup gdcmHeaderHelper
* \brief \todo
*/
-void gdcmSerieHeaderHelper::SetDirectory(string dir)
+void gdcmSerieHeaderHelper::SetDirectory(std::string dir)
{
- list<string> filenames_list;
+ std::list<std::string> filenames_list;
GetDir(dir, filenames_list); //OS specific
- for(list<string>::iterator it = filenames_list.begin(); it !=
+ for(std::list<std::string>::iterator it = filenames_list.begin(); it !=
filenames_list.end(); it++)
{
gdcmHeaderHelper *file = new gdcmHeaderHelper( it->c_str() );
//----------------------------------------------------------------------------
//This could be implemented in a 'Strategy Pattern' approach
//But as I don't know how to do it, I leave it this way
-//BTW, this is also a Strategy, I don't know this is the best approcah :)
+//BTW, this is also a Strategy, I don't know this is the best approach :)
void gdcmSerieHeaderHelper::OrderGdcmFileList()
{
if( ImagePositionPatientOrdering() )
float min, max;
bool first = true;
int n=0;
- vector<float> distlist;
+ std::vector<float> distlist;
//!\todo rewrite this for loop.
- for (list<gdcmHeaderHelper*>::iterator it = CoherentGdcmFileList.begin();
+ for (std::list<gdcmHeaderHelper*>::iterator it = CoherentGdcmFileList.begin();
it != CoherentGdcmFileList.end(); it++)
{
if(first) {
//Then I order the slices according to the value "dist". Finally, once
//I've read in all the slices, I calculate the z-spacing as the difference
//between the "dist" values for the first two slices.
- vector<gdcmHeaderHelper*> CoherentGdcmFileVector(n);
+ std::vector<gdcmHeaderHelper*> CoherentGdcmFileVector(n);
//CoherentGdcmFileVector.reserve( n );
CoherentGdcmFileVector.resize( n );
//assert( CoherentGdcmFileVector.capacity() >= n );
n = 0;
//VC++ don't understand what scope is !! it -> it2
- for (list<gdcmHeaderHelper*>::iterator it2 = CoherentGdcmFileList.begin();
+ for (std::list<gdcmHeaderHelper*>::iterator it2 = CoherentGdcmFileList.begin();
it2 != CoherentGdcmFileList.end(); it2++, n++)
{
//2*n sort algo !!
CoherentGdcmFileList.clear(); //this doesn't delete list's element, node only
//VC++ don't understand what scope is !! it -> it3
- for (vector<gdcmHeaderHelper*>::iterator it3 = CoherentGdcmFileVector.begin();
+ for (std::vector<gdcmHeaderHelper*>::iterator it3 = CoherentGdcmFileVector.begin();
it3 != CoherentGdcmFileVector.end(); it3++)
{
CoherentGdcmFileList.push_back( *it3 );
int n = 0;//CoherentGdcmFileList.size(); //O(N) operation !!
unsigned char *partition;
- list<gdcmHeaderHelper*>::iterator it = CoherentGdcmFileList.begin();
+ std::list<gdcmHeaderHelper*>::iterator it = CoherentGdcmFileList.begin();
min = max = (*it)->GetImageNumber();
for (; it != CoherentGdcmFileList.end(); it++, n++)
partition = new unsigned char[n];
memset(partition, 0, n);
- vector<gdcmHeaderHelper*> CoherentGdcmFileVector(n);
+ std::vector<gdcmHeaderHelper*> CoherentGdcmFileVector(n);
//VC++ don't understand what scope is !! it -> it2
- for (list<gdcmHeaderHelper*>::iterator it2 = CoherentGdcmFileList.begin();
+ for (std::list<gdcmHeaderHelper*>::iterator it2 = CoherentGdcmFileList.begin();
it2 != CoherentGdcmFileList.end(); it2++)
{
pos = (*it2)->GetImageNumber();
//VC++ don't understand what scope is !! it -> it3
CoherentGdcmFileList.clear(); //this doesn't delete list's element, node only
- for (vector<gdcmHeaderHelper*>::iterator it3 = CoherentGdcmFileVector.begin();
+ for (std::vector<gdcmHeaderHelper*>::iterator it3 = CoherentGdcmFileVector.begin();
it3 != CoherentGdcmFileVector.end(); it3++)
{
CoherentGdcmFileList.push_back( *it3 );
return true;
}
//----------------------------------------------------------------------------
-list<gdcmHeaderHelper*> &gdcmSerieHeaderHelper::GetGdcmFileList()
+std::list<gdcmHeaderHelper*> &gdcmSerieHeaderHelper::GetGdcmFileList()
{
return CoherentGdcmFileList;
}