gdcm::Util Class Reference

Here are some utility functions, belonging to the 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
std::string	Format (const char *format,...)
	Provide a better 'c++' approach for sprintf For example c code is: sprintf(trash, "%04x|%04x", group , elem);.
void	Tokenize (const std::string &str, std::vector< std::string > &tokens, const std::string &delimiters="")
	Because not available in C++ (?).
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.
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).
std::string	NormalizePath (std::string const &name)
	Add a SEPARATOR to the end of the name is necessary.
std::string	GetPath (std::string const &fullName)
	Get the (directory) path from a full path file name.
std::string	GetName (std::string const &fullName)
	Get the (last) name of a full path file name.
std::string	GetCurrentDate ()
	Get the current date of the system in a dicom string.
std::string	GetCurrentTime ()
	Get the current time of the system in a dicom string.
std::string	GetCurrentDateTime ()
	Get both the date and time at the same time to avoid problem around midnight where two call could be before and after midnight.
unsigned int	GetCurrentThreadID ()
unsigned int	GetCurrentProcessID ()
bool	IsCurrentProcessorBigEndian ()
	tells us if the processor we are working with is BigEndian or not
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 is backslash followed by zero that needed to be escaped with an extra backslash for doxygen) \0 as you want.
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 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.
bool	DicomStringEqual (const std::string &s1, const char *s2)
	Safely compare two Dicom String: -Both string should be of even length -We allow padding of even length string by either a null character of a space.
std::string	GetMACAddress ()
	Encode the mac address on a fixed lenght string of 15 characters. we save space this way.
std::string	CreateUniqueUID (const std::string &root="")
	Creates a new UID. As stipulate in the DICOM ref each time a DICOM image is create it should have a unique identifier (URI).
void	SetRootUID (const std::string &root="")
const std::string &	GetRootUID ()
Static Private Member Functions
std::string	GetIPAddress ()
	Return the IP adress of the machine writting the DICOM image.
Static Private Attributes
std::string	RootUID = GDCM_UID
const std::string	GDCM_UID = "1.2.826.0.1.3680043.2.1143"

---

Detailed Description

Here are some utility functions, belonging to the 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

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. Definition at line 148 of file gdcmUtil.cxx. { 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 (  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 remove non printable characters from Definition at line 173 of file gdcmUtil.cxx. { 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 stipulate in the DICOM ref each time a DICOM image is create it should have a unique identifier (URI). Parameters: root  is the DICOM prefix assigned by IOS group Definition at line 762 of file gdcmUtil.cxx. References Format(), gdcmErrorMacro, and RootUID. Referenced by vtkGdcmWriter::WriteDcmFile(). { 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(); append += "."; append += Util::GetCurrentDateTime(); //Also add a mini random number just in case: int r = (int) (100.0*rand()/RAND_MAX); append += Format("%02d", r); // 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 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 387 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 is backslash followed by zero that needed to be escaped with an extra backslash for doxygen) \0 as you want. Definition at line 369 of file gdcmUtil.cxx. References gdcmAssertMacro. Referenced by DicomStringEqual(). { 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 compare two Dicom String: -Both string should be of even length -We allow padding of even length string by either a null character of a space. Definition at line 405 of file gdcmUtil.cxx. References DicomString(). { // s2 is the string from the DICOM reference: '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: sprintf(trash, "%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 Format("%04x|%04x", group , elem); Definition at line 113 of file gdcmUtil.cxx. Referenced by CreateUniqueUID(), and GetCurrentDateTime(). { char buffer[2048]; 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 263 of file gdcmUtil.cxx. { 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 two call could be before and after midnight. Definition at line 288 of file gdcmUtil.cxx. References Format(). { 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 std::string r = tmp; r += Format("%03ld", milliseconds); return r; }

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

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

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

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

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

Return the IP adress of the machine writting the DICOM image. Definition at line 884 of file gdcmUtil.cxx. References 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 722 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 243 of file gdcmUtil.cxx. { 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 222 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 806 of file gdcmUtil.cxx. References RootUID. { return RootUID; }

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

tells us if the processor we are working with is BigEndian or not Definition at line 352 of file gdcmUtil.cxx. { #ifdef 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 203 of file gdcmUtil.cxx. { 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; }

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

Definition at line 798 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++ (?). Definition at line 129 of file gdcmUtil.cxx. { 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

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

Definition at line 93 of file gdcmUtil.cxx. Referenced by SetRootUID().

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

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

---

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

• gdcmUtil.h
• gdcmUtil.cxx

---