gdcm::Util Class Reference

Here are some utility functions, belonging to the gdcm::Util class, dealing with strings, file names... that can be called from anywhere by whomsoever they can help. More...

#include <gdcmUtil.h>

List of all members.

Static Public Member Functions
static std::string	Format (const char *format,...)
	Provide a better 'c++' approach for sprintf For example c code is: char result[2048]; // hope 2048 is enough sprintf(result, "%04x|%04x", group , elem);.
static void	Tokenize (const std::string &str, std::vector< std::string > &tokens, const std::string &delimiters=" ")
	Because not available in C++ (?).
static int	CountSubstring (const std::string &str, const std::string &subStr)
	Because not available in C++ (?) Counts the number of occurences of a substring within a string.
static std::string	CreateCleanString (std::string const &s)
	Weed out a string from the non-printable characters (in order to avoid corrupting the terminal of invocation when printing).
static std::string	CreateCleanString (uint8_t *s, int l)
	Weed out a string from the non-printable characters (in order to avoid corrupting the terminal of invocation when printing).
static bool	IsCleanString (std::string const &s)
	Checks whether a 'string' is printable or not (in order to avoid corrupting the terminal of invocation when printing).
static bool	IsCleanArea (uint8_t *s, int l)
	Checks whether an 'area' is printable or not (in order to avoid corrupting the terminal of invocation when printing).
static std::string	NormalizePath (std::string const &name)
	Add a SEPARATOR to the end of the name is necessary.
static std::string	GetPath (std::string const &fullName)
	Get the (directory) path from a full path file name.
static std::string	GetName (std::string const &fullName)
	Get the (last) name of a full path file name.
static std::string	GetCurrentDate ()
	Get the current date of the system in a dicom string.
static std::string	GetCurrentTime ()
	Get the current time of the system in a dicom string.
static std::string	GetCurrentDateTime ()
	Get both the date and time at the same time to avoid problem around midnight where the two calls could be before and after midnight.
static std::string	GetVersion ()
	Provides a simple static GetVersion() function.
static unsigned int	GetCurrentThreadID ()
static unsigned int	GetCurrentProcessID ()
static bool	IsCurrentProcessorBigEndian ()
	tells us whether the processor we are working with is BigEndian or not
static std::string	DicomString (const char *s, size_t l)
	Create a /DICOM/ string: It should a of even length (no odd length ever) It can contain as many (if you are reading this from your editor the following character is backslash followed by zero that needed to be escaped with an extra backslash for doxygen) \0 as you want.
static std::string	DicomString (const char *s)
	Create a /DICOM/ string: It should a of even length (no odd length ever) It can contain as many (if you are reading this from your editor the following character is backslash followed by zero that needed to be escaped with an extra backslash for doxygen) \0 as you want. This function is similar to DicomString(const char*), except it doesn't take a length. It only pad with a null character if length is odd.
static bool	DicomStringEqual (const std::string &s1, const char *s2)
	Safely check the equality of two Dicom String: Both strings should be of even length We allow padding of even length string by either a null character of a space.
static bool	CompareDicomString (const std::string &s1, const char *s2, int op)
	Safely compare two Dicom String: Both strings should be of even length We allow padding of even length string by either a null character of a space.
static std::string	GetMACAddress ()
	Encode the mac address on a fixed lenght string of 15 characters. we save space this way.
static std::string	CreateUniqueUID (const std::string &root="")
	Creates a new UID. As stipulated in the DICOM ref each time a DICOM image is created it should have a unique identifier (URI).
static void	SetRootUID (const std::string &root="")
static const std::string &	GetRootUID ()
static const uint8_t *	GetFileMetaInformationVersion ()
static void	SetFileMetaInformationVersion (uint16_t fmiv)
static void	hifpswap (double *a, double *b)
static void	hNoifpswap (double *a, double *b)
Static Private Member Functions
static std::string	GetIPAddress ()
	Return the IP adress of the machine writting the DICOM image.
Static Private Attributes
static std::string	RootUID = GDCM_UID
static const std::string	GDCM_UID = "1.2.826.0.1.3680043.2.1143"
static uint8_t *	FileMetaInformationVersion = (uint8_t *)&FMIV
static const uint16_t	FMIV = 0x0100
static std::string	GDCM_MAC_ADRESS = GetMACAddress()

---

Detailed Description

Here are some utility functions, belonging to the gdcm::Util class, dealing with strings, file names... that can be called from anywhere by whomsoever they can help.

Definition at line 36 of file gdcmUtil.h.

---

Member Function Documentation

bool gdcm::Util::CompareDicomString (  const std::string &  s1, const char *  s2, int  op )  [static]

Safely compare two Dicom String: Both strings should be of even length We allow padding of even length string by either a null character of a space. Definition at line 505 of file gdcmUtil.cxx. References DicomString(), gdcm::GDCM_DIFFERENT, gdcm::GDCM_EQUAL, gdcm::GDCM_GREATER, gdcm::GDCM_GREATEROREQUAL, gdcm::GDCM_LESS, gdcm::GDCM_LESSOREQUAL, and gdcmDebugMacro. Referenced by gdcm::SerieHelper::AddFileName(). { // s2 is the string from the DICOM reference e.g. : 'MONOCHROME1' std::string s1_even = s1; //Never change input parameter std::string s2_even = DicomString( s2 ); if ( s1_even[s1_even.size()-1] == ' ' ) { s1_even[s1_even.size()-1] = '\0'; //replace space character by null } switch (op) { case GDCM_EQUAL : return s1_even == s2_even; case GDCM_DIFFERENT : return s1_even != s2_even; case GDCM_GREATER : return s1_even > s2_even; case GDCM_GREATEROREQUAL : return s1_even >= s2_even; case GDCM_LESS : return s1_even < s2_even; case GDCM_LESSOREQUAL : return s1_even <= s2_even; default : gdcmDebugMacro(" Wrong operator : " << op); return false; } }

int gdcm::Util::CountSubstring (  const std::string &  str, const std::string &  subStr )  [static]

Because not available in C++ (?) Counts the number of occurences of a substring within a string. Parameters: str  string to check subStr  substring to count Definition at line 168 of file gdcmUtil.cxx. Referenced by gdcm::CheckVM(). { int count = 0; // counts how many times it appears std::string::size_type x = 0; // The index position in the string do { x = str.find(subStr,x); // Find the substring if (x != std::string::npos) // If present { count++; // increase the count x += subStr.length(); // Skip this word } } while (x != std::string::npos);// Carry on until not present return count; }

std::string gdcm::Util::CreateCleanString (  uint8_t *  s, int  l )  [static]

Weed out a string from the non-printable characters (in order to avoid corrupting the terminal of invocation when printing). Parameters: s  area to process (uint8_t is just for prototyping. feel free to cast) l  area length to check Definition at line 260 of file gdcmUtil.cxx. { std::string str; for( int i=0; i<l; i++) { if (!isprint((unsigned char)s[i]) ) { str = str + '.'; } else { str = str + (char )s[i]; } } return str; }

std::string gdcm::Util::CreateCleanString (  std::string const &  s  )  [static]

Weed out a string from the non-printable characters (in order to avoid corrupting the terminal of invocation when printing). Parameters: s  string to check (uint8_t is just for prototyping. feel free to cast) Definition at line 228 of file gdcmUtil.cxx. Referenced by gdcm::DocEntrySet::GetEntryForcedAsciiValue(), and gdcm::DataEntry::Print(). { std::string str = s; for(unsigned int i=0; i<str.size(); i++) { if (!isprint((unsigned char)str[i]) ) { str[i] = '.'; } } if (str.size() > 0 ) { if (!isprint((unsigned char)s[str.size()-1]) ) { if (s[str.size()-1] == 0 ) { str[str.size()-1] = ' '; } } } return str; }

std::string gdcm::Util::CreateUniqueUID (  const std::string &  root = ""  )  [static]

Creates a new UID. As stipulated in the DICOM ref each time a DICOM image is created it should have a unique identifier (URI). Parameters: root  is the DICOM prefix assigned by IOS group Definition at line 884 of file gdcmUtil.cxx. References GDCM_MAC_ADRESS, gdcmErrorMacro, GetCurrentDateTime(), and RootUID. Referenced by gdcm::FileHelper::CheckMandatoryElements(), and gdcm::DicomDirMeta::WriteContent(). { std::string prefix; std::string append; if ( root.empty() ) { // gdcm UID prefix, as supplied by http://www.medicalconnections.co.uk prefix = RootUID; } else { prefix = root; } // A root was specified use it to forge our new UID: append += "."; //append += Util::GetMACAddress(); // to save CPU time append += Util::GDCM_MAC_ADRESS; append += "."; append += Util::GetCurrentDateTime(); append += "."; //Also add a mini random number just in case: char tmp[10]; int r = (int) (100.0*rand()/RAND_MAX); // Don't use Util::Format to accelerate the execution sprintf(tmp,"%02d", r); append += tmp; // If append is too long we need to rehash it if ( (prefix + append).size() > 64 ) { gdcmErrorMacro( "Size of UID is too long." ); // we need a hash function to truncate this number // if only md5 was cross plateform // MD5(append); } return prefix + append; }

std::string gdcm::Util::DicomString (  const char *  s  )  [static]

Create a /DICOM/ string: It should a of even length (no odd length ever) It can contain as many (if you are reading this from your editor the following character is backslash followed by zero that needed to be escaped with an extra backslash for doxygen) \0 as you want. This function is similar to DicomString(const char*), except it doesn't take a length. It only pad with a null character if length is odd. Definition at line 469 of file gdcmUtil.cxx. References gdcmAssertMacro. { size_t l = strlen(s); if ( l%2 ) { l++; } std::string r(s, s+l); gdcmAssertMacro( !(r.size() % 2) ); return r; }

std::string gdcm::Util::DicomString (  const char *  s, size_t  l )  [static]

Create a /DICOM/ string: It should a of even length (no odd length ever) It can contain as many (if you are reading this from your editor the following character is backslash followed by zero that needed to be escaped with an extra backslash for doxygen) \0 as you want. Definition at line 451 of file gdcmUtil.cxx. References gdcmAssertMacro. Referenced by CompareDicomString(), DicomStringEqual(), gdcm::FileHelper::SetWriteFileTypeToExplicitVR(), gdcm::FileHelper::SetWriteFileTypeToImplicitVR(), gdcm::FileHelper::SetWriteFileTypeToJPEG(), and gdcm::File::Write(). { std::string r(s, s+l); gdcmAssertMacro( !(r.size() % 2) ); // == basically 'l' is even return r; }

bool gdcm::Util::DicomStringEqual (  const std::string &  s1, const char *  s2 )  [static]

Safely check the equality of two Dicom String: Both strings should be of even length We allow padding of even length string by either a null character of a space. Definition at line 487 of file gdcmUtil.cxx. References DicomString(). Referenced by gdcm::SerieHelper::AddGdcmFile(), gdcm::File::GetNumberOfScalarComponents(), gdcm::File::IsMonochrome(), and gdcm::File::IsMonochrome1(). { // s2 is the string from the DICOM reference e.g. : 'MONOCHROME1' std::string s1_even = s1; //Never change input parameter std::string s2_even = DicomString( s2 ); if ( s1_even[s1_even.size()-1] == ' ' ) { s1_even[s1_even.size()-1] = '\0'; //replace space character by null } return s1_even == s2_even; }

std::string gdcm::Util::Format (  const char *  format,   ... )  [static]

Provide a better 'c++' approach for sprintf For example c code is: char result[2048]; // hope 2048 is enough sprintf(result, "%04x|%04x", group , elem);. c++ code is std::ostringstream buf; buf << std::right << std::setw(4) << std::setfill('0') << std::hex << group << "|" << std::right << std::setw(4) << std::setfill('0') << std::hex << elem; buf.str(); gdcm style code is string result; result = gdcm::Util::Format("%04x|%04x", group , elem); Definition at line 127 of file gdcmUtil.cxx. Referenced by GetIPAddress(), gdcm::Document::OpenFile(), gdcm::DocEntry::Print(), gdcm::Document::ReadNextDocEntry(), and gdcm::File::Write(). { char buffer[2048]; // hope 2048 is enough va_list args; va_start(args, format); vsprintf(buffer, format, args); //might be a security flaw va_end(args); // Each invocation of va_start should be matched // by a corresponding invocation of va_end // args is then 'undefined' return buffer; }

std::string gdcm::Util::GetCurrentDate (   )  [static]

Get the current date of the system in a dicom string. Definition at line 342 of file gdcmUtil.cxx. Referenced by gdcm::FileHelper::CheckMandatoryElements(). { char tmp[512]; time_t tloc; time (&tloc); strftime(tmp,512,"%Y%m%d", localtime(&tloc) ); return tmp; }

std::string gdcm::Util::GetCurrentDateTime (   )  [static]

Get both the date and time at the same time to avoid problem around midnight where the two calls could be before and after midnight. Definition at line 367 of file gdcmUtil.cxx. Referenced by CreateUniqueUID(). { char tmp[40]; long milliseconds; time_t timep; // We need implementation specific functions to obtain millisecond precision #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__) struct timeb tb; ::ftime(&tb); timep = tb.time; milliseconds = tb.millitm; #else struct timeval tv; gettimeofday (&tv, NULL); timep = tv.tv_sec; // Compute milliseconds from microseconds. milliseconds = tv.tv_usec / 1000; #endif // Obtain the time of day, and convert it to a tm struct. struct tm *ptm = localtime (&timep); // Format the date and time, down to a single second. strftime (tmp, sizeof (tmp), "%Y%m%d%H%M%S", ptm); // Add milliseconds // Don't use Util::Format to accelerate execution of code char tmpAll[80]; sprintf(tmpAll,"%s%03ld",tmp,milliseconds); return tmpAll; }

unsigned int gdcm::Util::GetCurrentProcessID (   )  [static]

Definition at line 420 of file gdcmUtil.cxx. { #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__) // NOTE: There is also a _getpid()... return (unsigned int)GetCurrentProcessId(); #else // get process identification, POSIX return (unsigned int)getpid(); #endif }

unsigned int gdcm::Util::GetCurrentThreadID (   )  [static]

Definition at line 399 of file gdcmUtil.cxx. { // FIXME the implementation is far from complete #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__) return (unsigned int)GetCurrentThreadId(); #else #ifdef __linux__ return 0; // Doesn't work on fedora, but is in the man page... //return (unsigned int)gettid(); #else #ifdef __sun return (unsigned int)thr_self(); #else //default implementation return 0; #endif // __sun #endif // __linux__ #endif // Win32 }

std::string gdcm::Util::GetCurrentTime (   )  [static]

Get the current time of the system in a dicom string. Definition at line 354 of file gdcmUtil.cxx. Referenced by gdcm::FileHelper::CheckMandatoryElements(). { char tmp[512]; time_t tloc; time (&tloc); strftime(tmp,512,"%H%M%S", localtime(&tloc) ); return tmp; }

static const uint8_t* gdcm::Util::GetFileMetaInformationVersion (   )  [inline, static]

Definition at line 74 of file gdcmUtil.h. Referenced by gdcm::FileHelper::CheckMandatoryElements(). { return FileMetaInformationVersion;}

std::string gdcm::Util::GetIPAddress (   )  [static, private]

Return the IP adress of the machine writting the DICOM image. Definition at line 1090 of file gdcmUtil.cxx. References Format(), and HOST_NAME_MAX. { // This is a rip from // http://www.codeguru.com/Cpp/I-N/internet/network/article.php/c3445/ #ifndef HOST_NAME_MAX // SUSv2 guarantees that `Host names are limited to 255 bytes'. // POSIX 1003.1-2001 guarantees that `Host names (not including the // terminating NUL) are limited to HOST_NAME_MAX bytes'. #define HOST_NAME_MAX 255 // In this case we should maybe check the string was not truncated. // But I don't known how to check that... #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__) // with WinSock DLL we need to initialize the WinSock before using gethostname WORD wVersionRequested = MAKEWORD(1,0); WSADATA WSAData; int err = WSAStartup(wVersionRequested,&WSAData); if (err != 0) { // Tell the user that we could not find a usable // WinSock DLL. WSACleanup(); return "127.0.0.1"; } #endif #endif //HOST_NAME_MAX std::string str; char szHostName[HOST_NAME_MAX+1]; int r = gethostname(szHostName, HOST_NAME_MAX); if ( r == 0 ) { // Get host adresses struct hostent *pHost = gethostbyname(szHostName); for( int i = 0; pHost!= NULL && pHost->h_addr_list[i]!= NULL; i++ ) { for( int j = 0; j<pHost->h_length; j++ ) { if ( j > 0 ) str += "."; str += Util::Format("%u", (unsigned int)((unsigned char*)pHost->h_addr_list[i])[j]); } // str now contains one local IP address #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__) WSACleanup(); #endif } } // If an error occur r == -1 // Most of the time it will return 127.0.0.1... return str; }

std::string gdcm::Util::GetMACAddress (   )  [static]

Encode the mac address on a fixed lenght string of 15 characters. we save space this way. Definition at line 843 of file gdcmUtil.cxx. References gdcmWarningMacro, gdcm::getlastdigit(), and gdcm::GetMacAddrSys(). { // This code is the result of a long internet search to find something // as compact as possible (not OS independant). We only have to separate // 3 OS: Win32, SunOS and 'real' POSIX // http://groups-beta.google.com/group/comp.unix.solaris/msg/ad36929d783d63be // http://bdn.borland.com/article/0,1410,26040,00.html unsigned char addr[6]; int stat = GetMacAddrSys(addr); if (stat == 0) { // We need to convert a 6 digit number from base 256 to base 10, using integer // would requires a 48bits one. To avoid this we have to reimplement the div + modulo // with string only bool zero = false; int res; std::string sres; while(!zero) { res = getlastdigit(addr); sres.insert(sres.begin(), '0' + res); zero = (addr[0] == 0) && (addr[1] == 0) && (addr[2] == 0) && (addr[3] == 0) && (addr[4] == 0) && (addr[5] == 0); } return sres; } else { gdcmWarningMacro("Problem in finding the MAC Address"); return ""; } }

std::string gdcm::Util::GetName (  std::string const &  fullName  )  [static]

Get the (last) name of a full path file name. Parameters: fullName  file/directory name to extract end name from Definition at line 322 of file gdcmUtil.cxx. Referenced by gdcm::DicomDir::SetElement(). { std::string filename = fullName; std::string::size_type slash_pos = filename.rfind("/"); std::string::size_type backslash_pos = filename.rfind("\\"); slash_pos = slash_pos > backslash_pos ? slash_pos : backslash_pos; if (slash_pos != std::string::npos ) { return filename.substr(slash_pos + 1); } else { return filename; } }

std::string gdcm::Util::GetPath (  std::string const &  fullName  )  [static]

Get the (directory) path from a full path file name. Parameters: fullName  file/directory name to extract Path from Definition at line 301 of file gdcmUtil.cxx. { std::string res = fullName; int pos1 = res.rfind("/"); int pos2 = res.rfind("\\"); if ( pos1 > pos2 ) { res.resize(pos1); } else { res.resize(pos2); } return res; }

const std::string & gdcm::Util::GetRootUID (   )  [static]

Definition at line 932 of file gdcmUtil.cxx. References RootUID. { return RootUID; }

static std::string gdcm::Util::GetVersion (   )  [inline, static]

Provides a simple static GetVersion() function. Definition at line 57 of file gdcmUtil.h. Referenced by gdcm::FileHelper::CheckMandatoryElements(). { return GDCM_VERSION;}

static void gdcm::Util::hifpswap (  double *  a, double *  b )  [inline, static]

Definition at line 85 of file gdcmUtil.h. { double tmp; tmp = *a; *a = *b; *b = tmp; }

static void gdcm::Util::hNoifpswap (  double *  a, double *  b )  [inline, static]

Definition at line 92 of file gdcmUtil.h. { double tmp; tmp = *a; *a = *b; *b = tmp; }

bool gdcm::Util::IsCleanArea (  uint8_t *  s, int  l )  [static]

Checks whether an 'area' is printable or not (in order to avoid corrupting the terminal of invocation when printing). Parameters: s  area to check (uint8_t is just for prototyping. feel free to cast) l  area length to check Definition at line 212 of file gdcmUtil.cxx. Referenced by gdcm::DocEntrySet::GetEntryForcedAsciiValue(), and gdcm::DataEntry::Print(). { for( int i=0; i<l; i++) { if (!isprint((unsigned char)s[i]) ) { return false; } } return true; }

bool gdcm::Util::IsCleanString (  std::string const &  s  )  [static]

Checks whether a 'string' is printable or not (in order to avoid corrupting the terminal of invocation when printing). Parameters: s  string to check Definition at line 193 of file gdcmUtil.cxx. { //std::cout<< std::endl << s << std::endl; for(unsigned int i=0; i<s.size(); i++) { if (!isprint((unsigned char)s[i]) ) { return false; } } return true; }

bool gdcm::Util::IsCurrentProcessorBigEndian (   )  [static]

tells us whether the processor we are working with is BigEndian or not Definition at line 434 of file gdcmUtil.cxx. Referenced by gdcm::Document::CheckSwap(), and gdcm::RLEFramesInfo::ConvertRLE16BitsFromRLE8Bits(). { #if defined(GDCM_WORDS_BIGENDIAN) return true; #else return false; #endif }

std::string gdcm::Util::NormalizePath (  std::string const &  pathname  )  [static]

Add a SEPARATOR to the end of the name is necessary. Parameters: pathname  file/directory name to normalize Definition at line 282 of file gdcmUtil.cxx. Referenced by gdcm::DirList::Explore(). { const char SEPARATOR_X = '/'; const char SEPARATOR_WIN = '\\'; const std::string SEPARATOR = "/"; std::string name = pathname; int size = name.size(); if ( name[size-1] != SEPARATOR_X && name[size-1] != SEPARATOR_WIN ) { name += SEPARATOR; } return name; }

static void gdcm::Util::SetFileMetaInformationVersion (  uint16_t  fmiv  )  [inline, static]

Definition at line 76 of file gdcmUtil.h. { FileMetaInformationVersion = (uint8_t *)&fmiv; }

void gdcm::Util::SetRootUID (  const std::string &  root = ""  )  [static]

Definition at line 924 of file gdcmUtil.cxx. References GDCM_UID, and RootUID. { if ( root.empty() ) RootUID = GDCM_UID; else RootUID = root; }

void gdcm::Util::Tokenize (  const std::string &  str, std::vector< std::string > &  tokens, const std::string &  delimiters = " " )  [static]

Because not available in C++ (?). Parameters: str  string to check tokens  std::vector to receive the tokenized substrings delimiters  string containing the character delimitors Definition at line 147 of file gdcmUtil.cxx. Referenced by gdcm::File::GetLUTNbits(), and gdcm::DataEntry::SetString(). { std::string::size_type lastPos = str.find_first_not_of(delimiters,0); std::string::size_type pos = str.find_first_of (delimiters,lastPos); while (std::string::npos != pos || std::string::npos != lastPos) { tokens.push_back(str.substr(lastPos, pos - lastPos)); lastPos = str.find_first_not_of(delimiters, pos); pos = str.find_first_of (delimiters, lastPos); } }

---

Member Data Documentation

uint8_t * gdcm::Util::FileMetaInformationVersion = (uint8_t *)&FMIV [static, private]

Definition at line 105 of file gdcmUtil.h.

const uint16_t gdcm::Util::FMIV = 0x0100 [static, private]

Definition at line 106 of file gdcmUtil.h.

std::string gdcm::Util::GDCM_MAC_ADRESS = GetMACAddress() [static, private]

Definition at line 107 of file gdcmUtil.h. Referenced by CreateUniqueUID().

const std::string gdcm::Util::GDCM_UID = "1.2.826.0.1.3680043.2.1143" [static, private]

Definition at line 104 of file gdcmUtil.h. Referenced by SetRootUID().

std::string gdcm::Util::RootUID = GDCM_UID [static, private]

Definition at line 103 of file gdcmUtil.h. Referenced by CreateUniqueUID(), GetRootUID(), and SetRootUID().

---

The documentation for this class was generated from the following files:

• gdcmUtil.h
• gdcmUtil.cxx

---