utils.cpp

Go to the documentation of this file.
00001 // -*- c-basic-offset: 4 -*-
00002 
00025 #include "utils.h"
00026 #include "hugin_version.h"
00027 #include "hugin_config.h"
00028 
00029 #ifdef _WIN32
00030     #define NOMINMAX
00031     #include <sys/utime.h>
00032     #include <ShlObj.h>
00033 #else
00034     #include <sys/time.h>
00035     #include <cstdlib>
00036     #include <unistd.h>
00037     #include <sys/types.h>
00038     #include <pwd.h>
00039 #endif
00040 #include <time.h>
00041 #include <fstream>
00042 #include <stdio.h>
00043 #include <cstdio>
00044 #ifdef _WIN32
00045 #define NOMINMAX
00046 #include <windows.h>
00047 #else
00048 #include <hugin_config.h>
00049 #endif
00050 #include <algorithm>
00051 #ifdef HAVE_STD_FILESYSTEM
00052 #include <filesystem>
00053 namespace fs = std::tr2::sys;
00054 #else
00055 #define BOOST_FILESYSTEM_VERSION 3
00056 #include <boost/filesystem.hpp>
00057 namespace fs = boost::filesystem;
00058 #endif
00059 #include <lcms2.h>
00060 
00061 #ifdef __APPLE__
00062 #include <mach-o/dyld.h>  /* _NSGetExecutablePath */
00063 #include <limits.h>       /* PATH_MAX */
00064 #include <libgen.h>       /* dirname */
00065 #endif
00066 
00067 #include <GL/glew.h>
00068 #ifdef _WIN32
00069 #include <GL/wglew.h>
00070 #elif defined __APPLE__
00071   #include <GLUT/glut.h>
00072 #endif
00073 
00074 namespace hugin_utils {
00075     
00076 #ifdef UNIX_LIKE
00077 std::string GetCurrentTimeString()
00078 {
00079   char tmp[100];
00080   struct tm t;
00081   struct timeval tv;
00082   gettimeofday(&tv,NULL);
00083   localtime_r((time_t*)&tv.tv_sec, &t); // is the casting safe?
00084   strftime(tmp,99,"%H:%M:%S",&t);
00085   sprintf(tmp+8,".%06ld", (long)tv.tv_usec);
00086   return tmp;
00087 }
00088 #else
00089 std::string GetCurrentTimeString()
00090 {
00091     // FIXME implement for Win
00092     return "";
00093 }
00094 #endif
00095 
00096 
00097 std::string getExtension(const std::string & basename2)
00098 {
00099         std::string::size_type idx = basename2.rfind('.');
00100     // check if the dot is not followed by a \ or a /
00101     // to avoid cutting pathes.
00102     if (idx == std::string::npos) {
00103         // no dot found
00104                 return std::string("");
00105     }
00106 #ifdef UNIX_LIKE
00107     // check for slashes after dot
00108     std::string::size_type slashidx = basename2.find('/', idx);
00109     if ( slashidx == std::string::npos)
00110     {
00111         return basename2.substr(idx+1);
00112     } else {
00113         return std::string("");
00114     }
00115 #else
00116     // check for slashes after dot
00117     std::string::size_type slashidx = basename2.find('/', idx);
00118     std::string::size_type backslashidx = basename2.find('\\', idx);
00119     if ( slashidx == std::string::npos &&  backslashidx == std::string::npos)
00120     {
00121         return basename2.substr(idx+1);
00122     } else {
00123                 return std::string("");
00124     }
00125 #endif
00126 }
00127 
00128 std::string stripExtension(const std::string & basename2)
00129 {
00130     std::string::size_type idx = basename2.rfind('.');
00131     // check if the dot is not followed by a \ or a /
00132     // to avoid cutting pathes.
00133     if (idx == std::string::npos) {
00134         // no dot found
00135         return basename2;
00136     }
00137 #ifdef UNIX_LIKE
00138     std::string::size_type slashidx = basename2.find('/', idx);
00139     if ( slashidx == std::string::npos)
00140     {
00141         return basename2.substr(0, idx);
00142     } else {
00143         return basename2;
00144     }
00145 #else
00146     // check for slashes after dot
00147     std::string::size_type slashidx = basename2.find('/', idx);
00148     std::string::size_type backslashidx = basename2.find('\\', idx);
00149     if ( slashidx == std::string::npos &&  backslashidx == std::string::npos)
00150     {
00151         return basename2.substr(0, idx);
00152     } else {
00153         return basename2;
00154     }
00155 #endif
00156 }
00157 
00158 std::string stripPath(const std::string & filename)
00159 {
00160 #ifdef UNIX_LIKE
00161     std::string::size_type idx = filename.rfind('/');
00162 #else
00163     std::string::size_type idx1 = filename.rfind('\\');
00164     std::string::size_type idx2 = filename.rfind('/');
00165     std::string::size_type idx;
00166     if (idx1 == std::string::npos) {
00167         idx = idx2;
00168     } else if (idx2 == std::string::npos) {
00169         idx = idx1;
00170     } else {
00171         idx = std::max(idx1, idx2);
00172     }
00173 #endif
00174     if (idx != std::string::npos) {
00175 //        DEBUG_DEBUG("returning substring: " << filename.substr(idx + 1));
00176         return filename.substr(idx + 1);
00177     } else {
00178         return filename;
00179     }
00180 }
00181 
00182 std::string getPathPrefix(const std::string & filename)
00183 {
00184 #ifdef UNIX_LIKE
00185     std::string::size_type idx = filename.rfind('/');
00186 #else
00187     std::string::size_type idx1 = filename.rfind('\\');
00188     std::string::size_type idx2 = filename.rfind('/');
00189     std::string::size_type idx;
00190     if (idx1 == std::string::npos) {
00191         idx = idx2;
00192     } else if (idx2 == std::string::npos) {
00193         idx = idx1;
00194     } else {
00195         idx = std::max(idx1, idx2);
00196     }
00197 #endif
00198     if (idx != std::string::npos) {
00199 //        DEBUG_DEBUG("returning substring: " << filename.substr(idx + 1));
00200         return filename.substr(0, idx+1);
00201     } else {
00202         return "";
00203     }
00204 }
00205 
00206 std::string StrTrim(const std::string& str)
00207 {
00208     std::string s(str);
00209     std::string::size_type pos = s.find_last_not_of(" \t");
00210     if (pos != std::string::npos)
00211     {
00212         s.erase(pos + 1);
00213         pos = s.find_first_not_of(" \t");
00214         if (pos != std::string::npos)
00215         {
00216             s.erase(0, pos);
00217         };
00218     }
00219     else
00220     {
00221         s.erase(s.begin(), s.end());
00222     };
00223     return s;
00224 }
00225 
00226 std::string doubleToString(double d, int digits)
00227 {
00228     char fmt[10];
00229     if (digits < 0) {
00230         strcpy(fmt,"%f");
00231     } else {
00232         std::sprintf(fmt,"%%.%df",digits);
00233     }
00234     char c[1024];
00235     c[1023] = 0;
00236 #ifdef _MSC_VER
00237     _snprintf (c, 1023, fmt, d);
00238 #else
00239     snprintf (c, 1023, fmt, d);
00240 #endif
00241 
00242     std::string number (c);
00243 
00244     int l = (int)number.length()-1;
00245 
00246     while ( l != 0 && number[l] == '0' ) {
00247       number.erase (l);
00248       l--;
00249     }
00250     if ( number[l] == ',' ) {
00251       number.erase (l);
00252       l--;
00253     }
00254     if ( number[l] == '.' ) {
00255       number.erase (l);
00256       l--;
00257     }
00258     return number;
00259 }
00260 
00261 bool stringToInt(const std::string& s, int& val)
00262 {
00263     if (StrTrim(s) == "0")
00264     {
00265         val = 0;
00266         return true;
00267     };
00268     int x = atoi(s.c_str());
00269     if (x != 0)
00270     {
00271         val = x;
00272         return true;
00273     };
00274     return false;
00275 };
00276 
00277 bool stringToUInt(const std::string&s, unsigned int& val)
00278 {
00279     int x;
00280     if (stringToInt(s, x))
00281     {
00282         if (x >= 0)
00283         {
00284             val = static_cast<unsigned int>(x);
00285             return true;
00286         };
00287     };
00288     return false;
00289 };
00290 
00291 std::vector<std::string> SplitString(const std::string& s, const std::string& sep)
00292 {
00293     std::vector<std::string> result;
00294     std::size_t pos = s.find_first_of(sep, 0);
00295     std::size_t pos2 = 0;
00296     while (pos != std::string::npos)
00297     {
00298         if (pos - pos2 > 0)
00299         {
00300             std::string t(s.substr(pos2, pos - pos2));
00301             t=StrTrim(t);
00302             if (!t.empty())
00303             {
00304                 result.push_back(t);
00305             };
00306         };
00307         pos2 = pos + 1;
00308         pos = s.find_first_of(sep, pos2);
00309     }
00310     if (pos2 < s.length())
00311     {
00312         std::string t(s.substr(pos2));
00313         t = StrTrim(t);
00314         if (!t.empty())
00315         {
00316             result.push_back(t);
00317         };
00318     };
00319     return result;
00320 };
00321 
00322 void ReplaceAll(std::string& s, const std::string& oldChar, char newChar)
00323 {
00324     std::size_t found = s.find_first_of(oldChar);
00325     while (found != std::string::npos)
00326     {
00327         s[found] = newChar;
00328         found = s.find_first_of(oldChar, found + 1);
00329     };
00330 };
00331 
00332     void ControlPointErrorColour(const double cperr, 
00333         double &r,double &g, double &b)
00334     {
00335         //Colour change points
00336 #define XP1 5.0f
00337 #define XP2 10.0f
00338 
00339         if ( cperr<= XP1) 
00340         {
00341             //low error
00342             r = cperr / XP1;
00343             g = 0.75;
00344         }
00345         else
00346         {
00347             r = 1.0;
00348             g = 0.75 * ((1.0 - std::min<double>(cperr - XP1, XP2 - XP1) / (XP2 - XP1)));
00349         } 
00350         b = 0.0;
00351     }
00352 
00353 bool FileExists(const std::string& filename)
00354 {
00355     std::ifstream ifile(filename.c_str());
00356     return !ifile.fail();
00357 }
00358 
00359 std::string GetAbsoluteFilename(const std::string& filename)
00360 {
00361 #ifdef _WIN32
00362     char fullpath[_MAX_PATH];
00363     _fullpath(fullpath,filename.c_str(),_MAX_PATH);
00364     return std::string(fullpath);
00365 #else
00366     //realpath works only with existing files
00367     //so as work around we create the file first, call then realpath 
00368     //and delete the temp file
00370     bool tempFileCreated=false;
00371     if(!FileExists(filename))
00372     {
00373         tempFileCreated=true;
00374         std::ofstream os(filename.c_str());
00375         os.close();
00376     };
00377     char *real_path = realpath(filename.c_str(), NULL);
00378     std::string absPath;
00379     if(real_path!=NULL)
00380     {
00381         absPath=std::string(real_path);
00382         free(real_path);
00383     }
00384     else
00385     {
00386         absPath=filename;
00387     };
00388     if(tempFileCreated)
00389     {
00390         remove(filename.c_str());
00391     };
00392     return absPath;
00393 #endif
00394 };
00395 
00396 std::string GetDataDir()
00397 {
00398 #ifdef _WIN32
00399     char buffer[MAX_PATH];//always use MAX_PATH for filepaths
00400     GetModuleFileName(NULL,buffer,sizeof(buffer));
00401     std::string working_path(buffer);
00402     std::string data_path("");
00403     //remove filename
00404     std::string::size_type pos=working_path.rfind("\\");
00405     if(pos!=std::string::npos)
00406     {
00407         working_path.erase(pos);
00408         //remove last dir: should be bin
00409         pos=working_path.rfind("\\");
00410         if(pos!=std::string::npos)
00411         {
00412             working_path.erase(pos);
00413             //append path delimiter and path
00414             working_path.append("\\share\\hugin\\data\\");
00415             data_path=working_path;
00416         }
00417     }
00418 #elif defined MAC_SELF_CONTAINED_BUNDLE
00419     char path[PATH_MAX + 1];
00420     uint32_t size = sizeof(path);
00421     std::string data_path("");
00422     if (_NSGetExecutablePath(path, &size) == 0)
00423     {
00424         data_path=dirname(path);
00425         data_path.append("/../Resources/xrc/");
00426     }
00427 #else
00428     std::string data_path = (INSTALL_DATA_DIR);
00429 #endif
00430     return data_path;
00431 };
00432 
00433 std::string GetUserAppDataDir()
00434 {
00435     fs::path path;
00436 #ifdef _WIN32
00437     char fullpath[_MAX_PATH];
00438     if(SHGetFolderPath(NULL, CSIDL_APPDATA | CSIDL_FLAG_CREATE, NULL, 0, fullpath)!=S_OK)
00439     {
00440         return std::string();
00441     };
00442     path = fs::path(fullpath);
00443     path /= "hugin";
00444 #else
00445     char *homedir = getenv("HOME");
00446     struct passwd *pw;
00447     if (homedir == NULL)
00448     {
00449         pw = getpwuid(getuid());
00450         if(pw != NULL)
00451         {
00452             homedir = pw->pw_dir;
00453         };
00454     };
00455     if(homedir == NULL)
00456     {
00457         return std::string();
00458     };
00459     path = fs::path(homedir);
00460     // we have already a file with name ".hugin" for our wxWidgets settings
00461     // therefore we use directory ".hugindata" in homedir
00462     path /= ".hugindata";
00463 #endif
00464     if (!fs::exists(path))
00465     {
00466         if (!fs::create_directories(path))
00467         {
00468             std::cerr << "ERROR: Could not create destination directory: " << path.string() << std::endl
00469                 << "Maybe you have not sufficent rights to create this directory." << std::endl;
00470             return std::string();
00471         };
00472     };
00473     return path.string();
00474 };
00475 
00476 // initialization and wrapup of GPU for GPU remapping
00477 #ifdef _WIN32
00478 struct ContextSettings
00479 {
00480     HWND window;
00481     HDC dc;
00482     HGLRC renderingContext;
00483     
00484     ContextSettings()
00485     {
00486         window = NULL;
00487         dc = NULL;
00488         renderingContext = NULL;
00489     }
00490 };
00491 static ContextSettings context;
00492 
00493 // create context, return false if failed
00494 bool CreateContext(int *argcp, char **argv)
00495 {
00496     WNDCLASS windowClass;
00497     /* register window class */
00498     ZeroMemory(&windowClass, sizeof(WNDCLASS));
00499     windowClass.hInstance = GetModuleHandle(NULL);
00500     windowClass.lpfnWndProc = DefWindowProc;
00501     windowClass.lpszClassName = "Hugin";
00502     if (RegisterClass(&windowClass) == 0)
00503     {
00504         return false;
00505     };
00506     /* create window */
00507     context.window = CreateWindow("Hugin", "Hugin", 0, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
00508         CW_USEDEFAULT, NULL, NULL, GetModuleHandle(NULL), NULL);
00509     if (context.window == NULL)
00510     {
00511         return false;
00512     };
00513     /* get the device context */
00514     context.dc = GetDC(context.window);
00515     if (context.dc == NULL)
00516     {
00517         return false;
00518     };
00519     /* find pixel format */
00520     PIXELFORMATDESCRIPTOR pixelFormatDesc;
00521     ZeroMemory(&pixelFormatDesc, sizeof(PIXELFORMATDESCRIPTOR));
00522     pixelFormatDesc.nSize = sizeof(PIXELFORMATDESCRIPTOR);
00523     pixelFormatDesc.nVersion = 1;
00524     pixelFormatDesc.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
00525     int pixelFormat = ChoosePixelFormat(context.dc, &pixelFormatDesc);
00526     if (pixelFormat == 0)
00527     {
00528         return false;
00529     }
00530     /* set the pixel format for the dc */
00531     if (SetPixelFormat(context.dc, pixelFormat, &pixelFormatDesc) == FALSE)
00532     {
00533         return false;
00534     };
00535     /* create rendering context */
00536     context.renderingContext = wglCreateContext(context.dc);
00537     if (context.renderingContext == NULL)
00538     {
00539         return false;
00540     };
00541     if (wglMakeCurrent(context.dc, context.renderingContext) == FALSE)
00542     {
00543         return false;
00544     };
00545     return true;
00546 }
00547 
00548 void DestroyContext()
00549 {
00550     if (context.renderingContext != NULL)
00551     {
00552         wglMakeCurrent(NULL, NULL);
00553         wglDeleteContext(context.renderingContext);
00554     }
00555     if (context.window != NULL && context.dc != NULL)
00556     {
00557         ReleaseDC(context.window, context.dc);
00558     };
00559     if (context.window != NULL)
00560     {
00561         DestroyWindow(context.window);
00562     };
00563     UnregisterClass("Hugin", GetModuleHandle(NULL));
00564 }
00565 
00566 #elif defined __APPLE__
00567 static GLuint GlutWindowHandle;
00568 bool CreateContext(int *argcp, char **argv)
00569 {
00570     glutInit(argcp, argv);
00571     glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA | GLUT_ALPHA);
00572     GlutWindowHandle = glutCreateWindow("Hugin");
00573     return true;
00574 }
00575 
00576 void DestroyContext()
00577 {
00578     glutDestroyWindow(GlutWindowHandle);
00579 }
00580 
00581 #else
00582 #include <X11/Xlib.h>
00583 #include <X11/Xutil.h>
00584 #include <GL/glx.h>
00585 
00586 struct ContextSettings
00587 {
00588     Display* display;
00589     XVisualInfo* visualInfo;
00590     GLXContext context;
00591     Window window;
00592     Colormap colormap;
00593     
00594     ContextSettings()
00595     {
00596         display=NULL;
00597         visualInfo=NULL;
00598         context=NULL;
00599         window=0;
00600         colormap=0;
00601     };
00602 };
00603 
00604 static ContextSettings context;
00605 
00606 bool CreateContext(int *argcp, char **argv)
00607 {
00608     /* open display */
00609     context.display = XOpenDisplay(NULL);
00610     if (context.display == NULL)
00611     {
00612         return false;
00613     };
00614     /* query for glx */
00615     int erb, evb;
00616     if (!glXQueryExtension(context.display, &erb, &evb))
00617     {
00618         return false;
00619     };
00620     /* choose visual */
00621     int attrib[] = { GLX_RGBA, None };
00622     context.visualInfo = glXChooseVisual(context.display, DefaultScreen(context.display), attrib);
00623     if (context.visualInfo == NULL)
00624     {
00625         return false;
00626     };
00627     /* create context */
00628     context.context = glXCreateContext(context.display, context.visualInfo, None, True);
00629     if (context.context == NULL)
00630     {
00631         return false;
00632     };
00633     /* create window */
00634     context.colormap = XCreateColormap(context.display, RootWindow(context.display, context.visualInfo->screen), context.visualInfo->visual, AllocNone);
00635     XSetWindowAttributes swa;
00636     swa.border_pixel = 0;
00637     swa.colormap = context.colormap;
00638     context.window = XCreateWindow(context.display, RootWindow(context.display, context.visualInfo->screen),
00639         0, 0, 1, 1, 0, context.visualInfo->depth, InputOutput, context.visualInfo->visual,
00640         CWBorderPixel | CWColormap, &swa);
00641     /* make context current */
00642     if (!glXMakeCurrent(context.display, context.window, context.context))
00643     {
00644         return false;
00645     };
00646     return true;
00647 };
00648 
00649 void DestroyContext()
00650 {
00651     if (context.display != NULL && context.context != NULL)
00652     {
00653         glXDestroyContext(context.display, context.context);
00654     }
00655     if (context.display != NULL && context.window != 0)
00656     {
00657         XDestroyWindow(context.display, context.window);
00658     };
00659     if (context.display != NULL && context.colormap != 0)
00660     {
00661         XFreeColormap(context.display, context.colormap);
00662     };
00663     if (context.visualInfo != NULL)
00664     {
00665         XFree(context.visualInfo);
00666     };
00667     if (context.display != NULL)
00668     {
00669         XCloseDisplay(context.display);
00670     };
00671 };
00672 #endif
00673 
00674 bool initGPU(int *argcp, char **argv)
00675 {
00676     if (!CreateContext(argcp, argv))
00677     {
00678         return false;
00679     };
00680     int err = glewInit();
00681     if (err != GLEW_OK)
00682     {
00683         std::cerr << argv[0] << ": an error occurred while setting up the GPU:" << std::endl;
00684         std::cerr << glewGetErrorString(err) << std::endl;
00685         std::cerr << argv[0] << ": Switching to CPU calculation." << std::endl;
00686         DestroyContext();
00687         return false;
00688     }
00689 
00690     std::cout << hugin_utils::stripPath(argv[0]) << ": using graphics card: " << glGetString(GL_VENDOR) << " " << glGetString(GL_RENDERER) << std::endl;
00691 
00692     const GLboolean has_arb_fragment_shader = glewGetExtension("GL_ARB_fragment_shader");
00693     const GLboolean has_arb_vertex_shader = glewGetExtension("GL_ARB_vertex_shader");
00694     const GLboolean has_arb_shader_objects = glewGetExtension("GL_ARB_shader_objects");
00695     const GLboolean has_arb_shading_language = glewGetExtension("GL_ARB_shading_language_100");
00696     const GLboolean has_ext_framebuffer = glewGetExtension("GL_EXT_framebuffer_object");
00697     const GLboolean has_arb_texture_rectangle = glewGetExtension("GL_ARB_texture_rectangle");
00698     const GLboolean has_arb_texture_border_clamp = glewGetExtension("GL_ARB_texture_border_clamp");
00699     const GLboolean has_arb_texture_float = glewGetExtension("GL_ARB_texture_float");
00700 
00701     if (!(has_arb_fragment_shader && has_arb_vertex_shader && has_arb_shader_objects && has_arb_shading_language && has_ext_framebuffer && has_arb_texture_rectangle && has_arb_texture_border_clamp && has_arb_texture_float)) {
00702         const char * msg[] = {"false", "true"};
00703         std::cerr << argv[0] << ": extension GL_ARB_fragment_shader = " << msg[has_arb_fragment_shader] << std::endl;
00704         std::cerr << argv[0] << ": extension GL_ARB_vertex_shader = " << msg[has_arb_vertex_shader] << std::endl;
00705         std::cerr << argv[0] << ": extension GL_ARB_shader_objects = " << msg[has_arb_shader_objects] << std::endl;
00706         std::cerr << argv[0] << ": extension GL_ARB_shading_language_100 = " << msg[has_arb_shading_language] << std::endl;
00707         std::cerr << argv[0] << ": extension GL_EXT_framebuffer_object = " << msg[has_ext_framebuffer] << std::endl;
00708         std::cerr << argv[0] << ": extension GL_ARB_texture_rectangle = " << msg[has_arb_texture_rectangle] << std::endl;
00709         std::cerr << argv[0] << ": extension GL_ARB_texture_border_clamp = " << msg[has_arb_texture_border_clamp] << std::endl;
00710         std::cerr << argv[0] << ": extension GL_ARB_texture_float = " << msg[has_arb_texture_float] << std::endl;
00711         std::cerr << argv[0] << ": This graphics system lacks the necessary extensions for -g." << std::endl;
00712         std::cerr << argv[0] << ": Switching to CPU calculation." << std::endl;
00713         DestroyContext();
00714         return false;
00715     }
00716 
00717     return true;
00718 }
00719 
00720 bool wrapupGPU()
00721 {
00722     DestroyContext();
00723     return true;
00724 }
00725 
00726 std::string GetHuginVersion()
00727 {
00728     return std::string(DISPLAY_VERSION);
00729 };
00730 
00731 std::string GetICCDesc(const vigra::ImageImportInfo::ICCProfile& iccProfile)
00732 {
00733     if (iccProfile.empty())
00734     {
00735         // no profile
00736         return std::string();
00737     };
00738     cmsHPROFILE profile = cmsOpenProfileFromMem(iccProfile.data(), iccProfile.size());
00739     if (profile == NULL)
00740     {
00741         // invalid profile
00742         return std::string();
00743     };
00744     const std::string name=GetICCDesc(profile);
00745     cmsCloseProfile(profile);
00746     return name;
00747 };
00748 
00749 std::string GetICCDesc(const cmsHPROFILE& profile)
00750 {
00751     const size_t size = cmsGetProfileInfoASCII(profile, cmsInfoDescription, cmsNoLanguage, cmsNoCountry, nullptr, 0);
00752     std::string information(size, '\000');
00753     cmsGetProfileInfoASCII(profile, cmsInfoDescription, cmsNoLanguage, cmsNoCountry, &information[0], size);
00754     StrTrim(information);
00755     return information;
00756 }
00757 } //namespace

Generated on 11 Feb 2016 for Hugintrunk by  doxygen 1.4.7