-// $Header: /cvs/public/gdcm/src/Attic/gdcmHeaderHelper.cxx,v 1.15 2003/11/03 10:49:31 jpr Exp $
-
+// gdcmHeaderHelper.cxx
+//-----------------------------------------------------------------------------
#include "gdcmHeaderHelper.h"
+#include "gdcmDirList.h"
-#include "gdcmUtil.h" //for debug
+#include "gdcmDebug.h"
#include <math.h>
#include <algorithm>
-#include <string.h> //for bzero
+#include <vector>
-//directory manipulation (os indep).
-//cygwin ???? -> _WIN32 ??
-#ifdef _MSC_VER
-#include <windows.h>
-int GetDir(std::string dPath, std::list<std::string> &filenames)
-{
- //For now dPath should have an ending "\"
- WIN32_FIND_DATA FileData;
- HANDLE hFile;
- hFile = FindFirstFile((dPath+"*").c_str(), &FileData);
- if ( hFile == INVALID_HANDLE_VALUE )
- {
- //No files !
- return false;
- }
-
- if( strncmp(FileData.cFileName, ".", 1) != 0 )
- filenames.push_back( dPath+FileData.cFileName );
- while( FindNextFile(hFile, &FileData ) != 0)
- {
- if( strncmp(FileData.cFileName, ".", 1) != 0 )
- filenames.push_back( dPath+FileData.cFileName );
- }
- return true;
-}
-
-#else
-#include <dirent.h>
-
-int GetDir(std::string dPath, std::list<std::string> &filenames)
-{
- DIR *dir = opendir( dPath.c_str() );
- struct dirent *entry;
- while((entry = readdir(dir)) != NULL)
- {
-// if( strncmp(entry->d_name, ".", 1) != 0 && strncmp(entry->d_name, "..", 2) != 0)
- if( strncmp(entry->d_name, ".", 1) != 0 )
- {
- filenames.push_back( dPath + "/" + entry->d_name );
- }
- }
- closedir(dir);
- return true;
-}
-
-#endif
-
-//----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
/**
* \ingroup gdcmHeaderHelper
- * \brief cstor
+ * \brief constructor
*/
-gdcmHeaderHelper::gdcmHeaderHelper() : gdcmHeader( )
-{
+gdcmHeaderHelper::gdcmHeaderHelper() : gdcmHeader( ) {
+
}
-//----------------------------------------------------------------------------
+
/**
* \ingroup gdcmHeaderHelper
- * \brief cstor
+ * \brief constructor
+ * @param InFilename Name of the file to deal with
+ * @param exception_on_error
+ * @param enable_sequences = true to allow the header
+ * to be parsed *inside* the SeQuences,
+ * when they have an actual length
+ * @param ignore_shadow = true if user wants to skip shadow groups
+ * during parsing, to save memory space
*/
gdcmHeaderHelper::gdcmHeaderHelper(const char *InFilename,
- bool exception_on_error) : gdcmHeader( InFilename , exception_on_error)
+ bool exception_on_error,
+ bool enable_sequences,
+ bool ignore_shadow)
+ : gdcmHeader( InFilename,
+ exception_on_error,
+ enable_sequences,
+ ignore_shadow)
{
}
-//----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+// Print
+
+//-----------------------------------------------------------------------------
+// Public
/**
* \ingroup gdcmHeaderHelper
- * \brief Return the size (in bytes) of a single pixel of data.
+ * \brief Returns the size (in bytes) of a single pixel of data.
* @return The size in bytes of a single pixel of data.
*
*/
// 0028 0100 US IMG Bits Allocated
// (in order no to be messed up by old RGB images)
- if (gdcmHeader::GetPubElValByNumber(0x0028,0x0100) == "24")
+ if (gdcmHeader::GetEntryByNumber(0x0028,0x0100) == "24")
return 3;
std::string PixelType = GetPixelType();
return 2;
if (PixelType == "32U" || PixelType == "32S")
return 4;
+ if (PixelType == "FD") // to help unfortunate users to manage DOUBLE
+ return 8;
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
* \brief Build the Pixel Type of the image.
* - 16S signed 16 bit,
* - 32U unsigned 32 bit,
* - 32S signed 32 bit,
+ * - FD Double,
* \warning 12 bit images appear as 16 bit.
- * \ 24 bit images appear as 8 bit
+ * 24 bit images appear as 8 bit
+ * 64 bit means 'DOUBLE' images
+ * (no DOUBLE images in kosher DICOM,
+ * but so usefull for people that miss them ;-)
* @return
*/
std::string gdcmHeaderHelper::GetPixelType() {
std::string BitsAlloc;
- BitsAlloc = GetElValByName("Bits Allocated");
- if (BitsAlloc == GDCM_UNFOUND) {
+ BitsAlloc = GetEntryByNumber(0x0028, 0x0100);
+ if (BitsAlloc == GDCM_UNFOUND) { // Bits Allocated
dbg.Verbose(0, "gdcmHeader::GetPixelType: unfound Bits Allocated");
BitsAlloc = std::string("16");
}
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) {
+ Signed = GetEntryByNumber(0x0028, 0x0103);
+ if (Signed == GDCM_UNFOUND) { // "Pixel Representation"
dbg.Verbose(0, "gdcmHeader::GetPixelType: unfound Pixel Representation");
BitsAlloc = std::string("0");
}
+ if (BitsAlloc == "64") // to help users that want to deal with DOUBLE
+ return("FD");
+
if (Signed == "0")
Signed = std::string("U");
else
return( BitsAlloc + Signed);
}
-//----------------------------------------------------------------------------
+
/**
* \ingroup gdcmHeaderHelper
* \brief gets the info from 0028,0030 : Pixel Spacing
- * \ else 1.
+ * else 1.0
* @return X dimension of a pixel
*/
float gdcmHeaderHelper::GetXSpacing() {
float xspacing, yspacing;
- std::string StrSpacing = GetPubElValByNumber(0x0028,0x0030);
+ std::string StrSpacing = GetEntryByNumber(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.;
+ int nbValues;
+ if( (nbValues = sscanf( StrSpacing.c_str(), "%f\\%f", &yspacing, &xspacing)) != 2) {
+ if (nbValues==1) // if single value is found, xspacing is defaulted to yspacing
+ return yspacing;
+ }
if (xspacing == 0.) {
dbg.Verbose(0, "gdcmHeader::GetYSpacing: gdcmData/CT-MONO2-8-abdo.dcm problem");
// seems to be a bug in the header ...
}
return xspacing;
}
-//----------------------------------------------------------------------------
+
/**
* \ingroup gdcmHeaderHelper
* \brief gets the info from 0028,0030 : Pixel Spacing
- * \ else 1.
+ * else 1.0
* @return Y dimension of a pixel
*/
float gdcmHeaderHelper::GetYSpacing() {
- float xspacing, yspacing;
- std::string StrSpacing = GetPubElValByNumber(0x0028,0x0030);
+ float yspacing;
+ std::string StrSpacing = GetEntryByNumber(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", &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);
- }
+ sscanf( StrSpacing.c_str(), "%f", &yspacing);
return yspacing;
}
-//----------------------------------------------------------------------------
/**
*\ingroup gdcmHeaderHelper
*\brief gets the info from 0018,0088 : Space Between Slices
- *\ else from 0018,0050 : Slice Thickness
- *\ else 1.
+ * else from 0018,0050 : Slice Thickness
+ * else 1.0
* @return Z dimension of a voxel-to be
*/
float gdcmHeaderHelper::GetZSpacing() {
- // TODO : translate into English
// Spacing Between Slices : distance entre le milieu de chaque coupe
// Les coupes peuvent etre :
// jointives (Spacing between Slices = Slice Thickness)
// Si le Spacing Between Slices est absent,
// on suppose que les coupes sont jointives
- std::string StrSpacingBSlices = GetPubElValByNumber(0x0018,0x0088);
+ std::string StrSpacingBSlices = GetEntryByNumber(0x0018,0x0088);
if (StrSpacingBSlices == GDCM_UNFOUND) {
dbg.Verbose(0, "gdcmHeader::GetZSpacing: unfound StrSpacingBSlices");
- std::string StrSliceThickness = GetPubElValByNumber(0x0018,0x0050);
+ std::string StrSliceThickness = GetEntryByNumber(0x0018,0x0050);
if (StrSliceThickness == GDCM_UNFOUND)
return 1.;
else
}
}
-//----------------------------------------------------------------------------
+/**
+ *\ingroup gdcmHeaderHelper
+ *\brief gets the info from 0028,1052 : Rescale Intercept
+ * @return Rescale Intercept
+ */
+float gdcmHeaderHelper::GetRescaleIntercept() {
+ float resInter = 0.;
+ std::string StrRescInter = GetEntryByNumber(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");
+ // bug in the element 0x0028,0x1052
+ }
+ }
+ return resInter;
+}
+
+/**
+ *\ingroup gdcmHeaderHelper
+ *\brief gets the info from 0028,1053 : Rescale Slope
+ * @return Rescale Slope
+ */
+ float gdcmHeaderHelper::GetRescaleSlope() {
+ float resSlope = 1.;
+ std::string StrRescSlope = GetEntryByNumber(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");
+ // bug in the element 0x0028,0x1053
+ }
+ }
+ return resSlope;
+}
+
+/**
+ * \ingroup gdcmHeaderHelper
+ * \brief This function is intended to user who doesn't want
+ * 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::GetEntryByNumber(0x0028,0x0100) == "24")
+ return 3;
+
+ std::string PhotometricInterpretation =
+ gdcmHeader::GetEntryByNumber(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::GetEntryByNumber(0x0028,0x0100) == "24")
+ return 3;
+
+ // we assume that *all* kinds of YBR are dealt with
+ return GetSamplesPerPixel();
+}
+
+/**
+ *\ingroup gdcmHeaderHelper
+ *\brief gets the info from 0020,000d : Study Instance UID
+ *\todo ? : return the ACR-NEMA element value if DICOM one is not found
+ * @return Study Instance UID
+ */
+ std::string gdcmHeaderHelper::GetStudyUID(){
+ return GetEntryByNumber(0x0020,0x000d); //0020 000d UI REL Study Instance UID
+}
+
+/**
+ *\ingroup gdcmHeaderHelper
+ *\brief gets the info from 0020,000e : Series Instance UID
+ *\todo ? : return the ACR-NEMA element value if DICOM one is not found
+ * @return Series Instance UID
+ */
+ std::string gdcmHeaderHelper::GetSeriesUID(){
+ return GetEntryByNumber(0x0020,0x000e); //0020 000e UI REL Series Instance UID
+}
+
+/**
+ *\ingroup gdcmHeaderHelper
+ *\brief gets the info from 0008,0016 : SOP Class UID
+ *\todo ? : return the ACR-NEMA element value if DICOM one is not found
+ * @return SOP Class UID
+ */
+ std::string gdcmHeaderHelper::GetClassUID(){
+ return GetEntryByNumber(0x0008,0x0016); //0008 0016 UI ID SOP Class UID
+}
+
+/**
+ *\ingroup gdcmHeaderHelper
+ *\brief gets the info from 0008,0018 : SOP Instance UID
+ *\todo ? : return the ACR-NEMA element value if DICOM one is not found
+ * @return SOP Instance UID
+ */
+ std::string gdcmHeaderHelper::GetInstanceUID(){
+ return GetEntryByNumber(0x0008,0x0018); //0008 0018 UI ID SOP Instance UID
+}
+//
+// -------------- Remember ! ----------------------------------
//
// Image Position Patient (0020,0032):
// If not found (ACR_NEMA) we try Image Position (0020,0030)
// 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 gdcmHeaderHelper
* \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
+ * else from 0020,0030 : Image Position (RET)
+ * else 0.
+ * @return up-left image corner X position
*/
+
float gdcmHeaderHelper::GetXOrigin() {
float xImPos, yImPos, zImPos;
- std::string StrImPos = GetPubElValByNumber(0x0020,0x0032);
+ std::string StrImPos = GetEntryByNumber(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
+ StrImPos = GetEntryByNumber(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.;
return xImPos;
}
-//----------------------------------------------------------------------------
+
/**
* \ingroup gdcmHeaderHelper
* \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
+ * else from 0020,0030 : Image Position (RET)
+ * else 0.
+ * @return up-left image corner Y position
*/
float gdcmHeaderHelper::GetYOrigin() {
float xImPos, yImPos, zImPos;
- std::string StrImPos = GetPubElValByNumber(0x0020,0x0032);
+ std::string StrImPos = GetEntryByNumber(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
+ StrImPos = GetEntryByNumber(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.;
return yImPos;
}
-//----------------------------------------------------------------------------
+
/**
* \ingroup gdcmHeaderHelper
* \brief gets the info from 0020,0032 : Image Position Patient
* \ else from 0020,1041 : Slice Location
* \ else from 0020,0050 : Location
* \ else 0.
- * @return up-left image corner position
+ * @return up-left image corner Z position
*/
float gdcmHeaderHelper::GetZOrigin() {
float xImPos, yImPos, zImPos;
- std::string StrImPos = GetPubElValByNumber(0x0020,0x0032);
+ std::string StrImPos = GetEntryByNumber(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;
}
}
- StrImPos = GetPubElValByNumber(0x0020,0x0030); // For ACR-NEMA images
+ StrImPos = GetEntryByNumber(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 zImPos;
}
}
- std::string StrSliceLocation = GetPubElValByNumber(0x0020,0x1041);// for *very* old ACR-NEMA images
+ std::string StrSliceLocation = GetEntryByNumber(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)");
- std::string StrLocation = GetPubElValByNumber(0x0020,0x0050);
+ std::string StrLocation = GetEntryByNumber(0x0020,0x0050);
if (StrLocation != GDCM_UNFOUND) {
if( sscanf( StrLocation.c_str(), "%f", &zImPos) !=1) {
dbg.Verbose(0, "gdcmHeader::GetZImagePosition: wrong Location (0020,0050)");
dbg.Verbose(0, "gdcmHeader::GetYImagePosition: unfound Location (0020,0050)");
return 0.; // Hopeless
}
-//----------------------------------------------------------------------------
+
/**
* \ingroup gdcmHeaderHelper
* \brief gets the info from 0020,0013 : Image Number
//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.
- std::string StrImNumber = GetPubElValByNumber(0x0020,0x0013); //0020 0013 IS REL Image Number
+ std::string StrImNumber = GetEntryByNumber(0x0020,0x0013); //0020 0013 IS REL Image Number
if (StrImNumber != GDCM_UNFOUND) {
return atoi( StrImNumber.c_str() );
}
return 0; //Hopeless
}
-//----------------------------------------------------------------------------
+
/**
* \ingroup gdcmHeaderHelper
* \brief gets the info from 0008,0060 : Modality
- * @return ModalityType
+ * @return Modality Type
*/
ModalityType gdcmHeaderHelper::GetModality(void) {
- std::string StrModality = GetPubElValByNumber(0x0008,0x0060); //0008 0060 CS ID Modality
+ std::string StrModality = GetEntryByNumber(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;
return Unknow;
}
-//----------------------------------------------------------------------------
-std::string gdcmHeaderHelper::GetStudyUID()
-{
- return GetPubElValByNumber(0x0020,0x000d); //0020 000d UI REL Study Instance UID
-}
-//----------------------------------------------------------------------------
-std::string gdcmHeaderHelper::GetSeriesUID()
-{
- return GetPubElValByNumber(0x0020,0x000e); //0020 000e UI REL Series Instance UID
-}
-//----------------------------------------------------------------------------
-std::string gdcmHeaderHelper::GetClassUID()
-{
- return GetPubElValByNumber(0x0008,0x0016); //0008 0016 UI ID SOP Class UID
-}
-//----------------------------------------------------------------------------
-std::string gdcmHeaderHelper::GetInstanceUID()
-{
- return GetPubElValByNumber(0x0008,0x0018); //0008 0018 UI ID SOP Instance UID
-}
-
-
-
-
-
-
-
-
-
-gdcmSerieHeaderHelper::~gdcmSerieHeaderHelper()
-{
- //! \todo
- for (std::list<gdcmHeaderHelper*>::iterator it = CoherentGdcmFileList.begin();
- it != CoherentGdcmFileList.end(); it++)
- {
- delete *it;
- }
- CoherentGdcmFileList.clear();
-}
-//----------------------------------------------------------------------------
/**
* \ingroup gdcmHeaderHelper
* \brief gets the info from 0020,0037 : Image Orientation Patient
+ * @param iop adress of the (6)float aray to receive values
* @return cosines of image orientation patient
*/
void gdcmHeaderHelper::GetImageOrientationPatient( float* iop ) {
//iop is supposed to be float[6]
iop[0] = iop[1] = iop[2] = iop[3] = iop[4] = iop[5] = 0;
- std::string StrImOriPat = GetPubElValByNumber(0x0020,0x0037); // 0020 0037 DS REL Image Orientation (Patient)
+ std::string StrImOriPat = GetEntryByNumber(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) {
}
//For ACR-NEMA
- StrImOriPat = GetPubElValByNumber(0x0020,0x0035); //0020 0035 DS REL Image Orientation (RET)
+ StrImOriPat = GetEntryByNumber(0x0020,0x0035); //0020 0035 DS REL Image Orientation (RET)
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) {
}
}
-//----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
+// Protected
+
+//-----------------------------------------------------------------------------
+// Private
+
+//-----------------------------------------------------------------------------
+
+
+
+//-----------------------------------------------------------------------------
+// gdcmSerieHeaderHelper
+//-----------------------------------------------------------------------------
+// Constructor / Destructor
+gdcmSerieHeaderHelper::~gdcmSerieHeaderHelper(){
+ //! \todo
+ for (std::list<gdcmHeaderHelper*>::iterator it = CoherentGdcmFileList.begin();
+ it != CoherentGdcmFileList.end(); it++)
+ {
+ delete *it;
+ }
+ CoherentGdcmFileList.clear();
+}
+
+//-----------------------------------------------------------------------------
+// Print
+
+//-----------------------------------------------------------------------------
+// Public
/**
- * \ingroup gdcmHeaderHelper
- * \brief add a gdcmFile to the list based on file name
- */
-void gdcmSerieHeaderHelper::AddFileName(std::string filename)
-{
+ * \ingroup gdcmHeaderHelper
+ * \brief add a gdcmFile to the list based on file name
+ * @param filename Name of the file to deal with
+ */
+void gdcmSerieHeaderHelper::AddFileName(std::string filename) {
gdcmHeaderHelper *GdcmFile = new gdcmHeaderHelper( filename.c_str() );
this->CoherentGdcmFileList.push_back( GdcmFile );
}
-//----------------------------------------------------------------------------
+
/**
- * \ingroup gdcmHeaderHelper
- * \brief add a gdcmFile to the list
- */
-void gdcmSerieHeaderHelper::AddGdcmFile(gdcmHeaderHelper *file)
-{
+ * \ingroup gdcmHeaderHelper
+ * \brief add a gdcmFile to the list
+ * @param file gdcmHeaderHelper to add
+ */
+void gdcmSerieHeaderHelper::AddGdcmFile(gdcmHeaderHelper *file){
this->CoherentGdcmFileList.push_back( file );
}
-//----------------------------------------------------------------------------
+
/**
- * \ingroup gdcmHeaderHelper
- * \brief \todo
- */
-void gdcmSerieHeaderHelper::SetDirectory(std::string dir)
-{
- std::list<std::string> filenames_list;
- GetDir(dir, filenames_list); //OS specific
+ * \ingroup gdcmHeaderHelper
+ * \brief Sets the Directory
+ * @param dir Name of the directory to deal with
+ */
+void gdcmSerieHeaderHelper::SetDirectory(std::string dir){
+ gdcmDirList filenames_list(dir); //OS specific
- for(std::list<std::string>::iterator it = filenames_list.begin(); it !=
- filenames_list.end(); it++)
+ for(gdcmDirList::iterator it = filenames_list.begin();
+ it !=filenames_list.end(); it++)
{
gdcmHeaderHelper *file = new gdcmHeaderHelper( it->c_str() );
this->CoherentGdcmFileList.push_back( file );
}
}
-//----------------------------------------------------------------------------
-//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 approach :)
-void gdcmSerieHeaderHelper::OrderGdcmFileList()
-{
- if( ImagePositionPatientOrdering() )
- {
+
+/**
+ * \ingroup gdcmHeaderHelper
+ * \brief Sorts the File List
+ * \warning 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 approach :)
+*/
+void gdcmSerieHeaderHelper::OrderGdcmFileList(){
+ if( ImagePositionPatientOrdering() ) {
return ;
}
- else if( ImageNumberOrdering() )
- {
+ else if( ImageNumberOrdering() ) {
return ;
- }
- else
- {
+ } else {
FileNameOrdering();
}
}
-//----------------------------------------------------------------------------
+
/**
- * \ingroup gdcmHeaderHelper
- * \brief
- We may order, considering :
- -# Image Number
- -# Image Position Patient
- -# More to come :)
+ * \ingroup gdcmHeaderHelper
+ * \brief Gets the *coherent* File List
+ * @return the *coherent* File List
*/
-//based on Jolinda's algorithm
+std::list<gdcmHeaderHelper*> &gdcmSerieHeaderHelper::GetGdcmFileList() {
+ return CoherentGdcmFileList;
+}
+
+//-----------------------------------------------------------------------------
+// Protected
+
+//-----------------------------------------------------------------------------
+// Private
+/**
+ * \ingroup gdcmHeaderHelper
+ * \brief sorts the images, according to their Patient Position
+ * We may order, considering :
+ * -# Image Number
+ * -# Image Position Patient
+ * -# More to come :)
+ * @return false only if the header is bugged !
+ */
bool gdcmSerieHeaderHelper::ImagePositionPatientOrdering()
+//based on Jolinda's algorithm
{
//iop is calculated based on the file file
float *cosines = new float[6];
delete[] cosines;
return false;
}
-
distlist.push_back( dist );
return true;
}
-//----------------------------------------------------------------------------
-//Based on Image Number
-bool gdcmSerieHeaderHelper::ImageNumberOrdering()
-{
+
+/**
+ * \ingroup gdcmHeaderHelper
+ * \brief sorts the images, according to their Image Number
+ * @return false only if the header is bugged !
+ */
+
+bool gdcmSerieHeaderHelper::ImageNumberOrdering() {
int min, max, pos;
- int n = 0;//CoherentGdcmFileList.size(); //O(N) operation !!
+ int n = 0;//CoherentGdcmFileList.size() is a O(N) operation !!
unsigned char *partition;
std::list<gdcmHeaderHelper*>::iterator it = CoherentGdcmFileList.begin();
partition[pos - min]++;
}
- unsigned char mult;
+ unsigned char mult = 1;
for(int i=0; i<n ; i++)
{
mult *= partition[i];
CoherentGdcmFileVector.clear();
delete[] partition;
- return mult;
+ return (mult!=0);
}
-//----------------------------------------------------------------------------
-bool gdcmSerieHeaderHelper::FileNameOrdering()
-{
+
+
+/**
+ * \ingroup gdcmHeaderHelper
+ * \brief sorts the images, according to their File Name
+ * @return false only if the header is bugged !
+ */
+ bool gdcmSerieHeaderHelper::FileNameOrdering() {
//using the sort
//sort(CoherentGdcmFileList.begin(), CoherentGdcmFileList.end());
return true;
}
-//----------------------------------------------------------------------------
-std::list<gdcmHeaderHelper*> &gdcmSerieHeaderHelper::GetGdcmFileList()
-{
- return CoherentGdcmFileList;
-}
-//----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
git://git.creatis.insa-lyon.fr / gdcm.git / blobdiff