[
{
"path": ".gitignore",
"content": "*.txt.user\n\n*-build\n\n#################\n## openFrameworks\n#################\n\n[Bb]in/*\n![Bb]in/data/\n[Bb]uild/\n[Oo]bj/\n*.o\n[Dd]ebug*/\n[Rr]elease*/\n*.mode*\n*.app/\n*.pyc\n*.log\n\n\n\n#################\n## Code::Blocks\n#################\n\n*.cbp\n*.depend\n*.layout\n\n############\n## Windows\n############\n\n# Windows image file caches\nThumbs.db\n\n# Folder config file\nDesktop.ini\n\n*~\n"
},
{
"path": "CMakeLists.txt",
"content": "cmake_minimum_required(VERSION 2.8)\nproject(htrack)\n\n#--- Gets rid of annoying CMake 3 warnings\nif(NOT (CMAKE_MAJOR_VERSION LESS 3))\n cmake_policy(SET CMP0043 OLD)\n cmake_policy(SET CMP0020 OLD)\n cmake_policy(SET CMP0005 OLD)\nendif()\n\n#--- Where to find the FindPackageName.cmake\nset(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)\n\n#--- Where exes/libs will be deployed\nset(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR})\nset(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR})\nset(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${PROJECT_BINARY_DIR})\nset(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG ${PROJECT_BINARY_DIR})\nset(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${PROJECT_BINARY_DIR})\nset(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE ${PROJECT_BINARY_DIR})\n\n#--- Compiler setup\ninclude(cmake/ConfigureCompiler.cmake)\n\n#--- Configure the libraries\ninclude(cmake/ConfigureQt.cmake)\ninclude(cmake/ConfigureOpenGL.cmake)\ninclude(cmake/ConfigureGLEW.cmake)\ninclude(cmake/ConfigureEigen.cmake)\ninclude(cmake/ConfigureOpenCV.cmake)\ninclude(cmake/ConfigureOpenNI.cmake)\ninclude(cmake/ConfigureRealSense.cmake)\ninclude(cmake/ConfigureLibRealSense.cmake)\ninclude(cmake/ConfigureSoftKinetic.cmake)\ninclude(cmake/ConfigureCUDA.cmake)\ninclude(cmake/ConfigureAntTweakBar.cmake)\n\n#--- sub-projects\nadd_subdirectory(util)\nadd_subdirectory(cudax)\nadd_subdirectory(tracker)\n\n#--- Choose which sensor to use\ninclude(cmake/ConfigureSensor.cmake)\nadd_definitions(${DEFINITION_SENSOR})\n\nadd_subdirectory(apps/htrack_atb)\nadd_subdirectory(apps/htrack_qt)\nadd_subdirectory(apps/colorpick)\n#add_subdirectory(apps/synthgen) #<<< NOT READY\n"
},
{
"path": "COPYING.txt",
"content": " GNU LESSER GENERAL PUBLIC LICENSE\n Version 3, 29 June 2007\n\n Copyright (C) 2007 Free Software Foundation, Inc. \n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n\n This version of the GNU Lesser General Public License incorporates\nthe terms and conditions of version 3 of the GNU General Public\nLicense, supplemented by the additional permissions listed below.\n\n 0. Additional Definitions.\n\n As used herein, \"this License\" refers to version 3 of the GNU Lesser\nGeneral Public License, and the \"GNU GPL\" refers to version 3 of the GNU\nGeneral Public License.\n\n \"The Library\" refers to a covered work governed by this License,\nother than an Application or a Combined Work as defined below.\n\n An \"Application\" is any work that makes use of an interface provided\nby the Library, but which is not otherwise based on the Library.\nDefining a subclass of a class defined by the Library is deemed a mode\nof using an interface provided by the Library.\n\n A \"Combined Work\" is a work produced by combining or linking an\nApplication with the Library. The particular version of the Library\nwith which the Combined Work was made is also called the \"Linked\nVersion\".\n\n The \"Minimal Corresponding Source\" for a Combined Work means the\nCorresponding Source for the Combined Work, excluding any source code\nfor portions of the Combined Work that, considered in isolation, are\nbased on the Application, and not on the Linked Version.\n\n The \"Corresponding Application Code\" for a Combined Work means the\nobject code and/or source code for the Application, including any data\nand utility programs needed for reproducing the Combined Work from the\nApplication, but excluding the System Libraries of the Combined Work.\n\n 1. Exception to Section 3 of the GNU GPL.\n\n You may convey a covered work under sections 3 and 4 of this License\nwithout being bound by section 3 of the GNU GPL.\n\n 2. Conveying Modified Versions.\n\n If you modify a copy of the Library, and, in your modifications, a\nfacility refers to a function or data to be supplied by an Application\nthat uses the facility (other than as an argument passed when the\nfacility is invoked), then you may convey a copy of the modified\nversion:\n\n a) under this License, provided that you make a good faith effort to\n ensure that, in the event an Application does not supply the\n function or data, the facility still operates, and performs\n whatever part of its purpose remains meaningful, or\n\n b) under the GNU GPL, with none of the additional permissions of\n this License applicable to that copy.\n\n 3. Object Code Incorporating Material from Library Header Files.\n\n The object code form of an Application may incorporate material from\na header file that is part of the Library. You may convey such object\ncode under terms of your choice, provided that, if the incorporated\nmaterial is not limited to numerical parameters, data structure\nlayouts and accessors, or small macros, inline functions and templates\n(ten or fewer lines in length), you do both of the following:\n\n a) Give prominent notice with each copy of the object code that the\n Library is used in it and that the Library and its use are\n covered by this License.\n\n b) Accompany the object code with a copy of the GNU GPL and this license\n document.\n\n 4. Combined Works.\n\n You may convey a Combined Work under terms of your choice that,\ntaken together, effectively do not restrict modification of the\nportions of the Library contained in the Combined Work and reverse\nengineering for debugging such modifications, if you also do each of\nthe following:\n\n a) Give prominent notice with each copy of the Combined Work that\n the Library is used in it and that the Library and its use are\n covered by this License.\n\n b) Accompany the Combined Work with a copy of the GNU GPL and this license\n document.\n\n c) For a Combined Work that displays copyright notices during\n execution, include the copyright notice for the Library among\n these notices, as well as a reference directing the user to the\n copies of the GNU GPL and this license document.\n\n d) Do one of the following:\n\n 0) Convey the Minimal Corresponding Source under the terms of this\n License, and the Corresponding Application Code in a form\n suitable for, and under terms that permit, the user to\n recombine or relink the Application with a modified version of\n the Linked Version to produce a modified Combined Work, in the\n manner specified by section 6 of the GNU GPL for conveying\n Corresponding Source.\n\n 1) Use a suitable shared library mechanism for linking with the\n Library. A suitable mechanism is one that (a) uses at run time\n a copy of the Library already present on the user's computer\n system, and (b) will operate properly with a modified version\n of the Library that is interface-compatible with the Linked\n Version.\n\n e) Provide Installation Information, but only if you would otherwise\n be required to provide such information under section 6 of the\n GNU GPL, and only to the extent that such information is\n necessary to install and execute a modified version of the\n Combined Work produced by recombining or relinking the\n Application with a modified version of the Linked Version. (If\n you use option 4d0, the Installation Information must accompany\n the Minimal Corresponding Source and Corresponding Application\n Code. If you use option 4d1, you must provide the Installation\n Information in the manner specified by section 6 of the GNU GPL\n for conveying Corresponding Source.)\n\n 5. Combined Libraries.\n\n You may place library facilities that are a work based on the\nLibrary side by side in a single library together with other library\nfacilities that are not Applications and are not covered by this\nLicense, and convey such a combined library under terms of your\nchoice, if you do both of the following:\n\n a) Accompany the combined library with a copy of the same work based\n on the Library, uncombined with any other library facilities,\n conveyed under the terms of this License.\n\n b) Give prominent notice with the combined library that part of it\n is a work based on the Library, and explaining where to find the\n accompanying uncombined form of the same work.\n\n 6. Revised Versions of the GNU Lesser General Public License.\n\n The Free Software Foundation may publish revised and/or new versions\nof the GNU Lesser General Public License from time to time. Such new\nversions will be similar in spirit to the present version, but may\ndiffer in detail to address new problems or concerns.\n\n Each version is given a distinguishing version number. If the\nLibrary as you received it specifies that a certain numbered version\nof the GNU Lesser General Public License \"or any later version\"\napplies to it, you have the option of following the terms and\nconditions either of that published version or of any later version\npublished by the Free Software Foundation. If the Library as you\nreceived it does not specify a version number of the GNU Lesser\nGeneral Public License, you may choose any version of the GNU Lesser\nGeneral Public License ever published by the Free Software Foundation.\n\n If the Library as you received it specifies that a proxy can decide\nwhether future versions of the GNU Lesser General Public License shall\napply, that proxy's public statement of acceptance of any version is\npermanent authorization for you to choose that version for the\nLibrary.\n"
},
{
"path": "README.md",
"content": "# Robust Articulated-ICP for Real-Time Hand Tracking\n\n- **YouTube Video**: https://youtu.be/rm3YnClSmIQ\n- **Paper PDF**: http://infoscience.epfl.ch/record/206951/files/htrack.pdf\n\n## Disclaimer\nTo obtain the results shown in the video (or as seen in the live demo sessions at SGP'15) proper hardware is necessary:\n- **Ubuntu 14.04** (on windows/osx the OS interferes with GPU on Compute/Graphics context switches) \n- Intel Core **i7 @4GhZ**\n- CUDA Graphic card (**NVIDIA GTX980** used in our demo)\n- **Senz3D** depth camera (SENSOR_DEPTHSENSEGRABBER, use SoftKinetic or Intel/Creative)\n\nOther notes:\n- note the software must be compiled in **64bits**!\n- **Wristband** color calibration (make sure the wristband is detected robustly otherwise the tracking might not perform as effectively, you can check this by enabling \"show wband\" in the htrack_atb application)\n\n## BibTex\n @article{htrack_sgp15,\n author = {Andrea Tagliasacchi and Matthias Schr{\\\"o}der and Anastasia Tkach and \n Sofien Bouaziz and Mario Botsch and Mark Pauly},\n title = {Robust Articulated-ICP for Real-Time Hand Tracking},\n journal = {Symposium on Geometry Processing (Computer Graphics Forum)},\n month = July,\n year = 2015}\n\n## News\n- July 8th 2015: we won the **Best Paper Award** at the Symposium on Geometry Processing (SGP) 2015!\n- June 12th 2015: official code release (in sync with CVPR'15 HANDS workshop)\n\n## Acknowledgements\n- Thanks to \"Tu-Hoa Pham\" for his pull request that improved the SoftKinetic (Senz3D) Sensor! \n"
},
{
"path": "apps/CMakeLists.txt",
"content": "cmake_minimum_required(VERSION 2.8)\nproject(htrack-helloworlds)\n\n#--- Gets rid of annoying CMake 3 warnings\nif(NOT (CMAKE_MAJOR_VERSION LESS 3))\n cmake_policy(SET CMP0043 OLD)\n cmake_policy(SET CMP0020 OLD)\n cmake_policy(SET CMP0005 OLD)\nendif()\n\n#--- Helloworld applications\nadd_subdirectory(helloworld)\nadd_subdirectory(helloworld_opencv)\nadd_subdirectory(helloworld_qtopengl)\nadd_subdirectory(helloworld_atb) # only for htrack-atb\nadd_subdirectory(helloworld_cudagl)\nadd_subdirectory(helloworld_cublas)\nadd_subdirectory(helloworld_thrust)\nadd_subdirectory(helloworld_openmp) # linux-only\nadd_subdirectory(helloworld_qglviewer) # only for htrack-qt\n\n#--- Sensors Testing\nadd_subdirectory(helloworld_realsense) # windows only!!\nadd_subdirectory(helloworld_openni) # any os\n"
},
{
"path": "apps/colorpick/CMakeLists.txt",
"content": "#--- This project needs this extra library\n#include(../../cmake/ConfigureQGLViewer.cmake)\n\nINCLUDE_DIRECTORIES(../../) #< #include \"tracker/...\"\nfile(GLOB_RECURSE SRC \"*.cpp\")\nfile(GLOB_RECURSE HDR \"*.h\")\nadd_executable(colorpick ${HDR} ${SRC})\ntarget_link_libraries(colorpick htracksdk ${LIBRARIES})\n"
},
{
"path": "apps/colorpick/colorpick.cpp",
"content": "// based on http://pastebin.com/EHz2a0YP\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \"tracker/Legacy/util/Util.h\"\n\nusing namespace cv;\nusing namespace std;\n\n//-----------------------------------------------------------------//\n\ncv::Mat image, sel, src, hsv;\nScalar cMin(179,255,255), cMax(0,0,0);\nbool selecting = false;\nchar w1[20] = \"Color picker\";\nchar w2[20] = \"Picked color\";\nchar w3[20] = \"Segments\";\n\n//-----------------------------------------------------------------//\n\nvoid filter()\n{\n\t// range based color classification\n\n\tcv::Mat bw;\n\tcv::inRange(hsv, cMin, cMax, bw);\n\tcv::cvtColor(bw, sel, CV_GRAY2BGR);\n\tcv::imshow(w2, sel);\n\n\t// segmentation with opening and contours\n\n\tcv::RNG rng(12345);\n\tcv::Mat output;\n\n\tvector > contours;\n\tvector hierarchy;\n\n\tcv::Mat kernel = getStructuringElement(MORPH_ELLIPSE, Size(4,4));\n\tcv::morphologyEx(bw, output, MORPH_OPEN, kernel);\n\tcv::findContours(output, contours, hierarchy, CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE);\n\n\tcv::Mat drawing = cv::Mat::zeros(output.size(), CV_8UC3);\n\n\tfor(int i = 0; i < contours.size(); ++i)\n\t{\n\t\tScalar color = Scalar(rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255));\n\t\tdrawContours(drawing, contours, i, color, CV_FILLED);\n\n\t\tMoments m = moments(contours[i]);\n\t\tPoint2f mp = Point2f(m.m10/m.m00, m.m01/m.m00);\n\t\tdouble a = contourArea(contours[i]);\n\n\t\tif(a > 2000)\n\t\t{\n\t\t\tScalar color = Scalar(255,255,255);\n\t\t\tdrawContours(drawing, contours, i, color);\n\t\t\tline(drawing, mp + Point2f(-4,-4), mp + Point2f( 4, 4), color);\n\t\t\tline(drawing, mp + Point2f( 4,-4), mp + Point2f(-4, 4), color);\n\t\t}\n\t}\n\n\timshow(w3, drawing);\n}\n\n//-----------------------------------------------------------------//\n\nstatic void onMouse(int event, int x, int y, int f, void *)\n{\n std::cout << \"## UPDATED\" << std::endl;\n \n\timage = src.clone();\n\tVec3b pix = hsv.at(y,x);\n\n\tint H = pix.val[0];\n\tint S = pix.val[1];\n\tint V = pix.val[2];\n\n\t//--\n\n\tif(event == EVENT_LBUTTONDOWN)\n\t\tselecting = true;\n\telse if(event == EVENT_LBUTTONUP)\n\t\tselecting = false;\n\tif(selecting)\n\t{\n\t\tif(H < cMin[0])\n\t\t\tcMin[0] = H;\n\t\tif(S < cMin[1])\n\t\t\tcMin[1] = S;\n\t\tif(V < cMin[2])\n\t\t\tcMin[2] = V;\n\n\t\tif(H > cMax[0])\n\t\t\tcMax[0] = H;\n\t\tif(S > cMax[1])\n\t\t\tcMax[1] = S;\n\t\tif(V > cMax[2])\n\t\t\tcMax[2] = V;\n\n\t\tfilter();\n\t}\n\n\t//--\n\n\tScalar bgr = cvc(hsv2rgb(cvc(cv::Scalar(H,S,V))), true);\n\trectangle(image, Point(3,5), Point(13,15), bgr, -1);\n\n\tstringstream s;\n\ts << \"HSV=(\" << H << \", \" << S << \", \" << V << \")\";\n\tputText(image, s.str().c_str(), Point(17,15), FONT_HERSHEY_SIMPLEX, .6, Scalar(0,0,0), 2);\n\tputText(image, s.str().c_str(), Point(17,15), FONT_HERSHEY_SIMPLEX, .6, Scalar(255,255,255));\n\n\t//--\n\n\tbgr = cvc(hsv2rgb(cvc(cMin)), true);\n\trectangle(image, Point(3,25), Point(13,35), bgr, -1);\n\n\ts.str(\"\");\n\ts.clear();\n\ts << \"hsv_min=\" << cMin[0] << \", \" << cMin[1] << \", \" << cMin[2];\n std::cout << s.str() << std::endl;\n\tputText(image, s.str().c_str(), Point(17,35), FONT_HERSHEY_SIMPLEX, .6, Scalar(0,0,0), 2);\n\tputText(image, s.str().c_str(), Point(17,35), FONT_HERSHEY_SIMPLEX, .6, Scalar(255,255,255));\n\n\t//--\n\n\tbgr = cvc(hsv2rgb(cvc(cMax)), true);\n\trectangle(image, Point(3,45), Point(13,55), bgr, -1);\n\n\ts.str(\"\");\n\ts.clear();\n\ts << \"hsv_max=\" << cMax[0] << \", \" << cMax[1] << \", \" << cMax[2];\n\tstd::cout << s.str() << std::endl;\n putText(image, s.str().c_str(), Point(17,55), FONT_HERSHEY_SIMPLEX, .6, Scalar(0,0,0), 2);\n\tputText(image, s.str().c_str(), Point(17,55), FONT_HERSHEY_SIMPLEX, .6, Scalar(255,255,255));\n\n\t//--\n\n\ts.str(\"\");\n\ts.clear();\n\ts << \"range:\";\n\tputText(image, s.str().c_str(), Point(255,25), FONT_HERSHEY_SIMPLEX, .6, Scalar(0,0,0), 2);\n\tputText(image, s.str().c_str(), Point(255,25), FONT_HERSHEY_SIMPLEX, .6, Scalar(255,255,255));\n\n\tdouble n = 57.0f;\n\n\tfor(double i = 0; i < n; ++i)\n\t{\n\t\t// note: red hues wrap around, 1D linear interpolation\n\t\t// doesn't include all possible HSV combinations\n\n\t\tdouble w = i / n;\n\t\tScalar col = (1.0-w)*cMin + w*cMax;\n\n\t\tbgr = cvc(hsv2rgb(cvc(col)), true);\n\t\trectangle(image, Point(255+i,35), Point(256+i,45), bgr, -1);\n\t}\n\n\t//--\n\n\timshow(w1, image);\n\timshow(w2, sel);\n}\n\n//-----------------------------------------------------------------//\n\nint main(int argc, char **argv)\n{\n\t// TODO use camera images for input\n\n\tcout << \"Color picker\" << endl\n\t << \"------------\" << endl\n\t << \"Pass image file as command line argument\" << endl\n\t << \"Click to select colors\" << endl\n\t << \"Press SPACE to reset min/max\" << endl\n\t << \"Press Q or ESC to quit\" << endl << endl;\n\n\tif(argc < 2)\n\t{\n\t\tcout << \"No file specified\" << endl;\n\t\treturn 0;\n\t}\n\n\tsrc = imread(argv[1]);\n\n\tif(!src.data)\n\t{\n\t\tcout << \"Could not read file\" << endl;\n\t\treturn 0;\n\t}\n\n\tnamedWindow(w1, WINDOW_AUTOSIZE);\n\tcvtColor(src, hsv, CV_BGR2HSV);\n\tfilter();\n\n\timshow(w1, src);\n\timshow(w2, sel);\n\n\tsetMouseCallback(w1, onMouse, 0);\n\n\tfor(;;)\n\t{\n\t\tchar key = waitKey(20);\n\n\t\tif(key == 0x71 || key == 0x1b)\n\t\t\tbreak;\n\t\telse if(key == 0x20)\n\t\t{\n\t\t\tcMin = Scalar(179,255,255);\n\t\t\tcMax = Scalar(0,0,0);\n\t\t\tfilter();\n\t\t}\n\t}\n\n\treturn 0;\n}\n\n"
},
{
"path": "apps/helloworld/CMakeLists.txt",
"content": "cmake_minimum_required(VERSION 2.8)\nget_filename_component(FOLDERNAME ${CMAKE_CURRENT_LIST_DIR} NAME)\nproject(${FOLDERNAME})\nfile(GLOB_RECURSE SOURCES \"*.cpp\")\nfile(GLOB_RECURSE HEADERS \"*.h\")\nfile(GLOB_RECURSE SHADERS \"*.glsl\")\nadd_executable(${FOLDERNAME} ${SOURCES} ${HEADERS} ${SHADERS})\ntarget_link_libraries(${FOLDERNAME} ${COMMON_LIBS})\n"
},
{
"path": "apps/helloworld/main.cpp",
"content": "#include \nint main(int /*argc*/, char ** /*argv*/)\n{\n std::cout << \"hello world!\" << std::endl;\n return 0;\n}\n"
},
{
"path": "apps/helloworld_atb/CMakeLists.txt",
"content": "cmake_minimum_required(VERSION 2.8)\nget_filename_component(PROJECT ${CMAKE_CURRENT_LIST_DIR} NAME)\nproject(${PROJECT})\n\nset(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/../../cmake)\ninclude(../../cmake/ConfigureCompiler.cmake)\ninclude(../../cmake/ConfigureQt.cmake)\ninclude(../../cmake/ConfigureOpenGL.cmake)\ninclude(../../cmake/ConfigureAntTweakBar.cmake)\n\nINCLUDE_DIRECTORIES(../../)\n#set(CMAKE_BUILD_TYPE \"Release\")\nset(CMAKE_BUILD_TYPE \"Debug\")\n\nlist(APPEND SOURCES ../../tracker/TwSettings.cpp)\nadd_executable(${PROJECT} main.cpp ${SOURCES})\ntarget_link_libraries(${PROJECT} ${LIBRARIES})\n#set(EXECUTABLE_OUTPUT_PATH ${CMAKE_SOURCE_DIR})\n"
},
{
"path": "apps/helloworld_atb/main.cpp",
"content": "#include \n#include \n#include \n#include \n#include \n\n#include \"../htrack_atb/AntTweakBarEventFilter.h\"\n#include \"tracker/TwSettings.h\"\n\nfloat v1;\nfloat g1_v1;\nfloat g1_v2;\n\n#include \"AntTweakBar.h\"\n\n\n/// Format class to enable OpenGL4 core profile\nclass OpenGLFormat : public QGLFormat{\npublic:\n OpenGLFormat(){\n setVersion(3,2);\n setProfile(QGLFormat::CoreProfile);\n setSampleBuffers(false); ///< no anti-aliasing\n // setSamples(1); ///< no anti-aliasing\n }\n};\n\nclass GLWidget : public QGLWidget{\n QOpenGLVertexArrayObject vao;\npublic:\n GLWidget():QGLWidget(OpenGLFormat()){\n std::cout << \"OpenGL \" << this->format().majorVersion() << \".\" << this->format().minorVersion() << std::endl;\n this->installEventFilter( new AntTweakBarEventFilter(this) ); ///< all actions pass through filter\n }\n ~GLWidget(){\n TwTerminate();\n }\n void initializeGL(){\n bool success = vao.create();\n if(!success) exit(EXIT_FAILURE);\n vao.bind();\n tw_settings->tw_init(this->width(), this->height());\n tw_settings->tw_add(v1, \"v1\", \"min=.5 max=50 step=0.4\");\n tw_settings->tw_add(g1_v1, \"g1_v1\", \"group=g1\");\n tw_settings->tw_add(g1_v2, \"g1_v2\", \"group=g1\");\n }\n\n void paintGL() {\n glClearColor(0,1,0,1); ///< green\n glClear(GL_COLOR_BUFFER_BIT);\n tw_settings->tw_draw();\n // TwWindowSize(this->width(), this->height());\n TwDraw();\n }\n};\n\nint main(int argc, char* argv[]){\n QApplication app(argc, argv);\n GLWidget glarea;\n glarea.show();\n return app.exec();\n}\n"
},
{
"path": "apps/helloworld_atb/main_new.cpp",
"content": "#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"gui/AntTweakBarEventFilter.h\"\n#include \"AntTweakBar.h\"\nTwBar* _bar = NULL;\n\nfloat v1;\nfloat g1_v1;\nfloat g1_v2;\n\nclass GLWidget : public QOpenGLWidget{\n QOpenGLVertexArrayObject vao;\npublic:\n GLWidget():QOpenGLWidget(){\n std::cout << \"OpenGL \" << this->format().majorVersion() << \".\" << this->format().minorVersion() << std::endl;\n this->installEventFilter( new AntTweakBarEventFilter(this) ); ///< all actions pass through filter\n }\n ~GLWidget(){\n TwTerminate();\n }\n void initializeGL(){\n bool success = vao.create();\n if(!success) exit(EXIT_FAILURE);\n vao.bind();\n TwInit(TW_OPENGL_CORE, NULL);\n TwWindowSize(this->width()*2, this->height()*2);\n _bar = TwNewBar (\"Settings\");\n TwAddVarRW(_bar, \"p\", TW_TYPE_FLOAT, &v1, \"min=.5 max=50 step=0.4\");\n TwAddVarRW(_bar, \"V1\", TW_TYPE_FLOAT, &g1_v1, \" group=g1 \");\n TwAddVarRW(_bar, \"V2\", TW_TYPE_FLOAT, &g1_v2, \" group=g1 \");\n glViewport(0, 0, this->width(), this->height());\n }\n\n void paintGL() {\n glViewport(0,0,this->width(), this->height());\n glClearColor(0,1,0,1); ///< green\n glClear(GL_COLOR_BUFFER_BIT);\n TwDraw();\n }\n};\n\nint main(int argc, char* argv[]){\n QApplication app(argc, argv);\n \n QSurfaceFormat format;\n format.setVersion(4, 3);\n format.setProfile(QSurfaceFormat::CoreProfile);\n format.setDepthBufferSize(24);\n format.setStencilBufferSize(8);\n QSurfaceFormat::setDefaultFormat(format);\n \n GLWidget glarea;\n glarea.show();\n return app.exec();\n}\n"
},
{
"path": "apps/helloworld_cublas/CMakeLists.txt",
"content": "cmake_minimum_required(VERSION 2.8)\nget_filename_component(PROJECT ${CMAKE_CURRENT_LIST_DIR} NAME)\nproject(${PROJECT})\n\nset(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/../../cmake)\ninclude(../../cmake/ConfigureCompiler.cmake)\ninclude(../../cmake/ConfigureQt.cmake)\ninclude(../../cmake/ConfigureCUDA.cmake)\ninclude(../../cmake/ConfigureEigen.cmake)\ninclude_directories(../../)\n\n#--- only compile a tiny fraction of cudax\nset(CUDAX_CU \"../../cudax/outer_product.cu\")\ncuda_add_library(cudax STATIC ${CUDAX_CU})\nlist(APPEND LIBRARIES cudax)\n\n#--- exec1\nadd_executable(${PROJECT}_simple main_simple.cpp)\ntarget_link_libraries(${PROJECT}_simple ${LIBRARIES})\n\n#--- exec2 (needs gnuplot!)\nif(UNIX AND NOT APPLE)\n add_executable(${PROJECT}_perfomance main_performance.cpp)\n target_link_libraries(${PROJECT}_perfomance ${LIBRARIES})\nendif()\n\n"
},
{
"path": "apps/helloworld_cublas/gnuplot_i.h",
"content": "////////////////////////////////////////////////////////////////////////////////\n///\n/// \\brief A C++ interface to gnuplot.\n///\n///\n/// The interface uses pipes and so won't run on a system that doesn't have\n/// POSIX pipe support Tested on Windows (MinGW and Visual C++) and Linux (GCC)\n///\n/// Version history:\n/// 0. C interface\n/// by N. Devillard (27/01/03)\n/// 1. C++ interface: direct translation from the C interface\n/// by Rajarshi Guha (07/03/03)\n/// 2. corrections for Win32 compatibility\n/// by V. Chyzhdzenka (20/05/03)\n/// 3. some member functions added, corrections for Win32 and Linux\n/// compatibility\n/// by M. Burgis (10/03/08)\n///\n/// Requirements:\n/// * gnuplot has to be installed (http://www.gnuplot.info/download.html)\n/// * for Windows: set Path-Variable for Gnuplot path\n/// (e.g. C:/program files/gnuplot/bin)\n/// or set Gnuplot path with:\n/// Gnuplot::set_GNUPlotPath(const std::string &path);\n///\n////////////////////////////////////////////////////////////////////////////////\n\n\n#ifndef _GNUPLOT_PIPES_H_\n#define _GNUPLOT_PIPES_H_\n\n\n#include \n#include \n#include \n#include \n#include // for std::ostringstream\n#include \n#include \n#include // for getenv()\n#include // for std::list\n\n\n#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__)\n//defined for 32 and 64-bit environments\n#include // for _access(), _mktemp()\n#define GP_MAX_TMP_FILES 27 // 27 temporary files it's Microsoft restriction\n#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)\n//all UNIX-like OSs (Linux, *BSD, MacOSX, Solaris, ...)\n#include // for access(), mkstemp()\n#define GP_MAX_TMP_FILES 64\n#else\n#error unsupported or unknown operating system\n#endif\n\n//declare classes in global namespace\n\n\nclass GnuplotException : public std::runtime_error\n{\npublic:\n GnuplotException(const std::string &msg) : std::runtime_error(msg) {}\n};\n\n\n\nclass Gnuplot\n{\nprivate:\n\n //----------------------------------------------------------------------------------\n // member data\n ///\\brief pointer to the stream that can be used to write to the pipe\n FILE *gnucmd;\n ///\\brief validation of gnuplot session\n bool valid;\n ///\\brief true = 2d, false = 3d\n bool two_dim;\n ///\\brief number of plots in session\n int nplots;\n ///\\brief functions and data are displayed in a defined styles\n std::string pstyle;\n ///\\brief interpolate and approximate data in defined styles (e.g. spline)\n std::string smooth;\n ///\\brief list of created tmpfiles\n std::vector tmpfile_list;\n\n //----------------------------------------------------------------------------------\n // static data\n ///\\brief number of all tmpfiles (number of tmpfiles restricted)\n static int tmpfile_num;\n ///\\brief name of executed GNUPlot file\n static std::string m_sGNUPlotFileName;\n ///\\brief gnuplot path\n static std::string m_sGNUPlotPath;\n ///\\brief standart terminal, used by showonscreen\n static std::string terminal_std;\n\n //----------------------------------------------------------------------------------\n // member functions (auxiliary functions)\n // ---------------------------------------------------\n ///\\brief get_program_path(); and popen();\n ///\n /// \\param --> void\n ///\n /// \\return <-- void\n // ---------------------------------------------------\n void init();\n // ---------------------------------------------------\n ///\\brief creates tmpfile and returns its name\n ///\n /// \\param tmp --> points to the tempfile\n ///\n /// \\return <-- the name of the tempfile\n // ---------------------------------------------------\n std::string create_tmpfile(std::ofstream &tmp);\n\n //----------------------------------------------------------------------------------\n ///\\brief gnuplot path found?\n ///\n /// \\param ---\n ///\n /// \\return <-- found the gnuplot path (yes == true, no == false)\n // ---------------------------------------------------------------------------------\n static bool get_program_path();\n\n // ---------------------------------------------------------------------------------\n ///\\brief checks if file is available\n ///\n /// \\param filename --> the filename\n /// \\param mode \t--> the mode [optional,default value = 0]\n ///\n /// \\return file exists (yes == true, no == false)\n // ---------------------------------------------------------------------------------\n bool file_available(const std::string &filename);\n\n // ---------------------------------------------------------------------------------\n ///\\brief checks if file exists\n ///\n /// \\param filename --> the filename\n /// \\param mode \t--> the mode [optional,default value = 0]\n ///\n /// \\return file exists (yes == true, no == false)\n // ---------------------------------------------------------------------------------\n static bool file_exists(const std::string &filename, int mode=0);\n\npublic:\n\n // ----------------------------------------------------------------------------\n /// \\brief optional function: set Gnuplot path manual\n /// attention: for windows: path with slash '/' not backslash '\\'\n ///\n /// \\param path --> the gnuplot path\n ///\n /// \\return true on success, false otherwise\n // ----------------------------------------------------------------------------\n static bool set_GNUPlotPath(const std::string &path);\n\n\n // ----------------------------------------------------------------------------\n /// optional: set standart terminal, used by showonscreen\n /// defaults: Windows - win, Linux - x11, Mac - aqua\n ///\n /// \\param type --> the terminal type\n ///\n /// \\return ---\n // ----------------------------------------------------------------------------\n static void set_terminal_std(const std::string &type);\n\n //-----------------------------------------------------------------------------\n // constructors\n // ----------------------------------------------------------------------------\n\n\n ///\\brief set a style during construction\n Gnuplot(const std::string &style = \"points\");\n\n /// plot a single std::vector at one go\n Gnuplot(const std::vector &x,\n const std::string &title = \"\",\n const std::string &style = \"points\",\n const std::string &labelx = \"x\",\n const std::string &labely = \"y\");\n\n /// plot pairs std::vector at one go\n Gnuplot(const std::vector &x,\n const std::vector &y,\n const std::string &title = \"\",\n const std::string &style = \"points\",\n const std::string &labelx = \"x\",\n const std::string &labely = \"y\");\n\n /// plot triples std::vector at one go\n Gnuplot(const std::vector &x,\n const std::vector &y,\n const std::vector &z,\n const std::string &title = \"\",\n const std::string &style = \"points\",\n const std::string &labelx = \"x\",\n const std::string &labely = \"y\",\n const std::string &labelz = \"z\");\n\n /// destructor: needed to delete temporary files\n ~Gnuplot();\n\n\n //----------------------------------------------------------------------------------\n\n /// send a command to gnuplot\n Gnuplot& cmd(const std::string &cmdstr);\n // -------------------------------------------------------------------------\n ///\\brief Sends a command to an active gnuplot session, identical to cmd()\n /// send a command to gnuplot using the << operator\n ///\n /// \\param cmdstr --> the command string\n ///\n /// \\return <-- a reference to the gnuplot object\n // -------------------------------------------------------------------------\n inline Gnuplot& operator<<(const std::string &cmdstr)\n {\n cmd(cmdstr);\n return(*this);\n }\n\n\n\n //--------------------------------------------------------------------------\n // show on screen or write to file\n\n /// sets terminal type to terminal_std\n Gnuplot& showonscreen(); // window output is set by default (win/x11/aqua)\n\n /// Saves a gnuplot to a file named filename. Defaults to saving pdf\n Gnuplot& savetofigure(const std::string &filename,\n const std::string &terminal=\"ps\");\n\n //--------------------------------------------------------------------------\n // set and unset\n\n /// set line style (some of these styles require additional information):\n /// lines, points, linespoints, impulses, dots, steps, fsteps, histeps,\n /// boxes, histograms, filledcurves\n Gnuplot& set_style(const std::string &stylestr = \"points\");\n\n /// interpolation and approximation of data, arguments:\n /// csplines, bezier, acsplines (for data values > 0), sbezier, unique, frequency\n /// (works only with plot_x, plot_xy, plotfile_x, plotfile_xy\n /// (if smooth is set, set_style has no effekt on data plotting)\n Gnuplot& set_smooth(const std::string &stylestr = \"csplines\");\n\n // ----------------------------------------------------------------------\n /// \\brief unset smooth\n /// attention: smooth is not set by default\n ///\n /// \\param ---\n ///\n /// \\return <-- a reference to a gnuplot object\n // ----------------------------------------------------------------------\n inline Gnuplot& unset_smooth()\n {\n smooth = \"\";\n return *this;\n };\n\n\n /// scales the size of the points used in plots\n Gnuplot& set_pointsize(const double pointsize = 1.0);\n\n /// turns grid on/off\n inline Gnuplot& set_grid()\n {\n cmd(\"set grid\");\n return *this;\n };\n /// grid is not set by default\n inline Gnuplot& unset_grid()\n {\n cmd(\"unset grid\");\n return *this;\n };\n\n // -----------------------------------------------\n /// set the mulitplot mode\n ///\n /// \\param ---\n ///\n /// \\return <-- reference to the gnuplot object\n // -----------------------------------------------\n inline Gnuplot& set_multiplot()\n {\n cmd(\"set multiplot\") ;\n return *this;\n };\n\n // -----------------------------------------------\n /// unsets the mulitplot mode\n ///\n /// \\param ---\n ///\n /// \\return <-- reference to the gnuplot object\n // -----------------------------------------------\n inline Gnuplot& unset_multiplot()\n {\n cmd(\"unset multiplot\");\n return *this;\n };\n\n\n\n /// set sampling rate of functions, or for interpolating data\n Gnuplot& set_samples(const int samples = 100);\n /// set isoline density (grid) for plotting functions as surfaces (for 3d plots)\n Gnuplot& set_isosamples(const int isolines = 10);\n\n // --------------------------------------------------------------------------\n /// enables/disables hidden line removal for surface plotting (for 3d plot)\n ///\n /// \\param ---\n ///\n /// \\return <-- reference to the gnuplot object\n // --------------------------------------------------------------------------\n Gnuplot& set_hidden3d()\n {\n cmd(\"set hidden3d\");\n return *this;\n };\n\n // ---------------------------------------------------------------------------\n /// hidden3d is not set by default\n ///\n /// \\param ---\n ///\n /// \\return <-- reference to the gnuplot object\n // ---------------------------------------------------------------------------\n inline Gnuplot& unset_hidden3d()\n {\n cmd(\"unset hidden3d\");\n return *this;\n };\n\n /// enables/disables contour drawing for surfaces (for 3d plot)\n /// base, surface, both\n Gnuplot& set_contour(const std::string &position = \"base\");\n // --------------------------------------------------------------------------\n /// contour is not set by default, it disables contour drawing for surfaces\n ///\n /// \\param ---\n ///\n /// \\return <-- reference to the gnuplot object\n // ------------------------------------------------------------------\n inline Gnuplot& unset_contour()\n {\n cmd(\"unset contour\");\n return *this;\n };\n\n // ------------------------------------------------------------\n /// enables/disables the display of surfaces (for 3d plot)\n ///\n /// \\param ---\n ///\n /// \\return <-- reference to the gnuplot object\n // ------------------------------------------------------------------\n inline Gnuplot& set_surface()\n {\n cmd(\"set surface\");\n return *this;\n };\n\n // ----------------------------------------------------------\n /// surface is set by default,\n /// it disables the display of surfaces (for 3d plot)\n ///\n /// \\param ---\n ///\n /// \\return <-- reference to the gnuplot object\n // ------------------------------------------------------------------\n inline Gnuplot& unset_surface()\n {\n cmd(\"unset surface\");\n return *this;\n }\n\n\n /// switches legend on/off\n /// position: inside/outside, left/center/right, top/center/bottom, nobox/box\n Gnuplot& set_legend(const std::string &position = \"default\");\n\n // ------------------------------------------------------------------\n /// \\brief Switches legend off\n /// attention:legend is set by default\n ///\n /// \\param ---\n ///\n /// \\return <-- reference to the gnuplot object\n // ------------------------------------------------------------------\n inline Gnuplot& unset_legend()\n {\n cmd(\"unset key\");\n return *this;\n }\n\n // -----------------------------------------------------------------------\n /// \\brief sets and clears the title of a gnuplot session\n ///\n /// \\param title --> the title of the plot [optional, default == \"\"]\n ///\n /// \\return <-- reference to the gnuplot object\n // -----------------------------------------------------------------------\n inline Gnuplot& set_title(const std::string &title = \"\")\n {\n std::string cmdstr;\n cmdstr = \"set title \\\"\";\n cmdstr+=title;\n cmdstr+=\"\\\"\";\n *this<set_title();\n return *this;\n }\n\n\n /// set x axis label\n Gnuplot& set_ylabel(const std::string &label = \"x\");\n /// set y axis label\n Gnuplot& set_xlabel(const std::string &label = \"y\");\n /// set z axis label\n Gnuplot& set_zlabel(const std::string &label = \"z\");\n\n /// set axis - ranges\n Gnuplot& set_xrange(const double iFrom,\n const double iTo);\n /// set y-axis - ranges\n Gnuplot& set_yrange(const double iFrom,\n const double iTo);\n /// set z-axis - ranges\n Gnuplot& set_zrange(const double iFrom,\n const double iTo);\n /// autoscale axis (set by default) of xaxis\n ///\n /// \\param ---\n ///\n /// \\return <-- reference to the gnuplot object\n // -----------------------------------------------\n inline Gnuplot& set_xautoscale()\n {\n cmd(\"set xrange restore\");\n cmd(\"set autoscale x\");\n return *this;\n };\n\n // -----------------------------------------------\n /// autoscale axis (set by default) of yaxis\n ///\n /// \\param ---\n ///\n /// \\return <-- reference to the gnuplot object\n // -----------------------------------------------\n inline Gnuplot& set_yautoscale()\n {\n cmd(\"set yrange restore\");\n cmd(\"set autoscale y\");\n return *this;\n };\n\n // -----------------------------------------------\n /// autoscale axis (set by default) of zaxis\n ///\n /// \\param ---\n ///\n /// \\return <-- reference to the gnuplot object\n // -----------------------------------------------\n inline Gnuplot& set_zautoscale()\n {\n cmd(\"set zrange restore\");\n cmd(\"set autoscale z\");\n return *this;\n };\n\n\n /// turns on/off log scaling for the specified xaxis (logscale is not set by default)\n Gnuplot& set_xlogscale(const double base = 10);\n /// turns on/off log scaling for the specified yaxis (logscale is not set by default)\n Gnuplot& set_ylogscale(const double base = 10);\n /// turns on/off log scaling for the specified zaxis (logscale is not set by default)\n Gnuplot& set_zlogscale(const double base = 10);\n\n // -----------------------------------------------\n /// turns off log scaling for the x axis\n ///\n /// \\param ---\n ///\n /// \\return <-- reference to the gnuplot object\n // -----------------------------------------------\n inline Gnuplot& unset_xlogscale()\n {\n cmd(\"unset logscale x\");\n return *this;\n };\n\n // -----------------------------------------------\n /// turns off log scaling for the y axis\n ///\n /// \\param ---\n ///\n /// \\return <-- reference to the gnuplot object\n // -----------------------------------------------\n inline Gnuplot& unset_ylogscale()\n {\n cmd(\"unset logscale y\");\n return *this;\n };\n\n // -----------------------------------------------\n /// turns off log scaling for the z axis\n ///\n /// \\param ---\n ///\n /// \\return <-- reference to the gnuplot object\n // -----------------------------------------------\n inline Gnuplot& unset_zlogscale()\n {\n cmd(\"unset logscale z\");\n return *this;\n };\n\n\n /// set palette range (autoscale by default)\n Gnuplot& set_cbrange(const double iFrom, const double iTo);\n\n\n //--------------------------------------------------------------------------\n // plot\n\n /// plot a single std::vector: x\n /// from file\n Gnuplot& plotfile_x(const std::string &filename,\n const unsigned int column = 1,\n const std::string &title = \"\");\n /// from std::vector\n template\n Gnuplot& plot_x(const X& x, const std::string &title = \"\");\n\n\n /// plot x,y pairs: x y\n /// from file\n Gnuplot& plotfile_xy(const std::string &filename,\n const unsigned int column_x = 1,\n const unsigned int column_y = 2,\n const std::string &title = \"\");\n /// from data\n template\n Gnuplot& plot_xy(const X& x, const Y& y, const std::string &title = \"\");\n\n\n /// plot x,y pairs with dy errorbars: x y dy\n /// from file\n Gnuplot& plotfile_xy_err(const std::string &filename,\n const unsigned int column_x = 1,\n const unsigned int column_y = 2,\n const unsigned int column_dy = 3,\n const std::string &title = \"\");\n /// from data\n template\n Gnuplot& plot_xy_err(const X &x, const Y &y, const E &dy,\n const std::string &title = \"\");\n\n\n /// plot x,y,z triples: x y z\n /// from file\n Gnuplot& plotfile_xyz(const std::string &filename,\n const unsigned int column_x = 1,\n const unsigned int column_y = 2,\n const unsigned int column_z = 3,\n const std::string &title = \"\");\n /// from std::vector\n template\n Gnuplot& plot_xyz(const X &x,\n const Y &y,\n const Z &z,\n const std::string &title = \"\");\n\n\n\n /// plot an equation of the form: y = ax + b, you supply a and b\n Gnuplot& plot_slope(const double a,\n const double b,\n const std::string &title = \"\");\n\n\n /// plot an equation supplied as a std::string y=f(x), write only the\n /// function f(x) not y the independent variable has to be x\n /// binary operators: ** exponentiation, * multiply, / divide, + add, -\n /// substract, % modulo\n /// unary operators: - minus, ! factorial\n /// elementary functions: rand(x), abs(x), sgn(x), ceil(x), floor(x),\n /// int(x), imag(x), real(x), arg(x), sqrt(x), exp(x), log(x), log10(x),\n /// sin(x), cos(x), tan(x), asin(x), acos(x), atan(x), atan2(y,x),\n /// sinh(x), cosh(x), tanh(x), asinh(x), acosh(x), atanh(x)\n /// special functions: erf(x), erfc(x), inverf(x), gamma(x), igamma(a,x),\n /// lgamma(x), ibeta(p,q,x), besj0(x), besj1(x), besy0(x), besy1(x),\n /// lambertw(x)\n /// statistical fuctions: norm(x), invnorm(x)\n Gnuplot& plot_equation(const std::string &equation,\n const std::string &title = \"\");\n\n /// plot an equation supplied as a std::string z=f(x,y), write only the\n /// function f(x,y) not z the independent variables have to be x and y\n Gnuplot& plot_equation3d(const std::string &equation,\n const std::string &title = \"\");\n\n\n /// plot image\n Gnuplot& plot_image(const unsigned char *ucPicBuf,\n const unsigned int iWidth,\n const unsigned int iHeight,\n const std::string &title = \"\");\n\n\n //--------------------------------------------------------------------------\n ///\\brief replot repeats the last plot or splot command.\n /// this can be useful for viewing a plot with different set options,\n /// or when generating the same plot for several devices (showonscreen,\n // savetofigure)\n ///\n /// \\param ---\n ///\n /// \\return ---\n //--------------------------------------------------------------------------\n inline Gnuplot& replot(void)\n {\n if (nplots > 0) cmd(\"replot\");\n return *this;\n };\n\n /// resets a gnuplot session (next plot will erase previous ones)\n Gnuplot& reset_plot();\n\n /// resets a gnuplot session and sets all variables to default\n Gnuplot& reset_all();\n\n /// deletes temporary files\n void remove_tmpfiles();\n\n // -------------------------------------------------------------------\n /// \\brief Is the gnuplot session valid ??\n ///\n ///\n /// \\param ---\n ///\n /// \\return true if valid, false if not\n // -------------------------------------------------------------------\n inline bool is_valid()\n {\n return(valid);\n };\n\n};\n\n//------------------------------------------------------------------------------\n//\n// initialize static data\n//\nint Gnuplot::tmpfile_num = 0;\n\n#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__)\nstd::string Gnuplot::m_sGNUPlotFileName = \"pgnuplot.exe\";\nstd::string Gnuplot::m_sGNUPlotPath = \"C:/program files/gnuplot/bin/\";\n#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)\nstd::string Gnuplot::m_sGNUPlotFileName = \"gnuplot\";\nstd::string Gnuplot::m_sGNUPlotPath = \"/usr/local/bin/\";\n#endif\n\n#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__)\nstd::string Gnuplot::terminal_std = \"windows\";\n#elif ( defined(unix) || defined(__unix) || defined(__unix__) ) && !defined(__APPLE__)\nstd::string Gnuplot::terminal_std = \"x11\";\n#elif defined(__APPLE__)\nstd::string Gnuplot::terminal_std = \"aqua\";\n#endif\n\n//------------------------------------------------------------------------------\n//\n// constructor: set a style during construction\n//\ninline Gnuplot::Gnuplot(const std::string &style)\n :gnucmd(NULL) ,valid(false) ,two_dim(false) ,nplots(0)\n\n{\n init();\n set_style(style);\n}\n\n//------------------------------------------------------------------------------\n//\n// constructor: open a new session, plot a signal (x)\n//\ninline Gnuplot::Gnuplot(const std::vector &x,\n const std::string &title,\n const std::string &style,\n const std::string &labelx,\n const std::string &labely)\n :gnucmd(NULL) ,valid(false) ,two_dim(false) ,nplots(0)\n{\n init();\n\n set_style(style);\n set_xlabel(labelx);\n set_ylabel(labely);\n\n plot_x(x,title);\n}\n\n\n//------------------------------------------------------------------------------\n//\n// constructor: open a new session, plot a signal (x,y)\n//\ninline Gnuplot::Gnuplot(const std::vector &x,\n const std::vector &y,\n const std::string &title,\n const std::string &style,\n const std::string &labelx,\n const std::string &labely)\n :gnucmd(NULL) ,valid(false) ,two_dim(false) ,nplots(0)\n{\n init();\n\n set_style(style);\n set_xlabel(labelx);\n set_ylabel(labely);\n\n plot_xy(x,y,title);\n}\n\n\n//------------------------------------------------------------------------------\n//\n// constructor: open a new session, plot a signal (x,y,z)\n//\ninline Gnuplot::Gnuplot(const std::vector &x,\n const std::vector &y,\n const std::vector &z,\n const std::string &title,\n const std::string &style,\n const std::string &labelx,\n const std::string &labely,\n const std::string &labelz)\n :gnucmd(NULL) ,valid(false) ,two_dim(false) ,nplots(0)\n{\n init();\n\n set_style(style);\n set_xlabel(labelx);\n set_ylabel(labely);\n set_zlabel(labelz);\n\n plot_xyz(x,y,z,title);\n}\n\n\n//------------------------------------------------------------------------------\n//\n/// Plots a 2d graph from a list of doubles: x\n//\ntemplate\nGnuplot& Gnuplot::plot_x(const X& x, const std::string &title)\n{\n if (x.size() == 0)\n {\n throw GnuplotException(\"std::vector too small\");\n return *this;\n }\n\n std::ofstream tmp;\n std::string name = create_tmpfile(tmp);\n if (name == \"\")\n return *this;\n\n //\n // write the data to file\n //\n for (unsigned int i = 0; i < x.size(); i++)\n tmp << x[i] << std::endl;\n\n tmp.flush();\n tmp.close();\n\n\n plotfile_x(name, 1, title);\n\n return *this;\n}\n\n\n//------------------------------------------------------------------------------\n//\n/// Plots a 2d graph from a list of doubles: x y\n//\ntemplate\nGnuplot& Gnuplot::plot_xy(const X& x, const Y& y, const std::string &title)\n{\n if (x.size() == 0 || y.size() == 0)\n {\n throw GnuplotException(\"std::vectors too small\");\n return *this;\n }\n\n if (x.size() != y.size())\n {\n throw GnuplotException(\"Length of the std::vectors differs\");\n return *this;\n }\n\n\n std::ofstream tmp;\n std::string name = create_tmpfile(tmp);\n if (name == \"\")\n return *this;\n\n //\n // write the data to file\n //\n for (unsigned int i = 0; i < x.size(); i++)\n tmp << x[i] << \" \" << y[i] << std::endl;\n\n tmp.flush();\n tmp.close();\n\n\n plotfile_xy(name, 1, 2, title);\n\n return *this;\n}\n\n///-----------------------------------------------------------------------------\n///\n/// plot x,y pairs with dy errorbars\n///\ntemplate\nGnuplot& Gnuplot::plot_xy_err(const X &x,\n const Y &y,\n const E &dy,\n const std::string &title)\n{\n if (x.size() == 0 || y.size() == 0 || dy.size() == 0)\n {\n throw GnuplotException(\"std::vectors too small\");\n return *this;\n }\n\n if (x.size() != y.size() || y.size() != dy.size())\n {\n throw GnuplotException(\"Length of the std::vectors differs\");\n return *this;\n }\n\n\n std::ofstream tmp;\n std::string name = create_tmpfile(tmp);\n if (name == \"\")\n return *this;\n\n //\n // write the data to file\n //\n for (unsigned int i = 0; i < x.size(); i++)\n tmp << x[i] << \" \" << y[i] << \" \" << dy[i] << std::endl;\n\n tmp.flush();\n tmp.close();\n\n\n // Do the actual plot\n plotfile_xy_err(name, 1, 2, 3, title);\n\n return *this;\n}\n\n\n//------------------------------------------------------------------------------\n//\n// Plots a 3d graph from a list of doubles: x y z\n//\ntemplate\nGnuplot& Gnuplot::plot_xyz(const X &x,\n const Y &y,\n const Z &z,\n const std::string &title)\n{\n if (x.size() == 0 || y.size() == 0 || z.size() == 0)\n {\n throw GnuplotException(\"std::vectors too small\");\n return *this;\n }\n\n if (x.size() != y.size() || x.size() != z.size())\n {\n throw GnuplotException(\"Length of the std::vectors differs\");\n return *this;\n }\n\n\n std::ofstream tmp;\n std::string name = create_tmpfile(tmp);\n if (name == \"\")\n return *this;\n\n //\n // write the data to file\n //\n for (unsigned int i = 0; i < x.size(); i++)\n tmp << x[i] << \" \" << y[i] << \" \" << z[i] <\nvoid stringtok (Container &container,\n std::string const &in,\n const char * const delimiters = \" \\t\\n\")\n{\n const std::string::size_type len = in.length();\n std::string::size_type i = 0;\n\n while ( i < len )\n {\n // eat leading whitespace\n i = in.find_first_not_of (delimiters, i);\n\n if (i == std::string::npos)\n return; // nothing left but white space\n\n // find the end of the token\n std::string::size_type j = in.find_first_of (delimiters, i);\n\n // push token\n if (j == std::string::npos)\n {\n container.push_back (in.substr(i));\n return;\n }\n else\n container.push_back (in.substr(i, j-i));\n\n // set up for next loop\n i = j + 1;\n }\n\n return;\n}\n\n\n//------------------------------------------------------------------------------\n//\n// Destructor: needed to delete temporary files\n//\nGnuplot::~Gnuplot()\n{\n// remove_tmpfiles();\n\n // A stream opened by popen() should be closed by pclose()\n#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__)\n if (_pclose(gnucmd) == -1)\n#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)\n if (pclose(gnucmd) == -1)\n#endif\n std::cerr << \"Gnuplot::~Gnuplot: Problem closing communication to gnuplot\" << std::endl;\n}\n\n\n//------------------------------------------------------------------------------\n//\n// Resets a gnuplot session (next plot will erase previous ones)\n//\nGnuplot& Gnuplot::reset_plot()\n{\n// remove_tmpfiles();\n\n nplots = 0;\n\n return *this;\n}\n\n\n//------------------------------------------------------------------------------\n//\n// resets a gnuplot session and sets all varibles to default\n//\nGnuplot& Gnuplot::reset_all()\n{\n// remove_tmpfiles();\n\n nplots = 0;\n cmd(\"reset\");\n cmd(\"clear\");\n pstyle = \"points\";\n smooth = \"\";\n showonscreen();\n\n return *this;\n}\n\n\n//------------------------------------------------------------------------------\n//\n// Change the plotting style of a gnuplot session\n//\nGnuplot& Gnuplot::set_style(const std::string &stylestr)\n{\n if (stylestr.find(\"lines\") == std::string::npos &&\n stylestr.find(\"points\") == std::string::npos &&\n stylestr.find(\"linespoints\") == std::string::npos &&\n stylestr.find(\"impulses\") == std::string::npos &&\n stylestr.find(\"dots\") == std::string::npos &&\n stylestr.find(\"steps\") == std::string::npos &&\n stylestr.find(\"fsteps\") == std::string::npos &&\n stylestr.find(\"histeps\") == std::string::npos &&\n stylestr.find(\"boxes\") == std::string::npos && // 1-4 columns of data are required\n stylestr.find(\"filledcurves\") == std::string::npos &&\n stylestr.find(\"histograms\") == std::string::npos ) //only for one data column\n// stylestr.find(\"labels\") == std::string::npos && // 3 columns of data are required\n// stylestr.find(\"xerrorbars\") == std::string::npos && // 3-4 columns of data are required\n// stylestr.find(\"xerrorlines\") == std::string::npos && // 3-4 columns of data are required\n// stylestr.find(\"errorbars\") == std::string::npos && // 3-4 columns of data are required\n// stylestr.find(\"errorlines\") == std::string::npos && // 3-4 columns of data are required\n// stylestr.find(\"yerrorbars\") == std::string::npos && // 3-4 columns of data are required\n// stylestr.find(\"yerrorlines\") == std::string::npos && // 3-4 columns of data are required\n// stylestr.find(\"boxerrorbars\") == std::string::npos && // 3-5 columns of data are required\n// stylestr.find(\"xyerrorbars\") == std::string::npos && // 4,6,7 columns of data are required\n// stylestr.find(\"xyerrorlines\") == std::string::npos && // 4,6,7 columns of data are required\n// stylestr.find(\"boxxyerrorbars\") == std::string::npos && // 4,6,7 columns of data are required\n// stylestr.find(\"financebars\") == std::string::npos && // 5 columns of data are required\n// stylestr.find(\"candlesticks\") == std::string::npos && // 5 columns of data are required\n// stylestr.find(\"vectors\") == std::string::npos &&\n// stylestr.find(\"image\") == std::string::npos &&\n// stylestr.find(\"rgbimage\") == std::string::npos &&\n// stylestr.find(\"pm3d\") == std::string::npos )\n {\n pstyle = std::string(\"points\");\n }\n else\n {\n pstyle = stylestr;\n }\n\n return *this;\n}\n\n\n//------------------------------------------------------------------------------\n//\n// smooth: interpolation and approximation of data\n//\nGnuplot& Gnuplot::set_smooth(const std::string &stylestr)\n{\n if (stylestr.find(\"unique\") == std::string::npos &&\n stylestr.find(\"frequency\") == std::string::npos &&\n stylestr.find(\"csplines\") == std::string::npos &&\n stylestr.find(\"acsplines\") == std::string::npos &&\n stylestr.find(\"bezier\") == std::string::npos &&\n stylestr.find(\"sbezier\") == std::string::npos )\n {\n smooth = \"\";\n }\n else\n {\n smooth = stylestr;\n }\n\n return *this;\n}\n\n\n//------------------------------------------------------------------------------\n//\n// sets terminal type to windows / x11\n//\nGnuplot& Gnuplot::showonscreen()\n{\n cmd(\"set output\");\n cmd(\"set terminal \" + Gnuplot::terminal_std);\n\n return *this;\n}\n\n//------------------------------------------------------------------------------\n//\n// saves a gnuplot session to a postscript file\n//\nGnuplot& Gnuplot::savetofigure(const std::string &filename,\n const std::string &terminal)\n{\n std::ostringstream cmdstr;\n cmdstr << \"set terminal \" << terminal;\n cmd(cmdstr.str() );\n\n cmdstr.str(\"\"); // Clear cmdstr\n cmdstr << \"set output \\\"\" << filename << \"\\\"\";\n cmd(cmdstr.str());\n\n return *this;\n}\n\n//------------------------------------------------------------------------------\n//\n// Switches legend on\n//\nGnuplot& Gnuplot::set_legend(const std::string &position)\n{\n std::ostringstream cmdstr;\n cmdstr << \"set key \" << position;\n\n cmd(cmdstr.str());\n\n return *this;\n}\n\n//------------------------------------------------------------------------------\n//\n// turns on log scaling for the x axis\n//\nGnuplot& Gnuplot::set_xlogscale(const double base)\n{\n std::ostringstream cmdstr;\n\n cmdstr << \"set logscale x \" << base;\n cmd(cmdstr.str());\n\n return *this;\n}\n\n//------------------------------------------------------------------------------\n//\n// turns on log scaling for the y axis\n//\nGnuplot& Gnuplot::set_ylogscale(const double base)\n{\n std::ostringstream cmdstr;\n\n cmdstr << \"set logscale y \" << base;\n cmd(cmdstr.str());\n\n return *this;\n}\n\n//------------------------------------------------------------------------------\n//\n// turns on log scaling for the z axis\n//\nGnuplot& Gnuplot::set_zlogscale(const double base)\n{\n std::ostringstream cmdstr;\n\n cmdstr << \"set logscale z \" << base;\n cmd(cmdstr.str());\n\n return *this;\n}\n\n//------------------------------------------------------------------------------\n//\n// scales the size of the points used in plots\n//\nGnuplot& Gnuplot::set_pointsize(const double pointsize)\n{\n std::ostringstream cmdstr;\n cmdstr << \"set pointsize \" << pointsize;\n cmd(cmdstr.str());\n\n return *this;\n}\n\n//------------------------------------------------------------------------------\n//\n// set isoline density (grid) for plotting functions as surfaces\n//\nGnuplot& Gnuplot::set_samples(const int samples)\n{\n std::ostringstream cmdstr;\n cmdstr << \"set samples \" << samples;\n cmd(cmdstr.str());\n\n return *this;\n}\n\n\n//------------------------------------------------------------------------------\n//\n// set isoline density (grid) for plotting functions as surfaces\n//\nGnuplot& Gnuplot::set_isosamples(const int isolines)\n{\n std::ostringstream cmdstr;\n cmdstr << \"set isosamples \" << isolines;\n cmd(cmdstr.str());\n\n return *this;\n}\n\n\n//------------------------------------------------------------------------------\n//\n// enables contour drawing for surfaces set contour {base | surface | both}\n//\n\nGnuplot& Gnuplot::set_contour(const std::string &position)\n{\n if (position.find(\"base\") == std::string::npos &&\n position.find(\"surface\") == std::string::npos &&\n position.find(\"both\") == std::string::npos )\n {\n cmd(\"set contour base\");\n }\n else\n {\n cmd(\"set contour \" + position);\n }\n\n return *this;\n}\n\n//------------------------------------------------------------------------------\n//\n// set labels\n//\n// set the xlabel\nGnuplot& Gnuplot::set_xlabel(const std::string &label)\n{\n std::ostringstream cmdstr;\n\n cmdstr << \"set xlabel \\\"\" << label << \"\\\"\";\n cmd(cmdstr.str());\n\n return *this;\n}\n\n//------------------------------------------------------------------------------\n// set the ylabel\n//\nGnuplot& Gnuplot::set_ylabel(const std::string &label)\n{\n std::ostringstream cmdstr;\n\n cmdstr << \"set ylabel \\\"\" << label << \"\\\"\";\n cmd(cmdstr.str());\n\n return *this;\n}\n\n//------------------------------------------------------------------------------\n// set the zlabel\n//\nGnuplot& Gnuplot::set_zlabel(const std::string &label)\n{\n std::ostringstream cmdstr;\n\n cmdstr << \"set zlabel \\\"\" << label << \"\\\"\";\n cmd(cmdstr.str());\n\n return *this;\n}\n\n//------------------------------------------------------------------------------\n//\n// set range\n//\n// set the xrange\nGnuplot& Gnuplot::set_xrange(const double iFrom,\n const double iTo)\n{\n std::ostringstream cmdstr;\n\n cmdstr << \"set xrange[\" << iFrom << \":\" << iTo << \"]\";\n cmd(cmdstr.str());\n\n return *this;\n}\n\n//------------------------------------------------------------------------------\n// set the yrange\n//\nGnuplot& Gnuplot::set_yrange(const double iFrom,\n const double iTo)\n{\n std::ostringstream cmdstr;\n\n cmdstr << \"set yrange[\" << iFrom << \":\" << iTo << \"]\";\n cmd(cmdstr.str());\n\n return *this;\n}\n\n//------------------------------------------------------------------------------\n// set the zrange\n//\nGnuplot& Gnuplot::set_zrange(const double iFrom,\n const double iTo)\n{\n std::ostringstream cmdstr;\n\n cmdstr << \"set zrange[\" << iFrom << \":\" << iTo << \"]\";\n cmd(cmdstr.str());\n\n return *this;\n}\n\n//------------------------------------------------------------------------------\n//\n// set the palette range\n//\nGnuplot& Gnuplot::set_cbrange(const double iFrom,\n const double iTo)\n{\n std::ostringstream cmdstr;\n\n cmdstr << \"set cbrange[\" << iFrom << \":\" << iTo << \"]\";\n cmd(cmdstr.str());\n\n return *this;\n}\n\n//------------------------------------------------------------------------------\n//\n// Plots a linear equation y=ax+b (where you supply the\n// slope a and intercept b)\n//\nGnuplot& Gnuplot::plot_slope(const double a,\n const double b,\n const std::string &title)\n{\n std::ostringstream cmdstr;\n //\n // command to be sent to gnuplot\n //\n if (nplots > 0 && two_dim == true)\n cmdstr << \"replot \";\n else\n cmdstr << \"plot \";\n\n cmdstr << a << \" * x + \" << b << \" title \\\"\";\n\n if (title == \"\")\n cmdstr << \"f(x) = \" << a << \" * x + \" << b;\n else\n cmdstr << title;\n\n cmdstr << \"\\\" with \" << pstyle;\n\n //\n // Do the actual plot\n //\n cmd(cmdstr.str());\n\n return *this;\n}\n\n//------------------------------------------------------------------------------\n//\n// Plot an equation supplied as a std::string y=f(x) (only f(x) expected)\n//\nGnuplot& Gnuplot::plot_equation(const std::string &equation,\n const std::string &title)\n{\n std::ostringstream cmdstr;\n //\n // command to be sent to gnuplot\n //\n if (nplots > 0 && two_dim == true)\n cmdstr << \"replot \";\n else\n cmdstr << \"plot \";\n\n cmdstr << equation;\n\n if (title == \"\")\n cmdstr << \" notitle\";\n else\n cmdstr << \" title \\\"\" << title << \"\\\"\";\n\n cmdstr << \" with \" << pstyle;\n\n //\n // Do the actual plot\n //\n cmd(cmdstr.str());\n\n return *this;\n}\n\n//------------------------------------------------------------------------------\n//\n// plot an equation supplied as a std::string y=(x)\n//\nGnuplot& Gnuplot::plot_equation3d(const std::string &equation,\n const std::string &title)\n{\n std::ostringstream cmdstr;\n //\n // command to be sent to gnuplot\n //\n if (nplots > 0 && two_dim == false)\n cmdstr << \"replot \";\n else\n cmdstr << \"splot \";\n\n cmdstr << equation << \" title \\\"\";\n\n if (title == \"\")\n cmdstr << \"f(x,y) = \" << equation;\n else\n cmdstr << title;\n\n cmdstr << \"\\\" with \" << pstyle;\n\n //\n // Do the actual plot\n //\n cmd(cmdstr.str());\n\n return *this;\n}\n\n\n//------------------------------------------------------------------------------\n//\n// Plots a 2d graph from a list of doubles (x) saved in a file\n//\nGnuplot& Gnuplot::plotfile_x(const std::string &filename,\n const unsigned int column,\n const std::string &title)\n{\n //\n // check if file exists\n //\n file_available(filename);\n\n\n std::ostringstream cmdstr;\n //\n // command to be sent to gnuplot\n //\n if (nplots > 0 && two_dim == true)\n cmdstr << \"replot \";\n else\n cmdstr << \"plot \";\n\n cmdstr << \"\\\"\" << filename << \"\\\" using \" << column;\n\n if (title == \"\")\n cmdstr << \" notitle \";\n else\n cmdstr << \" title \\\"\" << title << \"\\\" \";\n\n if(smooth == \"\")\n cmdstr << \"with \" << pstyle;\n else\n cmdstr << \"smooth \" << smooth;\n\n //\n // Do the actual plot\n //\n cmd(cmdstr.str()); //nplots++; two_dim = true; already in cmd();\n\n return *this;\n}\n\n\n\n//------------------------------------------------------------------------------\n//\n// Plots a 2d graph from a list of doubles (x y) saved in a file\n//\nGnuplot& Gnuplot::plotfile_xy(const std::string &filename,\n const unsigned int column_x,\n const unsigned int column_y,\n const std::string &title)\n{\n //\n // check if file exists\n //\n file_available(filename);\n\n\n std::ostringstream cmdstr;\n //\n // command to be sent to gnuplot\n //\n if (nplots > 0 && two_dim == true)\n cmdstr << \"replot \";\n else\n cmdstr << \"plot \";\n\n cmdstr << \"\\\"\" << filename << \"\\\" using \" << column_x << \":\" << column_y;\n\n if (title == \"\")\n cmdstr << \" notitle \";\n else\n cmdstr << \" title \\\"\" << title << \"\\\" \";\n\n if(smooth == \"\")\n cmdstr << \"with \" << pstyle;\n else\n cmdstr << \"smooth \" << smooth;\n\n //\n // Do the actual plot\n //\n cmd(cmdstr.str());\n\n return *this;\n}\n\n\n//------------------------------------------------------------------------------\n//\n// Plots a 2d graph with errorbars from a list of doubles (x y dy) in a file\n//\nGnuplot& Gnuplot::plotfile_xy_err(const std::string &filename,\n const unsigned int column_x,\n const unsigned int column_y,\n const unsigned int column_dy,\n const std::string &title)\n{\n //\n // check if file exists\n //\n file_available(filename);\n\n std::ostringstream cmdstr;\n //\n // command to be sent to gnuplot\n //\n if (nplots > 0 && two_dim == true)\n cmdstr << \"replot \";\n else\n cmdstr << \"plot \";\n\n cmdstr << \"\\\"\" << filename << \"\\\" using \"\n << column_x << \":\" << column_y << \":\" << column_dy\n << \" with errorbars \";\n\n if (title == \"\")\n cmdstr << \" notitle \";\n else\n cmdstr << \" title \\\"\" << title << \"\\\" \";\n\n //\n // Do the actual plot\n //\n cmd(cmdstr.str());\n\n return *this;\n}\n\n\n//------------------------------------------------------------------------------\n//\n// Plots a 3d graph from a list of doubles (x y z) saved in a file\n//\nGnuplot& Gnuplot::plotfile_xyz(const std::string &filename,\n const unsigned int column_x,\n const unsigned int column_y,\n const unsigned int column_z,\n const std::string &title)\n{\n //\n // check if file exists\n //\n file_available(filename);\n\n std::ostringstream cmdstr;\n //\n // command to be sent to gnuplot\n //\n if (nplots > 0 && two_dim == false)\n cmdstr << \"replot \";\n else\n cmdstr << \"splot \";\n\n cmdstr << \"\\\"\" << filename << \"\\\" using \" << column_x << \":\" << column_y\n << \":\" << column_z;\n\n if (title == \"\")\n cmdstr << \" notitle with \" << pstyle;\n else\n cmdstr << \" title \\\"\" << title << \"\\\" with \" << pstyle;\n\n //\n // Do the actual plot\n //\n cmd(cmdstr.str());\n\n return *this;\n}\n\n\n\n//------------------------------------------------------------------------------\n//\n/// * note that this function is not valid for versions of GNUPlot below 4.2\n//\nGnuplot& Gnuplot::plot_image(const unsigned char * ucPicBuf,\n const unsigned int iWidth,\n const unsigned int iHeight,\n const std::string &title)\n{\n std::ofstream tmp;\n std::string name = create_tmpfile(tmp);\n if (name == \"\")\n return *this;\n\n //\n // write the data to file\n //\n int iIndex = 0;\n for(unsigned int iRow = 0; iRow < iHeight; iRow++)\n {\n for(unsigned int iColumn = 0; iColumn < iWidth; iColumn++)\n {\n tmp << iColumn << \" \" << iRow << \" \"\n << static_cast(ucPicBuf[iIndex++]) << std::endl;\n }\n }\n\n tmp.flush();\n tmp.close();\n\n\n std::ostringstream cmdstr;\n //\n // command to be sent to gnuplot\n //\n if (nplots > 0 && two_dim == true)\n cmdstr << \"replot \";\n else\n cmdstr << \"plot \";\n\n if (title == \"\")\n cmdstr << \"\\\"\" << name << \"\\\" with image\";\n else\n cmdstr << \"\\\"\" << name << \"\\\" title \\\"\" << title << \"\\\" with image\";\n\n //\n // Do the actual plot\n //\n cmd(cmdstr.str());\n\n return *this;\n}\n\n\n\n//------------------------------------------------------------------------------\n//\n// Sends a command to an active gnuplot session\n//\nGnuplot& Gnuplot::cmd(const std::string &cmdstr)\n{\n if( !(valid) )\n {\n return *this;\n }\n\n\n // int fputs ( const char * str, FILE * stream );\n // writes the string str to the stream.\n // The function begins copying from the address specified (str) until it\n // reaches the terminating null character ('\\0'). This final\n // null-character is not copied to the stream.\n fputs( (cmdstr+\"\\n\").c_str(), gnucmd );\n\n // int fflush ( FILE * stream );\n // If the given stream was open for writing and the last i/o operation was\n // an output operation, any unwritten data in the output buffer is written\n // to the file. If the argument is a null pointer, all open files are\n // flushed. The stream remains open after this call.\n fflush(gnucmd);\n\n\n if( cmdstr.find(\"replot\") != std::string::npos )\n {\n return *this;\n }\n else if( cmdstr.find(\"splot\") != std::string::npos )\n {\n two_dim = false;\n nplots++;\n }\n else if( cmdstr.find(\"plot\") != std::string::npos )\n {\n two_dim = true;\n nplots++;\n }\n\n return *this;\n}\n\n\n\n//------------------------------------------------------------------------------\n//\n// Opens up a gnuplot session, ready to receive commands\n//\nvoid Gnuplot::init()\n{\n // char * getenv ( const char * name ); get value of environment variable\n // Retrieves a C string containing the value of the environment variable\n // whose name is specified as argument. If the requested variable is not\n // part of the environment list, the function returns a NULL pointer.\n#if ( defined(unix) || defined(__unix) || defined(__unix__) ) && !defined(__APPLE__)\n if (getenv(\"DISPLAY\") == NULL)\n {\n valid = false;\n throw GnuplotException(\"Can't find DISPLAY variable\");\n }\n#endif\n\n\n // if gnuplot not available\n if (!Gnuplot::get_program_path())\n {\n valid = false;\n throw GnuplotException(\"Can't find gnuplot\");\n }\n\n\n //\n // open pipe\n //\n std::string tmp = Gnuplot::m_sGNUPlotPath + \"/\" +\n Gnuplot::m_sGNUPlotFileName;\n\n // FILE *popen(const char *command, const char *mode);\n // The popen() function shall execute the command specified by the string\n // command, create a pipe between the calling program and the executed\n // command, and return a pointer to a stream that can be used to either read\n // from or write to the pipe.\n#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__)\n gnucmd = _popen(tmp.c_str(),\"w\");\n#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)\n gnucmd = popen(tmp.c_str(),\"w\");\n#endif\n\n // popen() shall return a pointer to an open stream that can be used to read\n // or write to the pipe. Otherwise, it shall return a null pointer and may\n // set errno to indicate the error.\n if (!gnucmd)\n {\n valid = false;\n throw GnuplotException(\"Couldn't open connection to gnuplot\");\n }\n\n nplots = 0;\n valid = true;\n smooth = \"\";\n\n //set terminal type\n showonscreen();\n\n return;\n}\n\n\n//------------------------------------------------------------------------------\n//\n// Find out if a command lives in m_sGNUPlotPath or in PATH\n//\nbool Gnuplot::get_program_path()\n{\n //\n // first look in m_sGNUPlotPath for Gnuplot\n //\n std::string tmp = Gnuplot::m_sGNUPlotPath + \"/\" +\n Gnuplot::m_sGNUPlotFileName;\n\n#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__)\n if ( Gnuplot::file_exists(tmp,0) ) // check existence\n#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)\n if ( Gnuplot::file_exists(tmp,1) ) // check existence and execution permission\n#endif\n {\n return true;\n }\n\n\n //\n // second look in PATH for Gnuplot\n //\n char *path;\n // Retrieves a C string containing the value of environment variable PATH\n path = getenv(\"PATH\");\n\n\n if (path == NULL)\n {\n throw GnuplotException(\"Path is not set\");\n return false;\n }\n else\n {\n std::list ls;\n\n //split path (one long string) into list ls of strings\n#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__)\n stringtok(ls,path,\";\");\n#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)\n stringtok(ls,path,\":\");\n#endif\n\n // scan list for Gnuplot program files\n for (std::list::const_iterator i = ls.begin();\n i != ls.end(); ++i)\n {\n tmp = (*i) + \"/\" + Gnuplot::m_sGNUPlotFileName;\n#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__)\n if ( Gnuplot::file_exists(tmp,0) ) // check existence\n#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)\n if ( Gnuplot::file_exists(tmp,1) ) // check existence and execution permission\n#endif\n {\n Gnuplot::m_sGNUPlotPath = *i; // set m_sGNUPlotPath\n return true;\n }\n }\n\n tmp = \"Can't find gnuplot neither in PATH nor in \\\"\" +\n Gnuplot::m_sGNUPlotPath + \"\\\"\";\n throw GnuplotException(tmp);\n }\n}\n\n\n\n//------------------------------------------------------------------------------\n//\n// check if file exists\n//\nbool Gnuplot::file_exists(const std::string &filename, int mode)\n{\n if ( mode < 0 || mode > 7)\n {\n throw std::runtime_error(\"In function \\\"Gnuplot::file_exists\\\": mode\\\n has to be an integer between 0 and 7\");\n return false;\n }\n\n // int _access(const char *path, int mode);\n // returns 0 if the file has the given mode,\n // it returns -1 if the named file does not exist or is not accessible in\n // the given mode\n // mode = 0 (F_OK) (default): checks file for existence only\n // mode = 1 (X_OK): execution permission\n // mode = 2 (W_OK): write permission\n // mode = 4 (R_OK): read permission\n // mode = 6 : read and write permission\n // mode = 7 : read, write and execution permission\n#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__)\n if (_access(filename.c_str(), mode) == 0)\n#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)\n if (access(filename.c_str(), mode) == 0)\n#endif\n {\n return true;\n }\n else\n {\n return false;\n }\n\n}\n\nbool Gnuplot::file_available(const std::string &filename)\n{\n std::ostringstream except;\n if( Gnuplot::file_exists(filename,0) ) // check existence\n {\n if( !(Gnuplot::file_exists(filename,4)) ) // check read permission\n {\n except << \"No read permission for File \\\"\" << filename << \"\\\"\";\n throw GnuplotException( except.str() );\n return false;\n }\n }\n else\n {\n except << \"File \\\"\" << filename << \"\\\" does not exist\";\n throw GnuplotException( except.str() );\n return false;\n }\n return false;\n}\n\n\n\n//------------------------------------------------------------------------------\n//\n// Opens a temporary file\n//\nstd::string Gnuplot::create_tmpfile(std::ofstream &tmp)\n{\n\n#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__)\n char name[] = \"gnuplotiXXXXXX\"; //tmp file in working directory\n#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)\n char name[] = \"/tmp/gnuplotiXXXXXX\"; // tmp file in /tmp\n#endif\n\n //\n // check if maximum number of temporary files reached\n //\n if (Gnuplot::tmpfile_num == GP_MAX_TMP_FILES - 1)\n {\n std::ostringstream except;\n except << \"Maximum number of temporary files reached (\"\n << GP_MAX_TMP_FILES << \"): cannot open more files\" << std::endl;\n\n throw GnuplotException( except.str() );\n }\n\n // int mkstemp(char *name);\n // shall replace the contents of the string pointed to by \"name\" by a unique\n // filename, and return a file descriptor for the file open for reading and\n // writing. Otherwise, -1 shall be returned if no suitable file could be\n // created. The string in template should look like a filename with six\n // trailing 'X' s; mkstemp() replaces each 'X' with a character from the\n // portable filename character set. The characters are chosen such that the\n // resulting name does not duplicate the name of an existing file at the\n // time of a call to mkstemp()\n\n\n //\n // open temporary files for output\n //\n#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__TOS_WIN__)\n if (_mktemp(name) == NULL)\n#elif defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)\n int tmpfd;\n if ((tmpfd = mkstemp(name)) == -1)\n#endif\n {\n std::ostringstream except;\n except << \"Cannot create temporary file \\\"\" << name << \"\\\"\";\n throw GnuplotException(except.str());\n }\n#if defined(unix) || defined(__unix) || defined(__unix__) || defined(__APPLE__)\n close(tmpfd);\n#endif\n\n tmp.open(name);\n if (tmp.bad())\n {\n std::ostringstream except;\n except << \"Cannot create temporary file \\\"\" << name << \"\\\"\";\n throw GnuplotException(except.str());\n }\n\n //\n // Save the temporary filename\n //\n tmpfile_list.push_back(name);\n Gnuplot::tmpfile_num++;\n\n return name;\n}\n\nvoid Gnuplot::remove_tmpfiles()\n{\n if ((tmpfile_list).size() > 0)\n {\n for (unsigned int i = 0; i < tmpfile_list.size(); i++)\n {\n\n if( remove( tmpfile_list[i].c_str() ) != 0 )\n {\n std::ostringstream except;\n except << \"Cannot remove temporary file \\\"\" << tmpfile_list[i] << \"\\\"\";\n throw GnuplotException(except.str());\n }\n }\n\n Gnuplot::tmpfile_num -= static_cast(tmpfile_list.size());\n }\n}\n#endif\n"
},
{
"path": "apps/helloworld_cublas/main_performance.cpp",
"content": "#include \n#include \n#include \n#include \"util/gl_wrapper.h\"\n#include \"util/OpenGL32Format.h\"\n#include \n#include \"thrust/device_vector.h\"\n#include \"thrust/host_vector.h\"\n#include \"thrust/copy.h\"\n#include \"cudax/CublasHelper.h\"\n#include \"cudax/CudaHelper.h\"\n#include \"cudax/CudaTimer.h\"\n#include \"./gnuplot_i.h\"\n\nusing namespace std;\nusing namespace cudax;\n\ntypedef float Scalar;\ntypedef Eigen::Matrix Matrix_MxN;\n\nextern \"C\" void outer_product(float* input, float* output, int rows, int cols);\nextern \"C\" void vector_product(float* J_in, float* e_in, float* Jte_out, int rows, int cols);\n\n//--\n\nextern \"C\" void outer_product_init(float* input, int rows, int cols);\nextern \"C\" void outer_product_compute(int rows, int cols);\nextern \"C\" void outer_product_copy(float* output);\n\nextern \"C\" void vector_product_init(float* J_in, float* e_in, int rows, int cols);\nextern \"C\" void vector_product_compute(int rows, int cols);\nextern \"C\" void vector_product_copy(float* Jte_out);\n\n//--\n\nvoid wait_for_key (){\n cout << endl << \"Press ENTER to continue...\" << endl;\n std::cin.clear();\n std::cin.ignore(std::cin.rdbuf()->in_avail());\n std::cin.get();\n return;\n}\n\nint main(int argc, char *argv[]){\n\n QApplication app(argc, argv);\n OpenGL32Format fmt;\n QGLWidget widget(fmt);\n widget.makeCurrent();\n\n CudaHelper::init();\n CublasHelper::init(); \n \n ///--- Jacobian multiplication\n {\n // Matrix dimensions\n const int MAX_NUM_CONSTRAINTS = 320*240;\n const int NUM_ROWS = 100;\n const int NUM_COLS = 26; ///< #DOF 1xhand\n\n // Row major matrix type\n typedef Eigen::Matrix Matrix_MxN_RowMajor;\n\n //--- JTJ computation\n\n // Large matrix with MAX_NUM_CONSTRAINTS rows\n Matrix_MxN_RowMajor J;\n J = Matrix_MxN_RowMajor::Random(MAX_NUM_CONSTRAINTS, NUM_COLS);\n\n // GPU matrix product of the top NUM_ROWS rows\n cout << \"compute:\" << endl;\n Matrix_MxN JtJ_gpu(NUM_COLS, NUM_COLS);\n\n#if 1\n outer_product_init(J.data(), NUM_ROWS, NUM_COLS);\n outer_product_compute(NUM_ROWS, NUM_COLS);\n outer_product_copy(JtJ_gpu.data());\n#else\n outer_product(J.data(), JtJ_gpu.data(), NUM_ROWS, NUM_COLS);\n#endif\n\n // CPU matrix product of the top NUM_ROWS rows\n Matrix_MxN J_sub = J.block(0, 0, NUM_ROWS, NUM_COLS);\n Matrix_MxN JtJ_cpu = J_sub.transpose() * J_sub;\n\n // Print results\n cout << \"CPU result:\" << endl << JtJ_cpu << endl << endl;\n cout << \"GPU result:\" << endl << JtJ_gpu << endl << endl;\n cout << \"Frobenius norm: \" << (JtJ_cpu - JtJ_gpu).norm() << endl << endl; \n \n //--- JTe computation\n\n // Right hand side matrix-vector multiplication\n Matrix_MxN_RowMajor e;\n e = Matrix_MxN_RowMajor::Random(MAX_NUM_CONSTRAINTS, 1);\n Matrix_MxN e_sub = e.block(0, 0, NUM_ROWS, 1);\n\n // GPU matrix-vector product\n Matrix_MxN Jte_gpu(NUM_COLS, 1);\n\n#if 1\n vector_product_init(J.data(), e.data(), NUM_ROWS, NUM_COLS);\n vector_product_compute(NUM_ROWS, NUM_COLS);\n vector_product_copy(Jte_gpu.data());\n#else\n vector_product(J.data(), e.data(), Jte_gpu.data(), NUM_ROWS, NUM_COLS);\n#endif\n\n // CPU matrix-vector product\n Matrix_MxN Jte_cpu = J_sub.transpose() * e_sub;\n\n // Print results\n cout << \"CPU result:\" << endl << Jte_cpu << endl << endl;\n cout << \"GPU result:\" << endl << Jte_gpu << endl << endl;\n cout << \"Frobenius norm: \" << (Jte_cpu - Jte_gpu).norm() << endl << endl;\n\n //--- Runtimes\n\n // Plot computation time\n vector data_x0(MAX_NUM_CONSTRAINTS); // Matrix dimension\n vector data_y1(MAX_NUM_CONSTRAINTS); // GPU JTJ runtime\n vector data_y2(MAX_NUM_CONSTRAINTS); // CPU JTJ runtime\n vector data_y3(MAX_NUM_CONSTRAINTS); // GPU JTe runtime\n vector data_y4(MAX_NUM_CONSTRAINTS); // CPU JTe runtime\n\n CudaTimer timer;\n\n for(int i = 0; i < MAX_NUM_CONSTRAINTS; i += 100){\n int N = i+1;\n float x = (float)N;\n\n //--- JTJ\n\n Matrix_MxN_RowMajor J_test = J.block(0,0,N,NUM_COLS);\n Matrix_MxN JtJ_test(NUM_COLS, NUM_COLS);\n\n // GPU\n outer_product_init(J_test.data(), N, NUM_COLS);\n timer.restart(\"\");\n outer_product_compute(N, NUM_COLS);\n //outer_product(J_test.data(), JtJ_test.data(), N, NUM_COLS);\n float y1 = timer.elapsed();\n outer_product_copy(JtJ_test.data());\n\n // CPU\n timer.restart(\"\");\n Matrix_MxN JtJ_test_cpu = J_test.transpose() * J_test;\n float y2 = timer.elapsed();\n\n //cout << \"Frobenius norm: \" << (JtJ_test - JtJ_test_cpu).norm() << endl << endl;\n\n //--- JTe\n\n Matrix_MxN_RowMajor e_test = e.block(0,0,N,1);\n Matrix_MxN Jte_test(NUM_COLS, 1);\n\n // GPU\n vector_product_init(J_test.data(), e_test.data(), N, NUM_COLS);\n timer.restart(\"\");\n vector_product_compute(N, NUM_COLS);\n //vector_product(J_test.data(), e_test.data(), Jte_test.data(), N, NUM_COLS);\n float y3 = timer.elapsed();\n vector_product_copy(Jte_test.data());\n\n // CPU\n timer.restart(\"\");\n Matrix_MxN Jte_test_cpu = J_test.transpose() * e_test;\n float y4 = timer.elapsed();\n\n //cout << \"Frobenius norm: \" << (Jte_test - Jte_test_cpu).norm() << endl << endl;\n\n data_x0.push_back(x);\n data_y1.push_back(y1);\n data_y2.push_back(y2);\n data_y3.push_back(y3);\n data_y4.push_back(y4);\n }\n\n try{\n Gnuplot::set_terminal_std(\"qt\");\n Gnuplot plot(\"lines\");\n plot.set_title(\"Computation time of J^T * J w.r.t. number of rows of J in milliseconds\");\n plot.set_grid();\n plot.plot_xy(data_x0, data_y1, \"GPU JTJ\");\n plot.plot_xy(data_x0, data_y2, \"CPU JTJ\");\n plot.plot_xy(data_x0, data_y3, \"GPU JTe\");\n plot.plot_xy(data_x0, data_y4, \"CPU JTe\");\n\n cout << \"Computation time for \"\n << MAX_NUM_CONSTRAINTS << \" x \"\n << NUM_COLS << \" matrix: \"\n << data_y1[data_y1.size()-1] << \" ms [GPU], \"\n << data_y2[data_y2.size()-1] << \" ms [CPU]\"\n << endl;\n\n wait_for_key(); ///< avoid window closing right away\n }catch(GnuplotException &e){\n cout << e.what() << endl;\n }\n }\n\n CublasHelper::cleanup();\n exit(0);\n\n return 0;\n}\n\n\n"
},
{
"path": "apps/helloworld_cublas/main_simple.cpp",
"content": "///--- Computes matrix products on GPU\n/// this example is broken, but if it runs it's \"okay\"\n/// TODO: matthias, it runs but frobenius is non-zero... why?\n\n#include \n#include \"util/gl_wrapper.h\"\n#include \"util/OpenGL32Format.h\"\n#include \n#include \n#include \n#include \"cudax/CublasHelper.h\"\n#include \"cudax/CudaHelper.h\"\n#include \"cudax/CublasHelper.h\"\n\nusing namespace std;\nusing namespace cudax;\n\ntypedef float Scalar;\ntypedef Eigen::Matrix Matrix_MxN;\nextern \"C\" void outer_product(float* input, float* output, int rows, int cols);\n\nint main(int argc, char *argv[]){\n QApplication app(argc, argv); \n OpenGL32Format fmt;\n QGLWidget widget(fmt);\n widget.makeCurrent();\n CudaHelper::init();\n CublasHelper::init();\n \n {\n Matrix_MxN J = Matrix_MxN::Random(100,10);\n Matrix_MxN JtJ(J.cols(),J.cols()); \n outer_product(J.data(), JtJ.data(), J.rows(), J.cols());\n cout << J.transpose() * J << endl;\n cout << endl << endl;\n cout << JtJ << endl;\n cout << endl << endl;\n cout << \"Frobenius norm: \" << (J.transpose()*J - JtJ).norm() << endl;\n }\n \n CublasHelper::cleanup();\n CudaHelper::cleanup();\n return 0;\n}\n"
},
{
"path": "apps/helloworld_cudagl/CMakeLists.txt",
"content": "cmake_minimum_required(VERSION 2.8)\nget_filename_component(PROJECTNAME ${CMAKE_CURRENT_LIST_DIR} NAME)\nproject(${PROJECTNAME})\n\nset(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/../../cmake)\ninclude(../../cmake/ConfigureCompiler.cmake)\ninclude(../../cmake/ConfigureQt.cmake)\ninclude(../../cmake/ConfigureOpenGL.cmake)\ninclude(../../cmake/ConfigureGLEW.cmake)\ninclude(../../cmake/ConfigureCUDA.cmake)\ninclude(../../cmake/ConfigureEigen.cmake)\ninclude(../../cmake/ConfigureOpenGL.cmake)\n\nset(CMAKE_BUILD_TYPE \"Release\")\n#set(CMAKE_BUILD_TYPE \"Debug\")\n\ninclude_directories(../../) #< #include \"tracker/...\"\nfile(GLOB SOURCES \"*.h\")\nfile(GLOB HEADERS \"*.cpp\")\nadd_executable(${PROJECTNAME} ${SOURCES} ${HEADERS})\ntarget_link_libraries(${PROJECTNAME} ${LIBRARIES})\n"
},
{
"path": "apps/helloworld_cudagl/main.cpp",
"content": "// Test the CUDA OpenGL interoperability\n//\n// Performance on GeForce 650M (OSX):\n// [cudaGraphicsGLRegisterImage] 21.8078 ms\n// [1000x (w/ offscreen draw)] 1687.07 ms\n// [1000x (w/o offscreen draw)] 1438.53 ms\n// [cudaGraphicsUnregisterResource] 0.555032 ms\n// Performance on GeForce GTX980 and i5@3Ghz (Ubuntu@MIT):\n// [cudaGraphicsGLRegisterImage] 170.678 ms\n// [1000x (w/ offscreen draw)] 204.626 ms\n// [1000x (w/o offscreen draw)] 195.564 ms\n// [cudaGraphicsUnregisterResource] 0.12116 ms\n// Performance on GeForce GTX980 (Win8.1):\n// [cudaGraphicsGLRegisterImage] 109.379 ms\n// [1000x (w/ offscreen draw)] 182.223 ms\n// [1000x (w/o offscreen draw)] 156.25 ms\n// [cudaGraphicsUnregisterResource] 0 ms\n\n#include \n#include \"util/gl_wrapper.h\"\n#include \"util/tictoc.h\"\n#include \"cudax/CudaHelper.h\"\n#include \n#include \n#include \n#include \"tracker/OffscreenRender/CustomFrameBuffer.h\"\n\n///--- Create an OpenGL>3 context\nclass GLWidget : public QGLWidget{\n QOpenGLVertexArrayObject vao;\n class OpenGLFormat : public QGLFormat{\n public:\n OpenGLFormat(){\n setVersion(3,2);\n setProfile(QGLFormat::CoreProfile);\n setSampleBuffers(false); ///< no anti-aliasing\n // setSamples(1); ///< no anti-aliasing\n }\n };\npublic:\n GLWidget():QGLWidget(OpenGLFormat()){\n std::cout << \"OpenGL Context \" << this->format().majorVersion() << \".\" << this->format().minorVersion() << std::endl; \n } \n void init(){\n bool success = vao.create();\n if(!success) exit(EXIT_FAILURE);\n vao.bind(); \n }\n};\n\nint main(int argc, char* argv[]){\n printf(\"%s starting...\\n\", argv[0]);\n QApplication app(argc, argv);\n GLWidget glarea;\n glarea.show();\n glarea.init();\n\n#ifdef WITH_GLEW\n\t//--- GLEW Initialization (must have a context)\n\tglewExperimental = true;\n\tif (glewInit() != GLEW_NO_ERROR){\n\n\t\tfprintf(stderr, \"Failed to initialize GLEW\\n\");\n\t\t// return EXIT_FAILURE;\n\t}\n#endif\n\n /// As in de docs, I get the device after creating the context\n int devID = gpuGetMaxGflopsDeviceId();\n cudaError status = cudaGLSetGLDevice(devID);\n if(status!=cudaSuccess){\n std::cout << \"Could not get OpenGL compliant device... exiting\" << std::endl;\n exit(0);\n }\n \n ///--- These two are paired-up with a bind\n struct ResourcePair {\n struct cudaGraphicsResource* resouce;\n cudaArray* array;\n };\n\n ///--- OpenGL initialization\n int width = 320;\n int height = 240;\n glViewport(0,0, width, height);\n glClearColor(1.0,1.0,1.0,1.0);\n glEnable(GL_DEPTH_TEST); \n \n ///--- Framebuffer initialization\n CustomFrameBuffer fb;\n fb.init(width, width);\n GLuint texture_id = fb.extra_tex_id();\n \n ResourcePair res;\n {\n TICTOC_SCOPE(timer, \"cudaGraphicsGLRegisterImage\");\n checkCudaErrors(cudaGraphicsGLRegisterImage(&res.resouce, texture_id, GL_TEXTURE_2D, cudaGraphicsMapFlagsReadOnly));\n }\n \n auto draw_map_unmap = [&](bool with_draw){\n if(with_draw){\n TIMED_SCOPE(timer,\"offscreendraw\");\n fb.bind();\n glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);\n fb.unbind();\n glFinish(); \n }\n { \n TIMED_SCOPE(timer,\"map\");\n checkCudaErrors(cudaGraphicsMapResources(1, &res.resouce, 0));\n checkCudaErrors(cudaGraphicsSubResourceGetMappedArray(&res.array, res.resouce, 0, 0));\n } \n {\n TIMED_SCOPE(timer,\"unmap\"); //~2 microseconds\n checkCudaErrors(cudaGraphicsUnmapResources(1, &res.resouce, 0)); \n }\n };\n \n TICTOC_BLOCK(timer,\"1000x (w/ offscreen draw)\")\n for (int i = 0; i < 1000; ++i)\n draw_map_unmap(true);\n TICTOC_BLOCK(timer,\"1000x (w/o offscreen draw)\")\n for (int i = 0; i < 1000; ++i)\n draw_map_unmap(true);\n\n TICTOC_BLOCK(timer,\"cudaGraphicsUnregisterResource\")\n {\n checkCudaErrors(cudaGraphicsUnregisterResource(res.resouce));\n }\n return 0;\n}\n"
},
{
"path": "apps/helloworld_librealsense/CMakeLists.txt",
"content": "# https://github.com/IntelRealSense/librealsense/issues/62\n\ncmake_minimum_required(VERSION 2.8)\nget_filename_component(PROJECT ${CMAKE_CURRENT_LIST_DIR} NAME)\nproject(${PROJECT})\nadd_compile_options(-std=c++11 -fPIC -lusb-1.0 -lpthread )\n\n\n# libusb-1.0\nfind_package(Threads REQUIRED)\nfind_package(PkgConfig)\npkg_check_modules(PC_LIBUSB REQUIRED libusb-1.0)\ninclude_directories( ${LIBUSB_1_INCLUDE_DIRS})\n\nset(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/../../cmake)\n# include(../../cmake/ConfigureOpenCV.cmake)\ninclude(../../cmake/ConfigureOpenGL.cmake)\n\n# GLUT\n#find_package(GLUT REQUIRED)\n#include_directories(${GLUT_INCLUDE_DIRS})\n#LIST(APPEND LIBRARIES ${GLUT_LIBRARY})\n\n# GLFW\nfind_package(PkgConfig REQUIRED)\npkg_search_module(GLFW REQUIRED glfw3)\ninclude_directories(${GLFW_INCLUDE_DIRS})\nLIST(APPEND LIBRARIES ${GLFW_LIBRARIES})\n\n\n\n# librealsense\nset(LIBREALSENSE_INCLUDE_DIR \"/home/raghu/Desktop/librealsense/include\")\nset(LIBREALSENSE_LIBRARY \"/usr/local/lib/librealsense.so\")\ninclude_directories(${LIBREALSENSE_INCLUDE_DIR})\nlist(APPEND LIBRARIES ${LIBREALSENSE_LIBRARY})\n\naux_source_directory(. SRC_LIST)\nadd_executable(${PROJECT_NAME} ${SRC_LIST})\ntarget_link_libraries( ${PROJECT_NAME} ${LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} )\n"
},
{
"path": "apps/helloworld_librealsense/main.cpp",
"content": "// License: Apache 2.0. See LICENSE file in root directory.\n// Copyright(c) 2015 Intel Corporation. All Rights Reserved.\n\n///////////////////////////////////////////////////////\n// librealsense tutorial #3 - Point cloud generation //\n///////////////////////////////////////////////////////\n\n// First include the librealsense C++ header file\n#include \n#include \n\n// Also include GLFW to allow for graphical display\n#define GLFW_INCLUDE_GLU\n#include \n\ndouble yaw, pitch, lastX, lastY; int ml;\nstatic void on_mouse_button(GLFWwindow * win, int button, int action, int mods)\n{\n if(button == GLFW_MOUSE_BUTTON_LEFT) ml = action == GLFW_PRESS;\n}\nstatic double clamp(double val, double lo, double hi) { return val < lo ? lo : val > hi ? hi : val; }\nstatic void on_cursor_pos(GLFWwindow * win, double x, double y)\n{\n if(ml)\n {\n yaw = clamp(yaw - (x - lastX), -120, 120);\n pitch = clamp(pitch + (y - lastY), -80, 80);\n }\n lastX = x;\n lastY = y;\n}\n\nint main() try\n{\n // Turn on logging. We can separately enable logging to console or to file, and use different severity filters for each.\n rs::log_to_console(rs::log_severity::warn);\n //rs::log_to_file(rs::log_severity::debug, \"librealsense.log\");\n\n // Create a context object. This object owns the handles to all connected realsense devices.\n rs::context ctx;\n printf(\"There are %d connected RealSense devices.\\n\", ctx.get_device_count());\n if(ctx.get_device_count() == 0) return EXIT_FAILURE;\n\n // This tutorial will access only a single device, but it is trivial to extend to multiple devices\n rs::device * dev = ctx.get_device(0);\n printf(\"\\nUsing device 0, an %s\\n\", dev->get_name());\n printf(\" Serial number: %s\\n\", dev->get_serial());\n printf(\" Firmware version: %s\\n\", dev->get_firmware_version());\n\n // Configure depth and color to run with the device's preferred settings\n dev->enable_stream(rs::stream::depth, rs::preset::best_quality);\n dev->enable_stream(rs::stream::color, rs::preset::best_quality);\n dev->start();\n\n // Open a GLFW window to display our output\n glfwInit();\n GLFWwindow * win = glfwCreateWindow(1280, 960, \"librealsense tutorial #3\", nullptr, nullptr);\n glfwSetCursorPosCallback(win, on_cursor_pos);\n glfwSetMouseButtonCallback(win, on_mouse_button);\n glfwMakeContextCurrent(win);\n while(!glfwWindowShouldClose(win))\n {\n // Wait for new frame data\n glfwPollEvents();\n dev->wait_for_frames();\n\n // Retrieve our images\n const uint16_t * depth_image = (const uint16_t *)dev->get_frame_data(rs::stream::depth);\n const uint8_t * color_image = (const uint8_t *)dev->get_frame_data(rs::stream::color);\n\n // Retrieve camera parameters for mapping between depth and color\n rs::intrinsics depth_intrin = dev->get_stream_intrinsics(rs::stream::depth);\n rs::extrinsics depth_to_color = dev->get_extrinsics(rs::stream::depth, rs::stream::color);\n rs::intrinsics color_intrin = dev->get_stream_intrinsics(rs::stream::color);\n float scale = dev->get_depth_scale();\n\n // Set up a perspective transform in a space that we can rotate by clicking and dragging the mouse\n glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);\n glMatrixMode(GL_PROJECTION);\n glLoadIdentity();\n gluPerspective(60, (float)1280/960, 0.01f, 20.0f);\n glMatrixMode(GL_MODELVIEW);\n glLoadIdentity();\n gluLookAt(0,0,0, 0,0,1, 0,-1,0);\n glTranslatef(0,0,+0.5f);\n glRotated(pitch, 1, 0, 0);\n glRotated(yaw, 0, 1, 0);\n glTranslatef(0,0,-0.5f);\n\n // We will render our depth data as a set of points in 3D space\n glPointSize(2);\n glEnable(GL_DEPTH_TEST);\n glBegin(GL_POINTS);\n\n for(int dy=0; dy= color_intrin.width || cy >= color_intrin.height)\n {\n glColor3ub(255, 255, 255);\n }\n else\n {\n glColor3ubv(color_image + (cy * color_intrin.width + cx) * 3);\n }\n\n // Emit a vertex at the 3D location of this depth pixel\n glVertex3f(depth_point.x, depth_point.y, depth_point.z);\n }\n }\n glEnd();\n\n glfwSwapBuffers(win);\n }\n\n return EXIT_SUCCESS;\n}\ncatch(const rs::error & e)\n{\n // Method calls against librealsense objects may throw exceptions of type rs::error\n printf(\"rs::error was thrown when calling %s(%s):\\n\", e.get_failed_function().c_str(), e.get_failed_args().c_str());\n printf(\" %s\\n\", e.what());\n return EXIT_FAILURE;\n}\n"
},
{
"path": "apps/helloworld_opencv/CMakeLists.txt",
"content": "cmake_minimum_required(VERSION 2.8)\nget_filename_component(PROJECT ${CMAKE_CURRENT_LIST_DIR} NAME)\nproject(${PROJECT})\n# cmake_policy(SET CMP0046 OLD)\n\n#set(CMAKE_BUILD_TYPE \"Release\")\n#set(CMAKE_BUILD_TYPE \"Debug\")\n\nset(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/../../cmake)\ninclude(../../cmake/ConfigureCompiler.cmake)\ninclude(../../cmake/ConfigureOpenCV.cmake)\n\nadd_executable(${PROJECT} main.cpp)\ntarget_link_libraries(${PROJECT} ${LIBRARIES})\nfile(COPY \"input.png\" DESTINATION ${PROJECT_BINARY_DIR})\n"
},
{
"path": "apps/helloworld_opencv/main.cpp",
"content": "#include \n#include \n#include \"stdlib.h\"\n#include \"opencv2/core/core.hpp\"\n#include \"opencv2/core/types_c.h\" ///< CV_RGB2GRAY\n#include \"opencv2/imgproc/imgproc.hpp\" ///< cvtColor\n#include \"opencv2/highgui/highgui.hpp\"\n\nint main(int, char **) {\n cv::Mat image = cv::imread(\"input.png\");\n std::cout << \"image size: \" << image.rows << \" \" << image.cols << std::endl;\n assert(image.rows > 0);\n assert(image.cols > 0);\n cv::cvtColor(image, image, CV_RGB2GRAY);\n cv::imshow(\"input\", image);\n cv::waitKey(0);\n exit(0);\n}\n"
},
{
"path": "apps/helloworld_openmp/CMakeLists.txt",
"content": "if(UNIX AND NOT APPLE)\n return()\nendif()\n\ncmake_minimum_required(VERSION 2.8)\nget_filename_component(PROJECT ${CMAKE_CURRENT_LIST_DIR} NAME)\nproject(${PROJECT})\n\nset(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/../../cmake)\ninclude(../../cmake/ConfigureCompiler.cmake)\ninclude(../../cmake/ConfigureOpenMP.cmake)\n\nadd_executable(${PROJECT} main.cpp)\ntarget_link_libraries(${PROJECT} ${LIBRARIES})\n"
},
{
"path": "apps/helloworld_openmp/main.cpp",
"content": "// COMPILE: /usr/local/bin/g++-4.8 -fopenmp openmp.cpp\n#include \n#include \n#include \n\nint main (int argc, char *argv[])\n{\n int nthreads, tid;\n\n /* Fork a team of threads giving them their own copies of variables */\n #pragma omp parallel private(nthreads, tid)\n {\n /* Obtain thread number */\n tid = omp_get_thread_num();\n printf(\"Hello World from thread = %d\\n\", tid);\n\n /* Only master thread does this */\n if (tid == 0)\n {\n nthreads = omp_get_num_threads();\n printf(\"Number of threads = %d\\n\", nthreads);\n }\n\n } /* All threads join master thread and disband */\n}"
},
{
"path": "apps/helloworld_openni/CMakeLists.txt",
"content": "cmake_minimum_required(VERSION 2.8)\nget_filename_component(PROJECT ${CMAKE_CURRENT_LIST_DIR} NAME)\nproject(${PROJECT})\n\n# cmake_policy(SET CMP0043 OLD)\n# cmake_policy(SET CMP0020 OLD)\n\nset(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/../../cmake)\ninclude(../../cmake/ConfigureCompiler.cmake)\ninclude(../../cmake/ConfigureOpenNI.cmake)\ninclude(../../cmake/ConfigureOpenCV.cmake)\ninclude(../../cmake/ConfigureQt.cmake)\ninclude(../../cmake/ConfigureEigen.cmake)\n\nif(OPENNI2_FOUND)\n set(CMAKE_BUILD_TYPE \"Debug\")\n INCLUDE_DIRECTORIES(../../)\n list(APPEND SOURCES ../../tracker/Data/Camera.cpp)\n list(APPEND SOURCES ../../tracker/Sensor/Sensor_openni.cpp)\n add_executable(${PROJECT} main.cpp ${SOURCES})\n target_link_libraries(${PROJECT} ${LIBRARIES})\nelse()\n message(STATUS \"Cannot compile this helloworld\")\nendif()\n"
},
{
"path": "apps/helloworld_openni/main.cpp",
"content": "#include \n#include \"util/tictoc.h\"\n#include \"util/opencv_wrapper.h\"\n#include \"tracker/Sensor/Sensor.h\"\n#include \"tracker/Data/DataFrame.h\"\n\nint main(int /*argc*/, char ** /*argv*/){ \n Camera* camera = new Camera(QVGA, 60 /*FPS*/);\n Sensor* sensor = new SensorOpenNI(camera);\n\n ///--- start the sensor \n sensor->start();\n bool success = sensor->spin_wait_for_data(5 /*seconds*/);\n assert(success);\n \n DataFrame frame(0);\n for(int i=0; i<30 /*seconds*/ *60 /*60FPS*/; i++){\n bool success = sensor->fetch_streams(frame);\n assert(success);\n // cv::normalize(frame.color, frame.color, 0, 255, cv::NORM_MINMAX);\n \n ///--- Show color\n cvtColor(frame.color, frame.color, CV_BGRA2RGBA);\n cv::imshow(\"color\", frame.color);\n \n ///--- Show depth\n cv::normalize(frame.depth, frame.depth, 0, USHRT_MAX, cv::NORM_MINMAX);\n cv::imshow(\"depth\", frame.depth);\n \n ///--- Wait a sec\n cv::waitKey(15 /*ms -> 60fps*/);\n }\n \n std::cout << \"finished!\" << std::endl;\n return 0;\n}\n"
},
{
"path": "apps/helloworld_qglviewer/CMakeLists.txt",
"content": "cmake_minimum_required(VERSION 2.8)\nget_filename_component(PROJECT ${CMAKE_CURRENT_LIST_DIR} NAME)\nproject(${PROJECT})\n#cmake_policy(SET CMP0020 OLD)\n\n#set(CMAKE_BUILD_TYPE \"Release\")\n#set(CMAKE_BUILD_TYPE \"Debug\")\n\n#--- Where to find the FindPackageName.cmake\nset(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/../../cmake)\ninclude(../../cmake/ConfigureCompiler.cmake)\ninclude(../../cmake/ConfigureQt.cmake)\ninclude(../../cmake/ConfigureOpenGL.cmake)\ninclude(../../cmake/ConfigureQGLViewer.cmake)\n\n#--- Create exe and link\nadd_executable(${PROJECT} main.cpp)\ntarget_link_libraries(${PROJECT} ${LIBRARIES})\n"
},
{
"path": "apps/helloworld_qglviewer/main.cpp",
"content": "#include \n#include \n\nclass Viewer : public QGLViewer {\n void draw() {\n /// @note this would not work in Mac as there is no compatibility profile\n /// and this is OpenGL2 stuff.\n const float nbSteps = 200.0;\n glBegin(GL_QUAD_STRIP);\n for (int i=0; i\n#include \n#include \n#include \n\n/// Format class to enable OpenGL4 core profile\nclass OpenGLFormat : public QGLFormat{\npublic:\n OpenGLFormat(){\n setVersion(3,2);\n setProfile(QGLFormat::CoreProfile);\n setSampleBuffers(false); ///< no anti-aliasing\n // setSamples(1); ///< no anti-aliasing\n }\n};\n\nclass GLWidget : public QGLWidget{\n QOpenGLVertexArrayObject vao;\npublic:\n GLWidget():QGLWidget(OpenGLFormat()){\n std::cout << \"OpenGL \" << this->format().majorVersion() << \".\" << this->format().minorVersion() << std::endl;\n }\n void initializeGL(){\n bool success = vao.create();\n if(!success) exit(EXIT_FAILURE);\n vao.bind();\n }\n\n void paintGL() {\n glClearColor(0,1,0,1); ///< green\n glClear(GL_COLOR_BUFFER_BIT);\n }\n};\n\n\nint main(int argc, char* argv[]){\n QApplication app(argc, argv);\n GLWidget glarea;\n glarea.show();\n return app.exec();\n}\n"
},
{
"path": "apps/helloworld_realsense/CMakeLists.txt",
"content": "if(NOT WIN32)\n return()\nendif()\n\ncmake_minimum_required(VERSION 2.8)\nget_filename_component(PROJECT ${CMAKE_CURRENT_LIST_DIR} NAME)\nproject(${PROJECT})\n\nset(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/../../cmake)\ninclude(../../cmake/ConfigureCompiler.cmake)\ninclude(../../cmake/ConfigureOpenNI.cmake)\ninclude(../../cmake/ConfigureOpenCV.cmake)\ninclude(../../cmake/ConfigureQt.cmake)\ninclude(../../cmake/ConfigureEigen.cmake)\ninclude(../../cmake/ConfigureRealSense.cmake)\n\nset(CMAKE_BUILD_TYPE \"Debug\")\nINCLUDE_DIRECTORIES(../../)\nlist(APPEND EXTRA_SOURCES ../../tracker/Data/Camera.cpp)\nlist(APPEND EXTRA_SOURCES ../../tracker/Sensor/Sensor_realsense.cpp)\n\nadd_executable(${PROJECT} main.cpp ${EXTRA_SOURCES})\ntarget_link_libraries(${PROJECT} ${LIBRARIES})\n"
},
{
"path": "apps/helloworld_realsense/main.cpp",
"content": "#include \n#include \"pxcsensemanager.h\"\n#include \"pxcsession.h\"\n#include \"pxcprojection.h\"\n\n#include \"util/tictoc.h\"\n#include \"util/opencv_wrapper.h\"\n#include \"tracker/Sensor/Sensor.h\"\n#include \"tracker/Data/DataFrame.h\"\n\nint main(int /*argc*/, char ** /*argv*/){\n Camera camera(QVGA, 60 /*FPS*/);\n SensorRealSense sensor(&camera);\n\n ///--- start the sensor\n sensor.start();\n bool success = sensor.spin_wait_for_data(5 /*seconds*/);\n assert(success);\n\n DataFrame frame(0);\n for(int i=0; i<30 /*seconds*/ *60 /*60FPS*/; i++){\n tic(total);\n bool success = sensor.fetch_streams(frame);\n assert(success);\n // printf(\"fetch time: %2.2f\\n\", toc(total)); fflush(stdout);\n // cv::normalize(frame.color, frame.color, 0, 255, cv::NORM_MINMAX);\n\n ///--- Show color\n cvtColor(frame.color, frame.color, CV_BGR2RGB);\n cv::imshow(\"color\", frame.color);\n ///--- Show depth\n cv::normalize(frame.depth, frame.depth, 0, USHRT_MAX, cv::NORM_MINMAX);\n cv::imshow(\"depth\", frame.depth);\n\n ///--- Wait a sec\n cv::waitKey(15 /*ms -> 60fps*/);\n }\n return 0;\n}\n\n#if 0\n/// @see file:///C:/Developer/RealSense/RSSDK/doc/HTML/index.html\nclass MyHandler : public PXCSenseManager::Handler {\npublic:\n virtual pxcStatus PXCAPI OnNewSample(pxcUID, PXCCapture::Sample *sample) {\n static auto now = std::chrono::system_clock::now();\n\n // Work on sample->color and sample->depth\n // ...\n // return NO_ERROR to continue, or any error to exit the loop\n if (sample->color!=NULL) {\n // work on the color sample\n }\n if (sample->depth!=NULL) {\n // work on the depth sample (actual useful data)\n auto now2 = std::chrono::system_clock::now();\n double elapsed = std::chrono::duration (now2-now).count();\n printf(\"elapsed: %.2f\", elapsed); fflush(stdout);\n now = now2;\n }\n\n return PXC_STATUS_NO_ERROR;\n }\n};\n\nint main(int /*argc*/, char ** /*argv*/){\n // Create a SenseManager instance\n PXCSenseManager *sm=PXCSenseManager::CreateInstance();\n\n#define SYNCHRONIZED\n#ifdef SYNCHRONIZED\n /// C++ Example 26: Capture Aligned Color and Depth Samples using the SenseManager Events\n // Select the color and depth streams\n PXCVideoModule::DataDesc ddesc={};\n ddesc.deviceInfo.streams=PXCCapture::STREAM_TYPE_COLOR|PXCCapture::STREAM_TYPE_DEPTH;\n ddesc.streams.color.frameRate = {60.0f, 60.0f};\n ddesc.streams.color.sizeMin = {320, 240};\n ddesc.streams.color.sizeMax = {320, 240};\n ddesc.streams.depth.frameRate = {60.0f, 60.0f};\n ddesc.streams.depth.sizeMin = {640, 240};\n ddesc.streams.depth.sizeMax = {640, 240};\n sm->EnableStreams(&ddesc);\n#else\n /// C++ Example 25: Capture Unaligned Color and Depth Samples using the SenseManager Events\n sm->EnableStream(PXCCapture::STREAM_TYPE_COLOR,320,240,60);\n sm->EnableStream(PXCCapture::STREAM_TYPE_DEPTH,640,240,60);\n#endif\n\n // Initialize my handler\n MyHandler handler;\n sm->Init(&handler);\n\n // Stream Data\n sm->StreamFrames(true);\n\n // Clean up\n sm->Release();\n return 0;\n}\n#endif\n\n#if 0\nint main(int /*argc*/, char ** /*argv*/){\n PXCSession* session = PXCSession::CreateInstance();\n PXCSession::ImplDesc desc={};\n desc.group=PXCSession::IMPL_GROUP_SENSOR;\n desc.subgroup=PXCSession::IMPL_SUBGROUP_VIDEO_CAPTURE;\n for (int i=0;;i++) {\n PXCSession::ImplDesc desc1;\n if (session->QueryImpl(&desc,i,&desc1)CreateImpl(&desc1,&capture);\n\n for (int i=0;;i++) {\n PXCCapture::DeviceInfo dinfo;\n if (capture->QueryDeviceInfo(i,&dinfo)CreateDevice(0);\n PXCCapture::StreamType streams=PXCCapture::STREAM_TYPE_COLOR|PXCCapture::STREAM_TYPE_DEPTH;\n for (int p=0;;p++) {\n PXCCapture::Device::StreamProfileSet profiles={};\n pxcStatus sts=device->QueryStreamProfileSet(streams, p, &profiles);\n if (stsRelease();\n capture->Release();\n }\n return 0;\n}\n#endif\n\n#if 0\nint main(int /*argc*/, char ** /*argv*/){\n PXCSenseManager *sm=PXCSenseManager::CreateInstance();\n\n // Select the color and depth streams\n sm->EnableStream(PXCCapture::STREAM_TYPE_COLOR,320,240,60);\n sm->EnableStream(PXCCapture::STREAM_TYPE_DEPTH,640,240,60);\n\n // Initialize and Stream Samples\n sm->Init();\n for (int i=0;i<20;i++) {\n // This function blocks until both samples are ready\n if (sm->AcquireFrame(true)QuerySample();\n\n // work on the samples sample->color and sample->depth\n\n // go fetching the next samples\n sm->ReleaseFrame();\n }\n\n // Close down\n sm->Release();\n exit(0);\n std::cout << \"hello world!\" << std::endl;\n return 0;\n}\n#endif\n"
},
{
"path": "apps/helloworld_thrust/CMakeLists.txt",
"content": "cmake_minimum_required(VERSION 2.8)\nget_filename_component(PROJECT ${CMAKE_CURRENT_LIST_DIR} NAME)\nproject(${PROJECT})\n\nset(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR}/../../cmake)\ninclude(../../cmake/ConfigureCompiler.cmake)\ninclude(../../cmake/ConfigureCUDA.cmake)\n\ninclude_directories(../../)\ncuda_add_executable(${PROJECT} main.cu)\ntarget_link_libraries(${PROJECT} ${LIBRARIES})\n"
},
{
"path": "apps/helloworld_thrust/main.cu",
"content": "#include \n#include \n#include \n#include \n#include \n#include \"util/tictoc.h\"\n#include \"cudax/CudaHelper.h\"\n\nint main(void)\n{\n int major = THRUST_MAJOR_VERSION;\n int minor = THRUST_MINOR_VERSION;\n std::cout << \"Thrust version: \" << major << \".\" << minor << std::endl;\n thrust::device_vector d_vec;\n thrust::host_vector h_vec(1 << 24); \n \n TICTOC_BLOCK(t_gen,\"Generate randoms + h2d transfer\")\n {\n thrust::generate(h_vec.begin(), h_vec.end(), rand);\n d_vec = h_vec; ///< \n }\n \n TICTOC_BLOCK(t_sort,\"GPU sort\")\n {\n thrust::sort(d_vec.begin(), d_vec.end()); \n cudaDeviceSynchronize(); ///< otherwise time is 0!!\n }\n \n TICTOC_BLOCK(t_back,\"d2h transfer\")\n {\n thrust::copy(d_vec.begin(), d_vec.end(), h_vec.begin()); \n }\n return 0;\n}\n"
},
{
"path": "apps/htrack_atb/AntTweakBarEventFilter.h",
"content": "#pragma once\n#include \n#include \n#ifdef WITH_ANTTWEAKBAR\n #include \"AntTweakBar.h\"\n#endif\n\n/// QGLWidget support for AntTweakBar (event forwarding)\nclass AntTweakBarEventFilter : public QObject{\nprivate:\n QGLWidget* parent;\npublic:\n AntTweakBarEventFilter(QGLWidget* parent) : QObject(parent){\n this->parent = parent;\n // all move events detected, not just when clicked\n parent->setMouseTracking(true);\n }\n\n /// Forward events to AntTweakBar\n bool eventFilter(QObject* obj, QEvent* event){\n#ifdef WITH_ANTTWEAKBAR\n bool event_on_atb = false;\n if (obj == parent) {\n QMouseEvent* me = dynamic_cast(event);\n QKeyEvent* ke = static_cast(event);\n\n TwMouseButtonID mouse_button;\n if(me!=NULL){\n if(me->button()==Qt::LeftButton) mouse_button = TW_MOUSE_LEFT;\n if(me->button()==Qt::RightButton) mouse_button = TW_MOUSE_RIGHT;\n if(me->button()==Qt::MiddleButton) mouse_button = TW_MOUSE_MIDDLE;\n }\n\n switch(event->type()){\n case QEvent::Resize:\n event_on_atb = TwWindowSize(parent->width()*2, parent->height()*2);\n // qDebug() << \"Resize\" F<< status;\n break;\n case QEvent::KeyRelease:\n event_on_atb = TwKeyPressed(ke->key(), TW_KMOD_NONE);\n // qDebug() << \"Key\" << status;\n break;\n case QEvent::MouseMove:\n event_on_atb = TwMouseMotion(me->pos().x(), me->pos().y());\n // qDebug() << \"Move\" << status << e->pos();\n break;\n case QEvent::MouseButtonPress:\n event_on_atb = TwMouseButton(TW_MOUSE_PRESSED, mouse_button);\n // qDebug() << \"Press\" << status;\n break;\n case QEvent::MouseButtonRelease:\n event_on_atb = TwMouseButton(TW_MOUSE_RELEASED, mouse_button);\n // qDebug() << \"Release\" << status;\n return true;\n default:\n break;\n }\n if(event_on_atb == true){\n parent->update();\n return true;\n }\n else\n return false; // Super::eventFilter(obj, event);\n } else {\n // pass the event on to the parent class\n return false; // Super::eventFilter(obj, event);\n }\n#else\n return false;\n#endif\n }\n};\n"
},
{
"path": "apps/htrack_atb/CMakeLists.txt",
"content": "INCLUDE_DIRECTORIES(../../) #< #include \"tracker/...\"\nfile(GLOB_RECURSE SRC \"*.cpp\")\nfile(GLOB_RECURSE HDR \"*.h\")\nadd_executable(htrack_atb ${HDR} ${SRC})\ntarget_link_libraries(htrack_atb htracksdk)\n\n"
},
{
"path": "apps/htrack_atb/main.cpp",
"content": "#include \n#include \n#include \n#include \n\n#include \"util/gl_wrapper.h\"\n#include \"util/OpenGL32Format.h\"\n#include \n#include \"AntTweakBarEventFilter.h\"\n\n#include \"tracker/ForwardDeclarations.h\"\n#include \"tracker/HandFinder/HandFinder.h\"\n#include \"tracker/Sensor/Sensor.h\"\n#include \"tracker/Data/Camera.h\"\n#include \"tracker/Calibration/Calibration.h\"\n#include \"tracker/OpenGL/KinectDataRenderer/KinectDataRenderer.h\"\n#include \"tracker/OpenGL/CylindersRenderer/Cylinders_renderer.h\"\n#include \"tracker/Tracker.h\"\n\nclass GLWidget : public QGLWidget{\npublic:\n Worker*const worker;\n DataStream*const datastream;\n SolutionStream*const solutions;\n\n Camera*const _camera;\n KinectDataRenderer kinect_renderer;\n Cylinders_renderer mrenderer;\n\npublic:\n GLWidget(Worker* worker, DataStream * datastream, SolutionStream * solution):\n QGLWidget(OpenGL32Format()),\n worker(worker),\n datastream(datastream),\n solutions(solutions),\n _camera(worker->camera),\n mrenderer(worker->cylinders)\n {\n std::cout << \"Started OpenGL \" << this->format().majorVersion() << \".\" << this->format().minorVersion() << std::endl;\n this->installEventFilter( new AntTweakBarEventFilter(this) ); ///< all actions pass through filter\n }\n\n ~GLWidget(){\n worker->cleanup_graphic_resources();\n tw_settings->tw_cleanup();\n }\n\n void initializeGL(){\n std::cout << \"GLWidget::initializeGL()\" << std::endl;\n initialize_glew();\n tw_settings->tw_init(this->width(), this->height()); ///< FIRST!!\n\n glEnable(GL_DEPTH_TEST);\n\n kinect_renderer.init(_camera);\n mrenderer.init(Cylinders_renderer::NORMAL);\n mrenderer.init_geometry(); // thick model\n\n ///--- Initialize other graphic resources\n this->makeCurrent();\n worker->init_graphic_resources();\n\n ///--- Setup with data from worker\n kinect_renderer.setup(worker->sensor_color_texture->texid(), worker->sensor_depth_texture->texid());\n }\n\n void paintGL() {\n glViewport(0,0,this->width(),this->height());\n glClearColor(1,1,1,1);\n glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);\n\n ///--- Rendering\n Eigen::Matrix4f view_projection = _camera->view_projection_matrix();\n Eigen::Matrix4f view = _camera->view_matrix();\n\n if(worker->handfinder->wristband_found())\n {\n kinect_renderer.enable_colormap(true);\n kinect_renderer.set_zNear(worker->handfinder->wristband_center()[2] - 150);\n kinect_renderer.set_zFar(worker->handfinder->wristband_center()[2] + 150);\n }\n kinect_renderer.set_uniform(\"view_projection\",view_projection);\n kinect_renderer.render();\n\n mrenderer.set_uniform(\"view\",view);\n mrenderer.set_uniform(\"view_projection\",view_projection);\n mrenderer.render();\n\n tw_settings->tw_draw();\n }\n\n void reload_model(){\n /// This recomputes segments lengths\n worker->cylinders->recomputeLengths();\n /// This accepts the new joint translations\n worker->skeleton->setInitialTranslations();\n /// This generates VBO from segments\n mrenderer.init_geometry();\n /// After change, show what's happened\n this->updateGL();\n }\n\nprivate:\n void keyPressEvent(QKeyEvent *event){\n GLWidget* qglviewer = this;\n switch(event->key()){\n case Qt::Key_Escape:\n this->close();\n break;\n case Qt::Key_1:\n // make_hand_thinner();\n worker->skeleton->scaleWidth(-5);\n Calibration::update_radius_helper(worker->cylinders, worker->skeleton);\n qglviewer->reload_model();\n break;\n case Qt::Key_2:\n // make_hand_wider();\n worker->skeleton->scaleWidth(5);\n Calibration::update_radius_helper(worker->cylinders, worker->skeleton);\n qglviewer->reload_model();\n break;\n case Qt::Key_3:\n // make_hand_shorter();\n worker->skeleton->scaleHeight(-1);\n Calibration::update_radius_helper(worker->cylinders, worker->skeleton);\n qglviewer->reload_model();\n break;\n case Qt::Key_4:\n // make_hand_longer();\n worker->skeleton->scaleHeight(1);\n Calibration::update_radius_helper(worker->cylinders, worker->skeleton);\n qglviewer->reload_model();\n break;\n case Qt::Key_5:\n // make_hand_smaller();\n worker->skeleton->scale(0.99f);\n qglviewer->reload_model();\n break;\n case Qt::Key_6:\n // make_hand_bigger();\n worker->skeleton->scale(1.01f);\n qglviewer->reload_model();\n break;\n default:\n QGLWidget::keyPressEvent(event);\n }\n }\n};\n\nint main(int argc, char* argv[]){\n Q_INIT_RESOURCE(shaders); ///< http://qt-project.org/wiki/QtResources\n QApplication app(argc, argv);\n std::cout << \"htrack starting\" << std::endl;\n std::cout << \"--Execution path: \" << QDir::currentPath().toStdString() << std::endl;\n\n#if defined(SOFTKIN) && !defined(__APPLE__)\n Camera camera(Intel, 60 /*FPS*/);\n SensorSoftKin sensor(&camera);\n#endif\n\n#if defined(DEPTHSENSEGRABBER) && !defined(__APPLE__)\n Camera camera(Intel, 60 /*FPS*/);\n SensorDepthSenseGrabber sensor(&camera);\n#endif\n\n#if defined(OPENNI)\n Camera camera(QVGA, 60 /*FPS*/);\n // Camera camera(QVGA, 30 /*FPS*/);\n SensorOpenNI sensor(&camera);\n#endif\n\n#if defined(REALSENSE)\n Camera camera(QVGA, 60 /*FPS*/);\n SensorRealSense sensor(&camera);\n#endif\n\n#if defined(LIBREALSENSE)\n Camera camera(Intel, 60 /*FPS*/);\n SensorLibRealSense sensor(&camera);\n#endif\n\n DataStream datastream(&camera);\n SolutionStream solutions;\n\n Worker worker(&camera);\n GLWidget glarea(&worker, &datastream, &solutions);\n glarea.resize(640*2,480*2); ///< force resize\n worker.bind_glarea(&glarea); ///< TODO: can we avoid this?\n\n ///--- Load calibration\n Calibration(&worker).autoload();\n // glarea->reload_model(); ///< TODO\n\n\n glarea.show(); ///< calls GLWidget::InitializeGL\n\n Tracker tracker(&worker,camera.FPS());\n tracker.sensor = &sensor;\n tracker.datastream = &datastream;\n tracker.solutions = &solutions;\n\n ///--- Starts the tracking\n tracker.toggle_tracking(true);\n\n return app.exec();\n}\n"
},
{
"path": "apps/htrack_qt/CMakeLists.txt",
"content": "#--- This project needs this extra library\ninclude(../../cmake/ConfigureQGLViewer.cmake)\n\nINCLUDE_DIRECTORIES(../../) #< #include \"tracker/...\"\nqt5_wrap_cpp(MOCS_HDRS Main_window.h OpenGL_viewer.h)\nfile(GLOB_RECURSE SRC \"*.cpp\")\nfile(GLOB_RECURSE HDR \"*.h\")\nadd_executable(htrack_qt ${HDR} ${SRC} ${MOCS_HDRS})\ntarget_link_libraries(htrack_qt htracksdk ${LIBRARIES})\n"
},
{
"path": "apps/htrack_qt/Main_window.cpp",
"content": "#include \"Main_window.h\"\n\n#include \n#include \n#include \"OpenGL_viewer.h\"\n#include \"tracker/OpenGL/DebugRenderer/DebugRenderer.h\"\n#include \"cudax/Timer.h\"\n#include \"util/opencv_wrapper.h\"\n#include \"util/mylogger.h\"\n\n#include \"tracker/Worker.h\"\n#include \"tracker/Tracker.h\"\n#include \"tracker/Data/SolutionStream.h\"\n#include \"tracker/Data/DataStream.h\"\n#include \"tracker/Calibration/Calibration.h\"\n#include \"tracker/HandFinder/HandFinder.h\"\n#include \"tracker/DataStructure/SkeletonSerializer.h\"\n\nMain_window::Main_window(Worker* worker, DataStream* stream, SolutionStream* solutions, OpenGL_viewer* qglviewer):\n worker(worker), datastream(stream), solutions(solutions), qglviewer(qglviewer){\n /// Delete class when window closes\n this->setAttribute(Qt::WA_DeleteOnClose);\n\n\n QWidget* widget = new QWidget(this);\n QVBoxLayout* v_layout = new QVBoxLayout;\n //v_layout->setAlignment(Qt::AlignCenter);\n widget->setLayout(v_layout);\n this->setCentralWidget(widget);\n\n /// Part 2: opengl\n {\n // qglviewer->setFixedSize(870, 870);\n v_layout->addWidget(qglviewer);\n // qglviewer->show();\n }\n\n /// Part 3: scrollbar\n {\n QHBoxLayout* h_layout = new QHBoxLayout;\n slider = new QSlider(Qt::Horizontal);\n\t\tslider->setMaximumHeight(24);\n slider_label = new QLabel(\"0/0\");\n\t\tslider_label->setMaximumHeight(24);\n toggle_live_ = new QPushButton(\"LIVE\");\n\t\ttoggle_live_->setMaximumHeight(24);\n toggle_live_->setCheckable(true);\n toggle_live_->setChecked(false);\n h_layout->addWidget(toggle_live_);\n toggle_record_ = new QPushButton(\"REC\");\n\t\ttoggle_record_->setMaximumHeight(24);\n toggle_record_->setCheckable(true);\n toggle_record_->setChecked(false);\n h_layout->addWidget(toggle_record_);\n h_layout->addWidget(slider);\n h_layout->addWidget(slider_label);\n v_layout->addLayout(h_layout);\n }\n\n ///--- Events\n connect(slider, SIGNAL(sliderMoved(int)), this, SLOT(display_frame(int)));\n\n /// Menu\n {\n //--- File menu\n QMenu* file = menuBar()->addMenu(\"File\");\n {\n QAction* save = file->addAction( \"Save\" );\n save->setShortcut( QKeySequence(Qt::CTRL + Qt::Key_S) );\n connect(save, SIGNAL(triggered()), this, SLOT(save_slot()));\n }\n {\n QAction* load = file->addAction( \"Open\" );\n load->setShortcut( QKeySequence(Qt::CTRL + Qt::Key_O) );\n connect(load, SIGNAL(triggered()), this, SLOT(load_slot()));\n }\n {\n connect(file->addAction(\"Save frame\"), SIGNAL(triggered()), this, SLOT(save_frame_slot()));\n }\n file->addSeparator();\n {\n QAction* action = file->addAction( \"Save tracking\" );\n connect(action, SIGNAL(triggered()), this, SLOT(save_tracking_pressed()));\n }\n {\n QAction* action = file->addAction( \"Load tracking\" );\n connect(action, SIGNAL(triggered()), this, SLOT(load_tracking_pressed()));\n }\n file->addSeparator(); \n {\n QAction* action = file->addAction( \"Save results\" );\n connect(action, SIGNAL(triggered()), this, SLOT(save_results_pressed()));\n }\n {\n QAction* action = file->addAction( \"Save results (one frame)\" );\n connect(action, SIGNAL(triggered()), this, SLOT(save_results_single_pressed()));\n }\n {\n QAction* action = file->addAction( \"Save joint positions (seq.)\" );\n connect(action, SIGNAL(triggered()), this, SLOT(save_joint_position_list()));\n }\n \n //--- Track menu\n QMenu* track = menuBar()->addMenu(\"Track\");\n {\n // worker->initialize_offset(frame);\n QAction* action = track->addAction( \"Offset initialization\" );\n action->setShortcut( Qt::Key_I );\n connect(action, SIGNAL(triggered()), this, SLOT(menu_initialize_offset()));\n }\n {\n QAction* action = track->addAction(\"Re-Init from previous frame\");\n action->setShortcut( Qt::Key_F2 );\n connect(action, SIGNAL(triggered()), this, SLOT(reinit_from_previous_frame()));\n }\n {\n QAction* action = track->addAction( \"Optimize current (1x)\" );\n#ifdef __unix__\n action->setShortcut( Qt::Key_T );\n#else\n action->setShortcut( Qt::Key_F1 ); \n#endif\n connect(action, SIGNAL(triggered()), this, SLOT(menu_track_pressed()));\n }\n {\n QAction* action = track->addAction( \"Optimize current (convergence)\" );\n // action->setShortcut( Qt::Key_F2 );\n connect(action, SIGNAL(triggered()), this, SLOT(menu_track_till_convergence_pressed()));\n }\n {\n A_track_whole = track->addAction( \"Re-Optimize whole sequence\" );\n A_track_whole->setShortcut( Qt::Key_F3 );\n A_track_whole->setCheckable(true);\n connect(A_track_whole, SIGNAL(toggled(bool)), this, SLOT(track_whole_sequence(bool)));\n }\n {\n QAction* action = track->addAction( \"Set Valid (to scrub solution)\" );\n connect(action, SIGNAL(triggered()), this, SLOT(menu_set_valid()));\n }\n {\n QAction* action = track->addAction( \"Set current solution\" );\n // action->setShortcut( Qt::Key_S );\n connect(action, SIGNAL(triggered()), this, SLOT(menu_set_current_solution()));\n }\n {\n A_replay = track->addAction( \"Replay sequence\" );\n A_replay->setShortcut( Qt::Key_Space );\n A_replay->setCheckable(true);\n connect(A_replay, SIGNAL(toggled(bool)), this, SLOT(replay_sequence(bool)));\n }\n {\n QAction* action = track->addAction( \"Next frame\" );\n action->setShortcut( Qt::Key_Right );\n connect(action, SIGNAL(triggered()), this, SLOT(display_next_frame()));\n }\n {\n QAction* action = track->addAction( \"Prevous frame\" );\n action->setShortcut( Qt::Key_Left );\n connect(action, SIGNAL(triggered()), this, SLOT(display_previous_frame()));\n }\n \n QMenu* extra = menuBar()->addMenu(\"Extra\");\n { \n connect(extra->addAction(\"Save Calibration\"), SIGNAL(triggered()), this, SLOT(save_calibration_slot()));\n connect(extra->addAction(\"Load Calibration\"), SIGNAL(triggered()), this, SLOT(load_calibration_slot()));\n extra->addSeparator(); \n connect(extra->addAction(\"Reload Model\"), SIGNAL(triggered()), qglviewer, SLOT(reload_model()));\n }\n }\n\n /// I have data on load\n if (stream->size()>1) {\n qDebug() << \"#available frames\" << stream->num_frames()-1;\n slider->setRange(0,stream->num_frames()-1);\n display_frame(0);\n }\n}\n\nvoid Main_window::requested_track(int fid)\n{\n // LOG(INFO) << \"Main_window::requested_track\";\n //solutions->invalidate(fid); ///< we are building it\n DataFrame& frame = datastream->get_frame(fid);\n worker->track(frame,false,false);\n solutions->set(fid, worker->skeleton->getCurrentParameters());\n qglviewer->updateGL();\n}\n\nvoid Main_window::reinit_from_previous_frame(){\n int fid = slider->value();\n if(fid==0) return;\n worker->skeleton->set( solutions->get(fid-1) ); \n}\n\nvoid Main_window::requested_track_till_convergence(int fid){\n // solutions->invalidate(fid); ///< we are building it\n DataFrame& frame = datastream->get_frame(fid);\n worker->track_till_convergence(frame);\n solutions->set(fid, worker->skeleton->getCurrentParameters());\n qglviewer->updateGL();\n}\n\nvoid Main_window::track_whole_sequence(bool checked){\n ///--- Don't restart if disabling\n if(checked==false) return;\n \n int start_at = slider->value();\n \n // LOG(INFO) << \"!!!Warning only doing first 10\";\n solutions->invalidate(start_at); ///< we are building it\n solutions->resize(datastream->size());\n for (int fid = start_at; fid < datastream->num_frames(); fid++){\n DataFrame& frame = datastream->get_frame(fid);\n display_frame(fid);\n\n ///--- Track\n worker->track_till_convergence(frame);\n ///--- Save\n solutions->set(fid, worker->skeleton->getCurrentParameters());\n \n qglviewer->updateGL();\n QApplication::processEvents();\n \n ///--- Allow user to interrupt\n if(A_track_whole->isChecked()==false)\n break;\n }\n \n ///--- If we did all this work, we might as well just save it...\n solutions->save(\"tracks/last_track_whole_sequence.track\");\n solutions->setValid(); ///< we are done building\n A_track_whole->setChecked(false);\n}\n\nvoid Main_window::set_current_solution(int fid){\n solutions->set(fid, worker->skeleton->getCurrentParameters());\n qglviewer->updateGL();\n}\n\nvoid Main_window::replay_sequence(bool checked){\n if(checked==false) return;\n float interval = 1000.0f / worker->camera->FPS();\n \n cudax::Timer t;\n for (int fid = 0; fid < datastream->num_frames(); fid++){\n t.restart(\"\");\n\n DataFrame& frame = datastream->get_frame(fid);\n display_frame(fid);\n QApplication::processEvents();\n\n ///--- Allow user to interrupt\n if(A_replay->isChecked()==false)\n break;\n\n // limit replay fps\n float dt = t.elapsed();\n float ms = interval- dt - 8.0f; // which 8ms?!\n if(ms>0) QThread::usleep(ms*1000);\n }\n}\n\nvoid Main_window::display_next_frame(){\n int fid = slider->value();\n display_frame(++fid);\n}\n\nvoid Main_window::display_previous_frame(){\n int fid = slider->value();\n display_frame(--fid);\n}\n\nvoid Main_window::display_latest_frame(){\n int fid = datastream->size()-1;\n \n display_frame(fid);\n}\n\nvoid Main_window::crop(int from, int to)\n{\n datastream->crop(from, to);\n this->display_latest_frame();\n}\n\nvoid Main_window::save_tracking_pressed()\n{\n QString filename = QFileDialog::getSaveFileName(QApplication::activeWindow(), tr(\"Save tracking as...\"), QDir::currentPath()+\"/tracks\");\n solutions->save(filename);\n}\n\nvoid Main_window::load_tracking_pressed()\n{\n QString filename = QFileDialog::getOpenFileName(QApplication::activeWindow(), tr(\"Load tracking\"), QDir::currentPath()+\"/tracks\");\n solutions->load(filename);\n}\n\nvoid Main_window::save_results_pressed()\n{\n ///--- Pick a folder\n QDir().mkdir(\"results\"); ///< just returns false if exists\n QString fname = QFileDialog::getExistingDirectory(QApplication::activeWindow(), \n \"Save Image Sequence in folder...\", \n QDir::currentPath()+\"/results\" \n /*, QFileDialog::ShowDirsOnly*/);\n if(fname.isNull())\n return;\n \n ///--- Save images\n qglviewer->transparent_background = true;\n for (int fid = 0; fid < datastream->num_frames(); fid++){\n worker->skeleton->set( solutions->get(fid) );\n display_frame(fid);\n qglviewer->updateGL();\n QApplication::processEvents();\n glFinish();\n ///--- Time to save\n QString filename = fname + QString(\"/%1.png\").arg(fid, /*pad to 10k*/ 6, /*base*/ 10, /*fillchar*/ QLatin1Char('0'));\n#define SAVE_RESULTS_EXPORT\n#ifdef SAVE_RESULTS_EXPORT\n QImage img = qglviewer->grabFrameBuffer(/*withAlpha=*/false);\n#else\n QImage img = glarea->grabFrameBuffer(/*withAlpha=*/true);\n#endif\n img.save(filename);\n }\n qglviewer->transparent_background = false;\n}\n\nvoid Main_window::save_results_single_pressed()\n{\n QString fname = QFileDialog::getSaveFileName(QApplication::activeWindow(), \n \"Save Image in file...\", \n QDir::currentPath()+\"/results\");\n if(fname.isEmpty()) return;\n \n qglviewer->transparent_background = true;\n {\n int fid = slider->value();\n worker->skeleton->set( solutions->get(fid) );\n display_frame(fid);\n qglviewer->updateGL();\n QApplication::processEvents();\n glFinish();\n ///--- Time to save \n#define SAVE_RESULTS_SINGLE_EXPORT\n#ifdef SAVE_RESULTS_SINGLE_EXPORT\n QImage img = qglviewer->grabFrameBuffer(/*withAlpha=*/false);\n#else\n QImage img = qglviewer->grabFrameBuffer(/*withAlpha=*/true);\n#endif\n img.save(fname);\n }\n qglviewer->transparent_background = false;\n}\n\nvoid Main_window::menu_initialize_offset()\n{\n worker->handfinder->binary_classification(worker->current_frame);\n worker->trivial_detector->exec(worker->current_frame, worker->handfinder->sensor_silhouette);\n qglviewer->updateGL();\n}\n\nvoid Main_window::menu_set_valid()\n{\n //allows sequence to be scrubbed\n solutions->setValid();\n}\n\nvoid Main_window::display_frame(int frame_id){\n if((frame_id<0) || !(frame_idsize())){\n mWarning(\"frame_id out of range: 0<=%d<%d\\n\",frame_id, datastream->size());\n fflush(stdout);\n return;\n }\n DataFrame& frame = datastream->get_frame(frame_id);\n update_slider(frame_id);\n update_sliderlabel(frame_id);\n \n if(solutions->isValid(frame_id)){\n std::vector theta = solutions->get(frame_id);\n if(theta.size()>0)\n worker->skeleton->set(theta);\n }\n\n ///--- If it's already done nothing happens anyway...\n worker->handfinder->binary_classification(frame);\n\n ///--- Update the current dataframe in the worker\n worker->current_frame = frame;\n \n ///--- Upload the new texture data (if necessary)\n worker->sensor_color_texture->load(frame.color.data, frame.id );\n worker->sensor_depth_texture->load(frame.depth.data, frame.id );\n qglviewer->updateGL();\n}\n\nvoid Main_window::save_slot(){ \n QString filename = QFileDialog::getSaveFileName(QApplication::activeWindow(), tr(\"Save as...\"), QDir::currentPath()+\"/recs\");\n datastream->save(filename);\n}\n\nvoid Main_window::load_slot(){ \n QString filename = QFileDialog::getOpenFileName(QApplication::activeWindow(), tr(\"Load...\"), QDir::currentPath()+\"/recs\");\n datastream->load(filename);\n\n ///--- Load default calibration\n Calibration(worker).autoload();\n qglviewer->reload_model();\n\n ///--- Load the first frame\n if(datastream->size()>0)\n display_frame(0);\n}\n\nvoid Main_window::save_frame_slot(){\n int fid = slider->value();\n DataFrame& frame = datastream->get_frame(fid);\n QString filename = QFileDialog::getSaveFileName(this, tr(\"Save as...\"), QDir::currentPath());\n if( !filename.isNull() ){\n cv::Mat color_bgr;\n cv::cvtColor(frame.color, color_bgr, CV_RGB2BGR);\n bool s1 = cv::imwrite((filename+\"_color.png\").toStdString().c_str(), color_bgr);\n bool s2 = cv::imwrite((filename+\"_depth.png\").toStdString().c_str(), frame.depth);\n if(!s1 || !s2) LOG(INFO) << \"somethign went wrong\";\n LOG(INFO) << \"frame# fid saved to files \" << filename.toStdString() << \"_{color,depth}.png\";\n /// TEST (yes, opencv stores BGR instead of RGB)\n // QImage im1((uchar*) frame.color.data, stream->width(), stream->height(), QImage::Format_RGB888);\n // im1.save(filename+\"_color2.png\");\n }\n}\n\nvoid Main_window::save_calibration_slot(){ \n QString filename = QFileDialog::getSaveFileName(QApplication::activeWindow(), tr(\"Save calibration as...\"), QDir::currentPath()+\"/calib\");\n Calibration(worker).save(filename.toStdString());\n}\n\nvoid Main_window::load_calibration_slot(){ \n QString filename = QFileDialog::getOpenFileName(QApplication::activeWindow(), tr(\"Load calibration...\"), QDir::currentPath()+\"/calib\");\n Calibration(worker).load(filename.toStdString());\n qglviewer->reload_model();\n qglviewer->updateGL();\n}\n\nvoid Main_window::update_slider(int frame){\n slider->setRange(0,datastream->size());\n slider->setValue(frame);\n}\n\nvoid Main_window::update_sliderlabel(int frame_id){\n QString one_frame_idx = QString::number(frame_id);\n QString frames_size = QString::number(datastream->size()-1);\n slider_label->setText(one_frame_idx+\"/\"+frames_size);\n}\n\n//== hand calibration =============================================//\n\nvoid Main_window::keyPressEvent(QKeyEvent *event){\n /// @todo this is __DUPLICATE CODE__ (TW application needs to do the same)\n switch(event->key()){\n case Qt::Key_Escape:\n this->close();\n break;\n case Qt::Key_1:\n // make_hand_thinner();\n worker->skeleton->scaleWidth(-5);\n Calibration::update_radius_helper(worker->cylinders, worker->skeleton);\n qglviewer->reload_model();\n break;\n case Qt::Key_2:\n // make_hand_wider();\n worker->skeleton->scaleWidth(5);\n Calibration::update_radius_helper(worker->cylinders, worker->skeleton);\n qglviewer->reload_model();\n break;\n case Qt::Key_3:\n // make_hand_shorter();\n worker->skeleton->scaleHeight(-1);\n Calibration::update_radius_helper(worker->cylinders, worker->skeleton);\n qglviewer->reload_model();\n break;\n case Qt::Key_4:\n // make_hand_longer();\n worker->skeleton->scaleHeight(1);\n Calibration::update_radius_helper(worker->cylinders, worker->skeleton);\n qglviewer->reload_model();\n break;\n case Qt::Key_5:\n // make_hand_smaller();\n worker->skeleton->scale(0.99f);\n qglviewer->reload_model();\n break;\n case Qt::Key_6:\n // make_hand_bigger();\n worker->skeleton->scale(1.01f);\n qglviewer->reload_model();\n break;\n default:\n QMainWindow::keyPressEvent(event);\n }\n}\n//=================================================================//\n\n//--------------------------------------------------------------------------------------------------\n//--------------------------------------------------------------------------------------------------\n//--------------------------- EXPERIMENTS -------------------------------------\n//--------------------------------------------------------------------------------------------------\n//--------------------------------------------------------------------------------------------------\n\nvoid Main_window::save_joint_position_list(){\n std::ofstream out(\"joint_positions.txt\");\n for (int fid = 0; fid < datastream->num_frames(); fid++){\n ///--- apply parameters\n worker->skeleton->set( solutions->get(fid) );\n ///--- save joint positions to file\n for(int i=0; iskeleton->getNumberOfJoints(); i++){\n Joint * joint = worker->skeleton->getJoint(i);\n cout << joint->getName() << std::endl;\n Vector3 s = joint->getGlobalTranslation(); \n out << s.transpose() << \" \";\n }\n out << std::endl;\n }\n out.close();\n}\n\n"
},
{
"path": "apps/htrack_qt/Main_window.h",
"content": "#pragma once\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"tracker/ForwardDeclarations.h\"\n\nclass OpenGL_viewer;\n\nclass Main_window : public QMainWindow{\n Q_OBJECT\nprivate:\n Worker*const worker;\n OpenGL_viewer*const qglviewer;\n DataStream*const datastream;\n SolutionStream*const solutions;\n QSlider* slider;\n QLabel* slider_label;\npublic:\n QPushButton* toggle_record_;\n QPushButton* toggle_live_;\n\npublic:\n ~Main_window(){ /*LOG(INFO) << __FUNCTION__;*/ }\n Main_window(Worker *worker, DataStream* datastream, SolutionStream* solutions, OpenGL_viewer* qglviewer);\n\npublic slots:\n void reinit_from_previous_frame();\n void requested_track(int);\n void requested_track_till_convergence(int);\n void track_whole_sequence(bool checked);\n void set_current_solution(int);\n void replay_sequence(bool checked);\n\npublic slots:\n void display_frame(int frame_id);\n void display_latest_frame();\n void display_next_frame();\n void display_previous_frame();\n void crop(int from, int to);\n void save_tracking_pressed();\n void load_tracking_pressed();\n void save_results_pressed();\n void save_results_single_pressed();\n/// @{ actions\nprivate:\n QAction* A_track_whole = NULL;\n QAction* A_replay = NULL;\n/// @}\n\n/// @{\nprivate slots:\n void menu_track_pressed(){ emit requested_track(slider->value());}\n void menu_track_till_convergence_pressed(){ emit requested_track_till_convergence(slider->value()); }\n void menu_initialize_offset();\n void menu_set_current_solution(){ emit set_current_solution(slider->value()); };\n void menu_set_valid();\n/// @}\n\n\nprivate slots:\n void save_slot();\n void load_slot();\n void save_frame_slot();\n void save_calibration_slot();\n void load_calibration_slot();\n void save_joint_position_list();\nprivate:\n void update_gui(int frame_id);\n void update_slider(int frame);\n void update_sliderlabel(int frame_id);\n\nprivate:\n void keyPressEvent(QKeyEvent *event);\n};\n"
},
{
"path": "apps/htrack_qt/OpenGL_viewer.cpp",
"content": "#include \"OpenGL_viewer.h\"\n\n///--- External\n#include \n#include \n\n#ifdef WITH_QGLVIEWER\n#include \n#include \n#include \n#endif\n\n#include \"util/OpenGL32Format.h\"\n#include \"util/eigen_opengl_helpers.h\"\n\n///--- Internal\n#include \"tracker/OpenGL/QuadRenderer/QuadRenderer.h\"\n#include \"tracker/OpenGL/CylindersRenderer/Cylinders_renderer.h\"\n#include \"tracker/OpenGL/KinectDataRenderer/KinectDataRenderer.h\"\n#include \"tracker/OpenGL/DebugRenderer/DebugRenderer.h\"\n#include \"tracker/Data/TextureColor8UC3.h\"\n#include \"tracker/Data/TextureDepth16UC1.h\"\n\n#include \"tracker/Data/Camera.h\"\n#include \"tracker/Worker.h\"\n#include \"util/mylogger.h\"\n\n/// IMREAD TEST\n#include \"opencv2/highgui/highgui.hpp\"\n#include \"tracker/HandFinder/HandFinder.h\"\n#include \"tracker/DataStructure/SkeletonSerializer.h\"\n\n// #define RESULTS\n\nOpenGL_viewer::OpenGL_viewer(Worker *_worker) : OpenGL_viewer_Superclass(OpenGL32Format(), NULL), worker(_worker), _camera(_worker->camera){\n CHECK_NOTNULL(worker);\n CHECK_NOTNULL(worker->cylinders);\n CHECK_NOTNULL(worker->skeleton);\n CHECK_NOTNULL(worker->camera);\n\n color_ch = std::make_shared(QuadRenderer::Color, _camera);\n depth_ch = std::make_shared(QuadRenderer::Depth, _camera);\n mrenderer = std::make_shared(worker->cylinders);\n srenderer = std::make_shared(worker->cylinders);\n kinect_renderer = std::make_shared();\n\n#ifdef BROKEN_CONSTANT_ASPECT_RATIO\n /// @see http://stackoverflow.com/questions/16801237/how-to-maintain-specific-height-to-width-ratio-of-widget-in-qt5\n /// @see http://doc.qt.digia.com/qq/qq04-height-for-width.html\n QSizePolicy policy(QSizePolicy::Preferred, QSizePolicy::Preferred);\n policy.setHeightForWidth(true);\n setSizePolicy(policy);\n#else\n setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);\n#endif\n\n ///--- Create the contextual menu\n contextual = new QMenu(this);\n auto add_entry = [=](const char* name, bool _default) {\n QAction* action = contextual->addAction(name);\n action->setCheckable(true);\n action->setChecked(_default);\n return action;\n };\n draw_model = add_entry(\"draw_model\", true);\n draw_cloud = add_entry(\"draw_cloud\", true);\n draw_skeleton = add_entry(\"draw_skeleton\", false);\n contextual->addSeparator();\n draw_sensor_color = add_entry(\"draw_sensor_color\", true);\n draw_sensor_depth = add_entry(\"draw_sensor_depth\", true);\n contextual->addSeparator();\n disable_depth_test = add_entry(\"disable_depth_test\", false);\n use_kinect_camera = add_entry(\"use_kinect_camera\", false);\n draw_color_fullscreen = add_entry(\"draw_color_fullscreen\", false);\n draw_depth_fullscreen = add_entry(\"draw_depth_fullscreen\", false);\n contextual->addSeparator();\n draw_debug = add_entry(\"draw_debug\", true);\n clear_debug = contextual->addAction(\"clear_debug\");\n wristband_colormap = add_entry(\"wristband_colormap\", true);\n\n#ifdef RESULTS\n disable_depth_test->setChecked(true);\n draw_model->setChecked(false);\n draw_skeleton->setChecked(true);\n draw_sensor_color->setChecked(false);\n draw_sensor_depth->setChecked(false);\n use_kinect_camera->setChecked(true);\n#endif\n\n ///--- Connect single shot events\n connect(clear_debug, &QAction::triggered, &(DebugRenderer::instance()), &DebugRenderer::clear);\n}\n\nOpenGL_viewer::~OpenGL_viewer(){\n worker->cleanup_graphic_resources();\n}\n\nvoid OpenGL_viewer::contextMenuEvent(QContextMenuEvent* event)\n{\n#ifdef __unix__\n // MS: my OS already uses alt+click, but not ctrl+click\n if(event->modifiers().testFlag(Qt::ControlModifier))\n#else\n if(event->modifiers().testFlag(Qt::AltModifier))\n#endif\n {\n contextual->exec(event->globalPos());\n updateGL();\n }\n}\n\n\n/// @warning QGLViewer pollutes OpenGL status. Resetting it here\nvoid OpenGL_viewer::initializeGL(){\n LOG(INFO) << \"OpenGL_viewer::initializeGL() OpenGL\" << this->format().majorVersion() << \".\" << this->format().minorVersion();\n glClearColor(1.0, 1.0, 1.0, 0.0);\n glEnable(GL_DEPTH_TEST);\n\n#ifdef WITH_QGLVIEWER\n camera()->frame()->setSpinningSensitivity(100); ///<<< Disable spin\n\n /// Setup default camera\n reset_camera();\n\n /// Bindings @see QGLViewer::setDefaultMouseBindings()\n /// Extra behavior in this->mouseDoubleClickEvent()\n {\n /// Disable double click to align scene\n setMouseBinding(Qt::NoModifier, Qt::LeftButton, NO_CLICK_ACTION, true); /// ALIGN_CAMERA\n setMouseBinding(Qt::ShiftModifier, Qt::RightButton, NO_CLICK_ACTION); /// RAP_FROM_PIXEL\n setMouseBinding(Qt::NoModifier, Qt::MiddleButton, NO_CLICK_ACTION, true); /// ZOOM_TO_FIT\n }\n#endif\n\n#ifdef WITH_GLEW\n initialize_glew();\n#endif\n\n ///--- Compile/initialize shaders\n mrenderer->init(Cylinders_renderer::NORMAL);\n srenderer->init(Cylinders_renderer::SKINNY);\n color_ch->init();\n depth_ch->init();\n kinect_renderer->init(_camera);\n CHECK_ERROR_GL();\n\n ///--- Initialize other graphic resources\n this->makeCurrent();\n worker->init_graphic_resources();\n\n ///--- Setup with data from worker\n color_ch->setup(worker->sensor_color_texture->texid());\n depth_ch->setup(worker->sensor_depth_texture->texid());\n kinect_renderer->setup(worker->sensor_color_texture->texid(), worker->sensor_depth_texture->texid());\n}\n\nvoid OpenGL_viewer::mouseDoubleClickEvent(QMouseEvent* e) {\n#ifdef WITH_QGLVIEWER\n /// MeshLAB like double click action\n {\n /// Modified version of \"RAP_FROM_PIXEL\"\n if (!camera()->setPivotPointFromPixel(e->pos()))\n return; // do nothing\n camera()->setSceneCenter( camera()->pivotPoint() );\n /// Stolen from \"centerScene\"\n camera()->frame()->projectOnLine(sceneCenter(), camera()->viewDirection());\n setVisualHintsMask(1);\n update();\n }\n#endif\n}\n\nvoid OpenGL_viewer::reset_camera() {\n#ifdef WITH_QGLVIEWER\n /// Default OpenGL camera (right-hand coordinate system)\n camera()->setType(qglviewer::Camera::ORTHOGRAPHIC);\n //camera()->setType(qglviewer::Camera::PERSPECTIVE);\n camera()->setPosition(qglviewer::Vec(0,0,0));\n camera()->lookAt(qglviewer::Vec(0,0,1));\n camera()->setUpVector(qglviewer::Vec(0,1,0));\n\n /// Setup camera zNear/zFar\n camera()->setSceneCenter(qglviewer::Vec(0,0,300/*mm*/));\n camera()->setSceneRadius(200 /*mm*/);\n camera()->showEntireScene();\n#endif\n}\n\nvoid OpenGL_viewer::reload_model(){\n /// This recomputes segments lengths\n worker->cylinders->recomputeLengths();\n /// This resets the \"local\" transformations\n //worker->skeleton->resetPosture(true);\n /// This accepts the new joint translations\n worker->skeleton->setInitialTranslations();\n /// This generates VBO from segments\n mrenderer->init_geometry(); // thick model\n srenderer->init_geometry(); // skinny model\n /// After change, show what's happened\n this->updateGL();\n}\n\n\nint OpenGL_viewer::width() {\n qreal r = window()->windowHandle()->devicePixelRatio();\n return QGLWidget::width()*r;\n}\n\nint OpenGL_viewer::height() {\n qreal r = window()->windowHandle()->devicePixelRatio();\n return QGLWidget::height()*r;\n}\n\nvoid OpenGL_viewer::paintGL() {\n /// Mostly for results generation\n glEnable(GL_MULTISAMPLE);\n\n glEnable(GL_DEPTH_TEST);\n glViewport(0,0,this->width(),this->height());\n if(transparent_background)\n glClearColor(1,1,1,0); ///< transparent background\n else\n glClearColor(1,1,1,1);\n\n ///--- Clear the screen\n glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);\n\n ///--- Setup camera (Model View Projection)\n bool use_kinect_camera = this->use_kinect_camera->isChecked();\n\n Eigen::Matrix4f view_projection;\n Eigen::Matrix4f view;\n#ifndef WITH_QGLVIEWER\n use_kinect_camera = true;\n#endif\n if(!use_kinect_camera){\n#ifdef WITH_QGLVIEWER\n /// This gives me OpenGL2 style matrices (right-hand system)\n /// @see reset_camera()\n camera()->getModelViewProjectionMatrix(view_projection.data());\n camera()->getModelViewMatrix(view.data());\n /// !!! set a left-hand coordinate system (remove x-coord flip of lookAt)\n view_projection.col(0) = -view_projection.col(0);\n view.col(0) = -view.col(0);\n#else\n exit(EXIT_FAILURE);\n#endif\n }\n else{\n view_projection = _camera->view_projection_matrix();\n view = _camera->view_matrix();\n }\n // std::cout << \"MVP\\n\" << MVP << std::endl;\n // std::cout << \"MVP\" << Camera(QVGA).view_projection_matrix() << std::endl;\n\n if (draw_debug->isChecked()){\n DebugRenderer::instance().set_uniform(\"view_projection\",view_projection);\n DebugRenderer::instance().render();\n CHECK_ERROR_GL();\n }\n\n if(use_kinect_camera)\n {\n if ( draw_color_fullscreen->isChecked() )\n {\n glViewport(0,0,this->width(),this->height());\n color_ch->render();\n }\n else if( draw_depth_fullscreen->isChecked() )\n {\n glViewport(0,0,this->width(),this->height());\n depth_ch->render();\n }\n }\n\n ///--- draw model\n if (draw_model->isChecked()){\n mrenderer->set_uniform(\"view\",view);\n mrenderer->set_uniform(\"view_projection\",view_projection);\n mrenderer->render();\n CHECK_ERROR_GL();\n }\n\n ///--- draw skeleton (when it's shown transparency)\n if (draw_skeleton->isChecked() && disable_depth_test->isChecked()){\n srenderer->set_uniform(\"view\",view);\n srenderer->set_uniform(\"view_projection\",view_projection);\n srenderer->render();\n CHECK_ERROR_GL();\n }\n\n ///--- draw kinect point cloud in shader\n if(draw_cloud->isChecked())\n {\n if(wristband_colormap->isChecked() && worker->handfinder->wristband_found())\n {\n kinect_renderer->enable_colormap(true);\n kinect_renderer->set_zNear(worker->handfinder->wristband_center()[2] - 150);\n kinect_renderer->set_zFar(worker->handfinder->wristband_center()[2] + 150);\n }\n\n kinect_renderer->set_uniform(\"view_projection\",view_projection);\n kinect_renderer->render();\n CHECK_ERROR_GL();\n }\n\n ///--- draw skeleton (when it's shown on top)\n if (draw_skeleton->isChecked() && !disable_depth_test->isChecked()){\n glClear(GL_DEPTH_BUFFER_BIT);\n srenderer->set_uniform(\"view\",view);\n srenderer->set_uniform(\"view_projection\",view_projection);\n srenderer->render();\n CHECK_ERROR_GL();\n }\n\n ///--- channels overlay\n {\n ///--- Settings\n const int width = this->width()/5;\n const float ratio = 240.0/320.0;\n int height = width*ratio;\n const int pad = 10;\n\n if(draw_sensor_color->isChecked()){\n glViewport(pad,this->height()-height-pad,width,height); ///< Top left\n color_ch->render();\n CHECK_ERROR_GL();\n }\n\n if(draw_sensor_depth->isChecked()){\n glViewport(this->width()-width-pad,this->height()-height-pad,width,height); ///< Top right\n depth_ch->render();\n CHECK_ERROR_GL();\n }\n }\n\n glDisable(GL_MULTISAMPLE);\n CHECK_ERROR_GL();\n}\n"
},
{
"path": "apps/htrack_qt/OpenGL_viewer.h",
"content": "#pragma once\n#include \"tracker/ForwardDeclarations.h\"\n\n#include \"util/gl_wrapper.h\"\n#include \n#include \n\n#ifdef WITH_QGLVIEWER\n#include \ntypedef QGLViewer OpenGL_viewer_Superclass;\n#else\n#include \ntypedef QGLWidget OpenGL_viewer_Superclass;\n#endif\n\nclass OpenGL_viewer : public OpenGL_viewer_Superclass {\n Q_OBJECT\nprivate:\n Worker*const worker;\n Camera*const _camera;\n std::shared_ptr color_ch;\n std::shared_ptr depth_ch;\n std::shared_ptr mrenderer;\n std::shared_ptr srenderer;\n std::shared_ptr kinect_renderer;\n \n/// @{\nprivate:\n friend class Main_window;\n bool transparent_background = false;\n/// @} \n\n/// @{ contextual menu\nprotected:\n void contextMenuEvent(QContextMenuEvent *event);\nprotected:\n QMenu* contextual;\n QAction* draw_cloud;\n QAction* draw_skeleton;\n QAction* draw_debug;\n QAction* use_kinect_camera;\n QAction* draw_model; \n QAction* draw_sensor_color;\n QAction* draw_sensor_depth;\n QAction* draw_color_fullscreen;\n QAction* draw_depth_fullscreen;\n QAction* clear_debug; \n QAction* disable_depth_test;\n QAction* wristband_colormap;\n/// @}\n\npublic:\n /// default window size\n// QSize sizeHint() const { return QSize(640, 480); }\n QSize sizeHint() const { return QSize(800, 600); }\n OpenGL_viewer(Worker*worker);\n ~OpenGL_viewer();\n \npublic slots: \n void reset_camera();\n /// Reload for when parameters of hand are modified\n void reload_model();\npublic:\n void initializeGL(); /// Inits the whole scene (shaders, buffers, etc)\n void paintGL(); /// Draws the whole scene\n int width();\n int height();\nprotected:\n void mouseDoubleClickEvent(QMouseEvent *e);\n};\n"
},
{
"path": "apps/htrack_qt/main.cpp",
"content": "#include \"util/gl_wrapper.h\"\n\n#include \n#include \n#include \n#include \n#include \n\n\n#include \"OpenGL_viewer.h\"\n#include \"Main_window.h\"\n#include \"util/mylogger.h\"\n\n#include \"tracker/ForwardDeclarations.h\"\n#include \"tracker/Sensor/Sensor.h\"\n#include \"tracker/Tracker.h\"\n#include \"tracker/Worker.h\"\n#include \"tracker/Data/DataStream.h\"\n#include \"tracker/Data/SolutionStream.h\"\n#include \"tracker/DataStructure/SkeletonSerializer.h\"\n#include \"tracker/Calibration/Calibration.h\"\n\nint main(int argc, char* argv[]) {\n\tQ_INIT_RESOURCE(shaders); ///< http://qt-project.org/wiki/QtResources\n\n LOG(INFO) << \"htrack starting\";\n LOG(INFO) << \"--Execution path: \" << QDir::currentPath();\n QString filename_data = (argc >= 2) ? argv[1] : \"\";\n QString filename_soln = (argc >= 3) ? argv[2] : \"\";\n\n ///--- Setup application\n QApplication app(argc, argv);\n QThread::currentThread()->setObjectName(\"Main thread\");\n QThread::currentThread()->setPriority(QThread::HighestPriority);\n\n#if defined(SOFTKIN) && !defined(__APPLE__)\n Camera camera(Intel, 60 /*FPS*/);\n SensorSoftKin sensor(&camera);\n#endif\n\n#if defined(DEPTHSENSEGRABBER) && !defined(__APPLE__)\n Camera camera(Intel, 60 /*FPS*/);\n SensorDepthSenseGrabber sensor(&camera);\n#endif\n\n#if defined(OPENNI)\n Camera camera(QVGA, 60 /*FPS*/);\n // Camera camera(QVGA, 30 /*FPS*/);\n SensorOpenNI sensor(&camera);\n#endif\n\n#if defined(REALSENSE)\n Camera camera(QVGA, 60 /*FPS*/);\n SensorRealSense sensor(&camera);\n#endif\n\n#if defined(LIBREALSENSE)\n Camera camera(Intel, 60 /*FPS*/);\n SensorLibRealSense sensor(&camera);\n#endif\n\n DataStream datastream(&camera);\n datastream.load(filename_data);\n\n SolutionStream* solutions = new SolutionStream();\n Worker worker(&camera);\n OpenGL_viewer* glarea = new OpenGL_viewer(&worker);\n worker.bind_glarea(glarea);\n\n Main_window* window = new Main_window(&worker, &datastream, solutions, glarea);\n window->raise();\n window->show();\n\n Tracker tracker(&worker, camera.FPS());\n tracker.sensor = &sensor;\n tracker.datastream = &datastream;\n tracker.solutions = solutions;\n\n ///--- UI connections\n QObject::connect(window->toggle_record_, &QPushButton::toggled, &tracker, &Tracker::toggle_recording);\n QObject::connect(window->toggle_live_, &QPushButton::toggled, &tracker, &Tracker::toggle_tracking);\n\n ///--- Attempt to load data\n solutions->resize(datastream.size());\n\n int debug_init_with_frame = 0; ///< decide where to start\n if (!filename_soln.isEmpty())\n solutions->load(filename_soln);\n if (datastream.size() > 0) {\n window->display_frame(debug_init_with_frame);\n }\n\n ///--- Load calibration\n Calibration(&worker).autoload();\n glarea->reload_model();\n\n ///--- Flip the hand model if desired\n//#define RIGHT_HAND\n#ifdef RIGHT_HAND\n /// special case for left-handed calibration...\n if (!datastream.get_prefix().startsWith(\"maschroemelax\")) {\n // flip mapping and model\n worker.skeleton->toRightHand2();\n }\n else {\n // flip mapping only and update\n worker.skeleton->setMapping(Mapping::rightArm2());\n if (datastream.size() > 0) {\n window->display_frame(debug_init_with_frame);\n }\n }\n#endif\n\n ///--- Start event loop\n return app.exec();\n}\n"
},
{
"path": "apps/synthgen/synthgen.cpp",
"content": "#if __unix__\n#define GL_GLEXT_PROTOTYPES 1\n#include \n#include \n#endif\n\n#include \n#include \n\n#include \"DataStream.h\"\n#include \"Sensor.h\"\n#include \"Skeleton.h\"\n#include \"Cylinders.h\"\n#include \"Cylinders_renderer.h\"\n#include \"PostureFile.h\"\n#include \"CustomFrameBuffer.h\"\n#include \"OpenGL32Format.h\"\n#include \"mylogger.h\"\n#include \"Types.h\"\n\n#include \n#include \n#include \n#include \n#include \n\n_INITIALIZE_EASYLOGGINGPP\n\nSettings* settings = NULL;\nOpenGL_viewer* glarea = NULL;\n\n\n\nint record_sequence(int argc, char* argv[]){\n setup_logger();\n QApplication app(argc, argv);\n\n string input = \"/Users/anastasia/Desktop/Data/Tompson/cpp_new/\";\n QString output = \"/Users/anastasia/Developer/htrack-data/recs/tompson_seq_2.dat\";\n\n Settings _settings(QDir::currentPath()+\"/settings.ini\");\n settings = &_settings;\n\n DataStream stream(Tompson);\n\n int num_frames = 2440;\n\n for (int i = 0; i < num_frames; ++i) {\n\n char filename_suffix_char_array[9]; sprintf(filename_suffix_char_array, \"1_%07d\", i + 1);\n string filename_suffix(filename_suffix_char_array);\n\n string depth_image_name = input + \"depth_\" + filename_suffix + \".png\";\n cv::Mat depth = cv::imread(depth_image_name, CV_LOAD_IMAGE_UNCHANGED);\n \n cout << i << endl;\n\n\n\n string color_image_name = input + \"rgb_\" + filename_suffix + \".png\";\n cv::Mat color = cv::imread(color_image_name, CV_LOAD_IMAGE_UNCHANGED);\n\n /*cv::namedWindow( \"Display window\", cv::WINDOW_AUTOSIZE );\n cv::imshow( \"Display window\", color );\n cv::waitKey(0);*/\n\n /*for(int row = 194; row < 200; row++){\n for(int col = 194; col < 200; col++){\n cout << depth.at(row, col) << \" \";\n }\n cout << \"; \" << endl;\n }\n cout << endl;*/\n\n if(!depth.data || !color.data ) {\n cout << \"Could not open or find the images\" << std::endl;\n return -1;\n }\n stream.add_frame(color.data, depth.data);\n }\n\n QFile::remove(output);\n stream.save(output);\n printf(\"%s finished!\\n\",argv[0]);\n fflush(stdout);\n return EXIT_SUCCESS;\n}\n\n\n/// @example this is generated programmatically\n/// synthgen SIMPLE_WAVE ../htrack-data/recs/synthwave.dat\n/// synthgen SIMPLE_MOVE_X ../htrack-data/recs/synthmovex.dat\n/// synthgen SIMPLE_MOVE_Y ../htrack-data/recs/synthmovey.dat\n/// synthgen SIMPLE_MOVE_Z ../htrack-data/recs/synthmovez_sphere.dat\n/// synthgen SIMPLE_INDEX_SWING ../htrack-data/recs/synthmovez_sphere.dat\n///\n/// @example this reads postures from file and generate a stream\n/// synthgen ./synthwave.mat ../htrack-data/recs/synthwave.dat\n/// @example this reads every 100th posture from file and generates a stream\n/// synthgen ./synthwave.mat ../htrack-data/recs/synthwave.dat 100\nint main(int argc, char* argv[]){\n \n return record_sequence(argc, argv);\n \n setup_logger();\n if(argc==1){\n LOG(INFO) << \"examples\";\n LOG(INFO) << \"./synthgen SIMPLE_INDEX_SWING ../htrack-data/recs/synth_index_swing.dat\";\n LOG(INFO) << \"./synthgen SIMPLE_MOVE_Z ../htrack-data/recs/synthmovez.dat\";\n LOG(INFO) << \"./synthgen SIMPLE_COLLISION ../htrack-data/recs/synth_collision.dat\";\n LOG(INFO) << \"./synthgen ../htrack-data/jangles/genMovements/20101220_152738_Trial02.mat ./recs/synth_genmov02.dat 10\";\n exit(0);\n }\n\n printf(\"%s starting...\\n\\n\", argv[0]);\n QApplication app(argc, argv);\n\n ///--- parse input\n CHECK(argc >= 3) << \"wrong number of arguments\";\n QString input = argv[1];\n QString output = argv[2];\n LOG(INFO) << \"input: \" << argv[1];\n\n /// Settings\n Settings _settings(QDir::currentPath()+\"/settings.ini\");\n settings = &_settings;\n\n ///--- Read from \"input\" or generate programmatically\n std::vector< vector > thetas;\n bool readFromFile = false;\n {\n\n if(!input.compare(\"THUMB_INDEX_COLLISION\"))\n {\n const int num = 3;\n VectorN m_theta = VectorN::LinSpaced(num, -49, -50);\n float initial[20] = {0.192209, -0.550227, -0.277241, -0.611161, 0.2734, -0.868817, -1.55841, -0.749486, 0.1484,\n -0.71486, -1.50187, -0.93126, -0.0890169, -0.887832, -1.659, -1.00195, -0.230305, -1.12951,\n -0.577767, -1.82401};\n\n for (int i = 0; i < num; ++i) {\n vector t(26, 0.0f);\n for (int j = 0; j < 20; ++j) {\n t[j + 6] = initial[j];\n }\n // global translation\n t[0] = 0.0f;\n t[1] = -70.0f;\n t[2] = 400.0f;\n\n // collision route\n t[11] = m_theta[i] * M_PI / 180.0;\n thetas.push_back(t);\n }\n }\n\n else if(!input.compare(\"IMPROBABLE_POSE\"))\n {\n const int num = 5;\n float initial[20] = {0.2245, 0.6083, -0.1260, -1.0965, -0.1580, -1.0081, -0.6572, -1.0159, -0.2056, 0.0670, -1.1924,\n -0.9529, -0.2882, -1.2361, -0.5992, -0.1336, 0.0659, -0.8790, -1.6130, -1.9549};\n\n for (int i = 0; i < num; ++i) {\n vector t(num_thetas, 0.0f);\n for (int j = 0; j < 20; ++j) {\n t[j + 6] = initial[j];\n }\n // global translation\n t[0] = 0.0f;\n t[1] = -70.0f;\n t[2] = 400.0f;\n\n thetas.push_back(t);\n }\n }\n\n\n else if(!input.compare(\"SIMPLE_COLLISION\"))\n {\n const int num = 30;\n VectorN m_theta = VectorN::LinSpaced(num,0,-15);\n VectorN a_theta = VectorN::LinSpaced(num,0,+10);\n\n for (int i = 0; i < num; ++i) {\n vector t(num_thetas, 0.0f);\n\n // global translation\n t[0] = 0.0f;\n t[1] = -10.0f;\n t[2] = 400.0f;\n\n // collision route\n t[18] = m_theta[i] * M_PI / 180.0;\n t[14] = a_theta[i] * M_PI / 180.0;\n thetas.push_back(t);\n }\n }\n\n else if(!input.compare(\"COLLISION_PROBLEM\"))\n {\n const int num = 5;\n VectorN theta_10 = VectorN::LinSpaced(num,8,15);\n VectorN theta_11 = VectorN::LinSpaced(num,5,10);\n VectorN theta_14 = VectorN::LinSpaced(num,-8,-15);\n VectorN theta_15 = VectorN::LinSpaced(num,-5,-10);\n\n for (int i = 0; i < num; ++i) {\n vector t(num_thetas, 0.0f);\n\n // global translation\n t[0] = 0.0f;\n t[1] = -10.0f;\n t[2] = 400.0f;\n\n // collision route\n t[10] = theta_10[i] * M_PI / 180.0;\n t[11] = theta_11[i] * M_PI / 180.0;\n t[14] = theta_14[i] * M_PI / 180.0;\n t[15] = theta_15[i] * M_PI / 180.0;\n thetas.push_back(t);\n }\n }\n\n else if(!input.compare(\"SIMPLE_WAVE\"))\n {\n for(float a = 0; a < 45.0f; a += 0.5f)\n {\n vector t(num_thetas, 0.0f);\n\n // global translation\n t[0] = 0.0f;\n t[1] = -10.0f;\n t[2] = 400.0f;\n\n // global rotation\n t[3] = 0.0f;\n t[4] = 0.0f;\n t[5] = a * M_PI / 180.0f;\n\n thetas.push_back(t);\n }\n }\n\n else if(!input.compare(\"SIMPLE_MOVE_Y\"))\n {\n LOG(INFO) << \"SIMPLE_MOVE_Y\";\n for(float a = 0.0; a < 100.0f; a += 2.0f)\n {\n vector t(num_thetas, 0.0f);\n\n // global translation\n t[0] = 0;\n t[1] = a;\n t[2] = 400.0f;\n\n thetas.push_back(t);\n }\n }\n\n else if(!input.compare(\"SIMPLE_MOVE_X\"))\n {\n Vector3 t0 = settings->vector3(\"skeleton/translation\");\n\n for(float a = 0.0; a < 100.0f; a += 2.0f)\n {\n vector t(num_thetas, 0.0f);\n\n // global translation\n t[0] = a+t0[0];\n t[1] = t0[1];\n t[2] = t0[2];\n\n thetas.push_back(t);\n }\n }\n\n else if(!input.compare(\"SIMPLE_MOVE_Z\"))\n {\n for(float a = 200.0f; a > -200.0f; a -= 2.0f)\n {\n vector t(num_thetas, 0.0f);\n\n // global translation\n t[0] = 0.0f;\n t[1] = -10.0f;\n t[2] = 400.0f + fabs(a);\n\n thetas.push_back(t);\n }\n }\n\n else if(!input.compare(\"SIMPLE_INDEX_SWING\"))\n {\n for(float a = -10.0f; a < 25.0f; a += 1.0f)\n {\n vector t(num_thetas, 0.0f);\n\n // global translation\n Vector3 t0 = settings->vector3(\"skeleton/translation\");\n t[0] = t0[0];\n t[1] = t0[1];\n t[2] = t0[2];\n\n // swing index left/right\n t[10] = -a * M_PI / 180.0f;\n\n thetas.push_back(t);\n }\n }\n\n else if(!input.compare(\"SIMPLE_MOVE_Z_2\"))\n {\n for(float a = 0.0f; a > -200.0f; a -= 2.0f)\n {\n vector t(num_thetas, 0.0f);\n\n // global translation\n t[0] = 0.0f;\n t[1] = -10.0f;\n t[2] = 400.0f + fabs(a);\n\n thetas.push_back(t);\n }\n }\n\n else if(!input.compare(\"SIMPLE_BEND_INDEX\"))\n {\n for(float a = 0.0f; a < 100.0f; a += 1.0f)\n {\n vector t(num_thetas, 0.0f);\n\n // global translation\n t[0] = 0.0f;\n t[1] = -10.0f;\n t[2] = 400.0f;\n\n // bend index finger\n t[11] = -a * M_PI / 180.0f;\n\n thetas.push_back(t);\n }\n }\n\n else\n {\n readFromFile = true;\n PostureFile p(argv[1]);\n\n if(argc >= 4)\n {\n int skip = atoi(argv[3]);\n\n for(size_t i = 0; i < p.postures.size(); i+=skip)\n {\n vector t = p.postures[i];\n\n // global translation\n Vector3 t0 = settings->vector3(\"skeleton/translation\");\n t[0] = t0[0];\n t[1] = t0[1];\n t[2] = t0[2];\n\n thetas.push_back(t);\n }\n }\n else\n {\n thetas = p.postures;\n }\n }\n LOG(INFO) << \"rendering\" << thetas.size() << \"postures\";\n }\n\n ///--- Where data will be saved\n DataStream stream;\n\n ///--- Initialize offscreen renderering context\n Camera camera(QVGA);\n OpenGL32Format format;\n QGLWidget glarea(format);\n glarea.makeCurrent();\n CustomFrameBuffer fb;\n glViewport(0,0,camera.width(), camera.height());\n glClearColor(1.0,1.0,1.0,1.0);\n glEnable(GL_DEPTH_TEST);\n fb.init(camera.width(), camera.height());\n\n ///--- Initialize renderer\n Skeleton *skeleton = Skeleton::leftHand();\n if(readFromFile){ ///<< ??????????????\n // this just looks better with the svn data\n skeleton->getJoint(\"Hand\")->rotate(Vec3f(0,0,1), -1.57f);\n skeleton->setInitialTransformations();\n }\n Cylinders *cylinders = new Cylinders(skeleton);\n Cylinders_renderer renderer(cylinders);\n renderer.init(Cylinders_renderer::FRAMEBUFFER);\n renderer.set_uniform(\"view_projection\", camera.view_projection_matrix());\n\n ///--- Prinout used matrices\n std::cout << \"Using view_projection: \\n \" << camera.view_projection_matrix() << std::endl;\n\n cv::Mat color;\n cv::Mat xyz;\n for(auto t : thetas){\n skeleton->set(t);\n\n ///--- Render time\n fb.bind();\n glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);\n renderer.render();\n fb.unbind();\n\n // #define JUST_SHOW_BUFFERS\n#ifdef JUST_SHOW_BUFFERS\n fb.display_color_attachment();\n fb.display_extra_attachment();\n cv::waitKey(0);\n break;\n#endif\n\n ///--- Fetch the textures\n fb.fetch_color_attachment(color);\n fb.fetch_extra_attachment(xyz);\n\n ///--- Flip them to match device\n cv::flip(color, color, 0 /*flip rows*/ );\n cv::flip(xyz, xyz, 0 /*flip rows*/ );\n\n ///--- Convert to depth map\n cv::Mat synthdepth = cv::Mat(stream.height(), stream.width(), CV_16UC1, cv::Scalar(1.0));\n for(int row = 0; row < synthdepth.rows; row++)\n for(int col = 0; col < synthdepth.cols; col++){\n cv::Vec4f p = xyz.at(row, col);\n synthdepth.at(row, col) = (ushort) p[2];\n }\n ///--- Convert IDs to an indexed color\n cv::Mat synthcolor = cv::Mat(stream.height(), stream.width(), CV_8UC4, cv::Scalar(255,255,255,255));\n cvtColor(color, synthcolor, CV_GRAY2RGB);\n\n ///--- Add synthetic data to stream\n stream.add_frame(synthcolor.data, synthdepth.data);\n }\n\n QFile::remove(output);\n stream.save(output);\n printf(\"%s finished!\\n\",argv[0]);\n fflush(stdout);\n return EXIT_SUCCESS;\n}\n\n"
},
{
"path": "cmake/CompileSynthgen.cmake",
"content": "set(WITH_SYNTHGEN TRUE)\nLIST(APPEND SRC_OPENGL2 \"opengl/Cylinders_renderer.cpp\" \"opengl/Renderer_interface.cpp\")\nadd_executable(synthgen apps/synthgen.cpp ${SRC_MATH} ${SRC_UTIL} ${SRC_GEOMETRY} ${SRC_OPENGL2} ${MATH} ${UTIL} ${GEOMETRY} ${QT_RESOURCES})\ntarget_link_libraries(synthgen ${LIBRARIES})\nqt5_use_modules(synthgen OpenGL Xml)\n"
},
{
"path": "cmake/ConfigureAntTweakBar.cmake",
"content": "#--- AntTweakBar\nfind_package(AntTweakBar)\nif(ANTTWEAKBAR_FOUND)\n include_directories(${ANTTWEAKBAR_INCLUDE_DIR})\n list(APPEND LIBRARIES ${ANTTWEAKBAR_LIBRARY})\n add_definitions(-DWITH_ANTTWEAKBAR)\n\n message(STATUS \"AntTweakBar: ${ANTTWEAKBAR_LIBRARY}\")\n\n #--- X11 (required by AntTweakBar)\n if(UNIX AND NOT APPLE)\n find_package(X11)\n if(NOT X11_FOUND)\n message(FATAL_ERROR \"Cannot found X11 on Linux. Necessary\")\n endif()\n list(APPEND LIBRARIES ${X11_LIBRARIES})\n endif()\nelse()\n # message(STATUS ANTTWEAKBAR_INCLUDE_DIR: ${ANTTWEAKBAR_INCLUDE_DIR})\n # message(STATUS ANTTWEAKBAR_LIBRARY: ${ANTTWEAKBAR_LIBRARY})\n message(STATUS \"WARNING: AntTweakbar not found\")\nendif()\n"
},
{
"path": "cmake/ConfigureCUDA.cmake",
"content": "set(WITH_CUDA TRUE)\nadd_definitions(-DWITH_CUDA)\n\n# Anastasia: what is this for?\nif(WIN32)\n # set(CUDA_TOOLKIT_ROOT_DIR \"C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v6.5\")\n set(CUDA_TOOLKIT_ROOT_DIR \"C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v7.0\")\nendif()\n\n#--- Import CUDA/CUBLAS\nfind_package(CUDA REQUIRED)\ninclude_directories(${CUDA_INCLUDE_DIRS})\nlist(APPEND LIBRARIES ${CUDA_LIBRARIES})\nlist(APPEND LIBRARIES ${CUDA_CUBLAS_LIBRARIES})\n\n#--- For matrix operations within Kernels (Eigen not supported)\nfind_package(GLM REQUIRED)\ninclude_directories(${GLM_INCLUDE_DIRS})\nadd_definitions(-DGLM_FORCE_CUDA) #< as mentioned in docs\n\n#--- Card needs appropriate version\nsite_name(HOSTNAME)\nmessage(STATUS \"HOSTNAME ${HOSTNAME}\")\n\nif(HOSTNAME STREQUAL \"lagrange\") #--- Andrea/Linux\n set(CUDA_NVCC_FLAGS \"-gencode arch=compute_50,code=sm_50\")# GTX980\n set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -w -Xcompiler -fPIC\" )\nelseif(HOSTNAME STREQUAL \"IC-LGG-DPC-06\") #--- Andrea,Fridge,Windows\n set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -gencode arch=compute_50,code=sm_50\") # GTX980\nelseif(HOSTNAME STREQUAL \"tsf-460-wpa-4-107.epfl.ch\") # Euler MAC-PRO Retina\n set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -gencode arch=compute_30,code=sm_30\") # Geforce 650m\nelseif(HOSTNAME STREQUAL \"waluigi\") #--- Matthias/Linux\n set(CUDA_NVCC_FLAGS \"-gencode arch=compute_30,code=sm_30\")# GTX660 Ti\n set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -w -Xcompiler -fPIC\" )\nelseif(HOSTNAME STREQUAL \"nastylinux\") #--- Anastasia\n set(CUDA_NVCC_FLAGS \"-gencode arch=compute_30,code=sm_30\")# GTX660 Ti\n set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -w -Xcompiler -fPIC -D__CUDACC__\" )\nelseif(HOSTNAME STREQUAL \"thp\") #--- THP/Alienware\n set(CUDA_NVCC_FLAGS \"-gencode arch=compute_30,code=sm_30\")# GTX780M\nelseif(HOSTNAME STREQUAL \"teakwood\") #--- THP/Alienware\n set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -gencode arch=compute_50,code=sm_50\") # GTX980 (Win/Linux Machine)\n\n#--- Generic\nelse()\n #set(CUDA_NVCC_FLAGS \"-gencode arch=compute_32,code=sm_32\") # invalid device function\n set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -gencode arch=compute_30,code=sm_30\") # Geforce 650m (MBPro Retina)\n set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -gencode arch=compute_32,code=sm_32\") # ?\n set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -gencode arch=compute_35,code=sm_35\") # ?\n set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -gencode arch=compute_50,code=sm_50\") # GTX980 (Win/Linux Machine)\nendif()\n\n#--- Enable debugging flags\n#set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -g\") # HOST debug mode\n#set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -G\") # DEV debug mode\n#set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -lineinfo\")\nset(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -DNDEBUG\") #< disable asserts\n\nif(WIN32)\n set(CUDA_PROPAGATE_HOST_FLAGS True)\n if (CMAKE_BUILD_TYPE STREQUAL \"Release\")\n set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -O3\")\n set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -use_fast_math\")\n endif()\nelse()\n #--- CUDA doesn't like \"--compiler-options -std=c++11\"\n set(CUDA_PROPAGATE_HOST_FLAGS False)\n set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -std c++11\")\n set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -O3\")\n set(CUDA_NVCC_FLAGS \"${CUDA_NVCC_FLAGS} -use_fast_math\")\nendif()\n\nmessage(STATUS \"CUDA_PROPAGATE_HOST_FLAGS: ${CUDA_PROPAGATE_HOST_FLAGS}\")\nmessage(STATUS \"CUDA_HOST_COMPILER: ${CUDA_HOST_COMPILER}\")\nmessage(STATUS \"CUDA_NVCC_FLAGS: ${CUDA_NVCC_FLAGS}\")\n"
},
{
"path": "cmake/ConfigureCompiler.cmake",
"content": "#--- Build type\n# set(CMAKE_BUILD_TYPE \"Release\") #<<< FORCE SET\nif(NOT CMAKE_BUILD_TYPE)\n set(CMAKE_BUILD_TYPE \"Release\")\nendif()\nmessage(STATUS \"CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE}\")\n\nif(APPLE)\n message(STATUS \"Compiler(Apple): clang\")\n set(CMAKE_CXX_COMPILER \"/usr/bin/clang++\")\n set(CMAKE_CC_COMPILER \"/usr/bin/clang\")\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations\")\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -std=c++11\")\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -O3\")\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -ferror-limit=1\") # max number of compiler errors \n# set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -Wall\") # enable warnings\n# set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -fopenmp\") # only for clangomp\n# set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -Ofast -march=native -mtune=native -mno-avx -DNDEBUG\")\nelseif(UNIX)\n message(STATUS \"Compiler(Linux): g++-4.8\")\n set(CMAKE_CXX_COMPILER \"/usr/bin/g++-4.8\")\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -Wno-deprecated-declarations\")\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -std=c++11\")\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -fopenmp\")\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -O3\")\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -march=native\")\n #set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -Wall\")\n #set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -Ofast -march=native -DNDEBUG\")\n #set(CMAKE_EXE_LINKER_FLAGS \"${CMAKE_EXE_LINKER_FLAGS} -flto -fwhole-program\")\n\n #The following are needed if you are using librealsense\n #add_compile_options(-std=c++11 -fPIC -lusb-1.0 -lpthread )\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -fPIC\")\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -lusb-1.0\")\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -lpthread\")\nelseif(WIN32)\n message(STATUS \"Compiler(Windows): Visual Studio 12 2013 Win64\")\n if (CMAKE_BUILD_TYPE STREQUAL \"Release\")\n message(STATUS \"--> NOTE: enabled windows performance flags\")\n add_definitions(-DNDEBUG)\n # set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} /Ox /Ot /fp:fast /GS- /GL\")\n # set(CMAKE_EXE_LINKER_FLAGS \"${CMAKE_EXE_LINKER_FLAGS} /LTCG\")\n endif()\nendif()\n"
},
{
"path": "cmake/ConfigureCudaOctree.cmake",
"content": "#if(FALSE)\n# message(STATUS \"CudaOctree internal build\")\n# include_directories(${CMAKE_SOURCE_DIR}/cuda_octree)\n# file(GLOB_RECURSE CPP_SOURCES \"${CMAKE_SOURCE_DIR}/cuda_octree/*.cpp\")\n# file(GLOB_RECURSE HPP_SOURCES \"${CMAKE_SOURCE_DIR}/cuda_octree/*.hpp\")\n# file(GLOB_RECURSE CUDA_SOURCES \"${CMAKE_SOURCE_DIR}/cuda_octree/*.cu\")\n# file(GLOB_RECURSE CPP_HEADERS \"${CMAKE_SOURCE_DIR}/cuda_octree/*.h\")\n# cuda_add_library(CudaOctree STATIC ${CUDA_SOURCES} ${CPP_SOURCES} ${HPP_SOURCES} ${CPP_HEADERS})\n# list(APPEND LIBRARIES CudaOctree)\n#else()\n# list(APPEND LIBRARIES /usr/local/lib/libCudaOctree.a)\n#endif()"
},
{
"path": "cmake/ConfigureEigen.cmake",
"content": "find_package(Eigen3 REQUIRED)\ninclude_directories(${EIGEN3_INCLUDE_DIRS})\nadd_definitions(-DWITH_EIGEN)\n"
},
{
"path": "cmake/ConfigureGLEW.cmake",
"content": "#--- STATICALLY LINKED!!!\nfind_package(GLEW REQUIRED)\ninclude_directories(${GLEW_INCLUDE_DIRS})\nlink_directories(${GLEW_LIBRARY_DIRS})\nadd_definitions(-DGLEW_STATIC)\nadd_definitions(-DWITH_GLEW)\nLIST(APPEND LIBRARIES ${GLEW_LIBRARIES})\nmessage(STATUS \"GLEW_LIBRARIES: ${GLEW_LIBRARIES}\")\n"
},
{
"path": "cmake/ConfigureGLFW.cmake",
"content": "#--- CMake extension to load GLFW\nfind_package(GLFW REQUIRED)\ninclude_directories(${GLFW_INCLUDE_DIRS})\nadd_definitions(${GLFW_DEFINITIONS})\nif(NOT GLFW_FOUND)\n message(ERROR \" GLFW not found!\")\nendif()\nLIST(APPEND LIBRARIES ${GLFW_LIBRARIES})\n"
},
{
"path": "cmake/ConfigureLibRealSense.cmake",
"content": "add_compile_options(-std=c++11 -fPIC -lusb-1.0 -lpthread )\n\n# libusb-1.0\nfind_package(Threads REQUIRED)\nfind_package(PkgConfig)\npkg_check_modules(PC_LIBUSB REQUIRED libusb-1.0)\ninclude_directories( ${LIBUSB_1_INCLUDE_DIRS})\n\n## GLFW\n#find_package(PkgConfig REQUIRED)\n#pkg_search_module(GLFW REQUIRED glfw3)\n#include_directories(${GLFW_INCLUDE_DIRS})\n#LIST(APPEND LIBRARIES ${GLFW_LIBRARIES})\n\n\n# librealsense\nset(LIBREALSENSE_INCLUDE_DIR \"/home/raghu/Desktop/librealsense/include\")\nset(LIBREALSENSE_LIBRARY \"/usr/local/lib/librealsense.so\")\ninclude_directories(${LIBREALSENSE_INCLUDE_DIR})\nlist(APPEND LIBRARIES ${LIBREALSENSE_LIBRARY})\n\n\n#--- Mark as available\nadd_definitions(-DHAS_LIBREALSENSE)\n"
},
{
"path": "cmake/ConfigureOpenCV.cmake",
"content": "find_package(OpenCV2 REQUIRED)\n\nif(OpenCV2_FOUND)\n include_directories(${OpenCV2_INCLUDE_DIRS})\n LIST(APPEND LIBRARIES ${OpenCV2_LIBRARIES})\n add_definitions(-DWITH_OPENCV)\nelse()\n message(FATAL_ERROR \"OpenCV required\")\nendif()\n\n#message(STATUS \"OpenCV2_LIBRARIES: ${OpenCV2_LIBRARIES}\")\n#message(STATUS \"OpenCV2_INCLUDE_DIRS: ${OpenCV2_INCLUDE_DIRS}\")\n\n#--- (OBSOLETE) find it with PkgConfig\n#find_package(PkgConfig REQUIRED)\n#pkg_check_modules(OPENCV REQUIRED opencv)\n#list(APPEND LIBRARIES ${OPENCV_LDFLAGS})\n#include_directories(${OPENCV_INCLUDE_DIRS})\n\n"
},
{
"path": "cmake/ConfigureOpenGL.cmake",
"content": "#--- OpenGL\nfind_package(OpenGL REQUIRED)\nif(NOT OPENGL_FOUND)\n message(ERROR \" OPENGL not found!\")\nendif(NOT OPENGL_FOUND)\n\ninclude_directories(${OpenGL_INCLUDE_DIRS})\nlink_directories(${OpenGL_LIBRARY_DIRS})\nadd_definitions(${OpenGL_DEFINITIONS})\nLIST(APPEND LIBRARIES ${OPENGL_LIBRARIES})\n\nif(UNIX)\n LIST(APPEND LIBRARIES ${OPENGL_glu_LIBRARY})\nendif()\n"
},
{
"path": "cmake/ConfigureOpenGP.cmake",
"content": "#--- OPENGP\nfind_package(OpenGP REQUIRED)\ninclude_directories(${OpenGP_INCLUDE_DIRS})\nadd_definitions(-DHEADERONLY)\nadd_definitions(-DUSE_EIGEN)\nif(NOT OPENGP_FOUND)\n message(ERROR \" OPENGP not found!\")\nendif()"
},
{
"path": "cmake/ConfigureOpenMP.cmake",
"content": "if(UNIX)\n # only for g++ or for the Clang+OpenMP compiler\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -fopenmp\")\nelseif(WIN32)\n message(STATUS \"OpenMP not tested on windows!\")\nendif()\n\nadd_definitions(-DWITH_OPENMP)\n"
},
{
"path": "cmake/ConfigureOpenNI.cmake",
"content": "#--- OpenNI2\nfind_package(OpenNI2)\nif(OPENNI2_FOUND)\n include_directories(${OPENNI2_INCLUDE_DIR})\n list(APPEND LIBRARIES ${OPENNI2_LIBRARY})\n add_definitions(-DWITH_OPENNI)\nelse()\n message(STATUS \"WARNING: OpenNI2 not found!\")\nendif()\n\n#message(STATUS \"OpenNI2: ${OPENNI2_LIBRARY}\")\n#message(STATUS \"OpenNI2: ${OPENNI2_INCLUDE_DIR}\")\n"
},
{
"path": "cmake/ConfigureQGLViewer.cmake",
"content": "find_package(QGLViewer) #<<< Optional\nif(QGLVIEWER_FOUND)\n include_directories(${QGLVIEWER_INCLUDE_DIR})\n add_definitions(-DQGLVIEWER)\n LIST(APPEND LIBRARIES ${QGLVIEWER_LIBRARIES})\n add_definitions(-DWITH_QGLVIEWER)\n #message(STATUS \"INCLUDE DIR\" ${QGLVIEWER_INCLUDE_DIR})\nendif()\n"
},
{
"path": "cmake/ConfigureQt.cmake",
"content": "# @see http://doc.qt.io/qt-5/cmake-manual.html\n#--- Tell cmake where to find Qt5. (Unfortunately cmake3 does not support Qt5 yet)\n\n#--- Debug\n#message(STATUS QT5_CMAKE_DIR $ENV{QT5_CMAKE_DIR})\n#message(STATUS CMAKE_PREFIX_PATH $ENV{CMAKE_PREFIX_PATH})\n\nif(DEFINED ENV{CMAKE_PREFIX_PATH})\n # If user has specified it, just use it...\n set(CMAKE_PREFIX_PATH $ENV{CMAKE_PREFIX_PATH})\n message(STATUS \"Qt5: Using environment CMAKE_PREFIX_PATH: ${CMAKE_PREFIX_PATH}\")\n\nelseif(DEFINED ENV{QT5_CMAKE_DIR})\n # User could have also specified QT5_CMAKE_DIR\n set(CMAKE_PREFIX_PATH $ENV{QT5_CMAKE_DIR})\n message(STATUS \"Qt5: Using environment variable QT5_CMAKE_DIR: ${CMAKE_PREFIX_PATH}\")\n\nelse()\n # Otherwise just resort to some built-in stuff\n if(WIN32)\n set(CMAKE_PREFIX_PATH \"C:/Developer/Qt/5.4/msvc2013_64_opengl/lib/cmake\")\n elseif(APPLE)\n set(CMAKE_PREFIX_PATH \"/usr/local/Cellar/qt5/5.4.1/lib/cmake\")\n elseif(UNIX)\n set(CMAKE_PREFIX_PATH \"/usr/local/qt/5.3/gcc_64/lib/cmake\")\n endif()\n message(STATUS \"!!!WARNING Qt5: resorting to default Qt5 paths (might fail): ${CMAKE_PREFIX_PATH}\")\nendif()\n\n#--- Needed for GUI\nfind_package(Qt5Widgets REQUIRED)\ninclude_directories(${Qt5Widgets_INCLUDE_DIRS})\nlist(APPEND LIBRARIES Qt5::Widgets)\n\n#--- Needed for OpenGL\nfind_package(Qt5OpenGL REQUIRED)\ninclude_directories(${Qt5OpenGL_INCLUDE_DIRS})\nlist(APPEND LIBRARIES Qt5::OpenGL)\n\n#--- Needed for the QGLViewer library\nfind_package(Qt5Xml REQUIRED)\ninclude_directories(${Qt5Xml_INCLUDE_DIRS})\nlist(APPEND LIBRARIES Qt5::Xml)\n\n"
},
{
"path": "cmake/ConfigureRealSense.cmake",
"content": "# TODO: use the find_file macro\n\nif(WIN32)\n set(REALSENSE_INCLUDE_DIR \"C:/Developer/RealSense/RSSDK/include\")\n set(REALSENSE_UTILITY_DIR \"C:/Developer/RealSense/RSSDK/sample/common/include\")\n\n if(${CMAKE_BUILD_TYPE} STREQUAL \"Debug\")\n set(REALSENSE_LIBRARY \"C:/Developer/RealSense/RSSDK/lib/x64/libpxcmd_d.lib\")\n set(REALSENSE_UTILITY_LIBRARY \"C:/Developer/RealSense/RSSDK/sample/common/lib/x64/v120/libpxcutilsmd_d.lib\")\n endif()\n\n if(${CMAKE_BUILD_TYPE} STREQUAL \"Release\")\n set(REALSENSE_LIBRARY \"C:/Developer/RealSense/RSSDK/lib/x64/libpxcmd.lib\")\n set(REALSENSE_UTILITY_LIBRARY \"C:/Developer/RealSense/RSSDK/sample/common/lib/x64/v120/libpxcutilsmd.lib\")\n endif()\n\n\n include_directories(${REALSENSE_INCLUDE_DIR} ${REALSENSE_UTILITY_DIR})\n\n list(APPEND LIBRARIES ${REALSENSE_LIBRARY})\n list(APPEND LIBRARIES ${REALSENSE_UTILITY_LIBRARY})\n\n #--- DEBUG\n # message(STATUS \"REALSENSE_LIBRARY ${REALSENSE_LIBRARY}\")\n # message(STATUS \"REALSENSE_UTILITY_LIBRARY ${REALSENSE_UTILITY_LIBRARY}\")\n\n #--- Mark as available\n add_definitions(-DHAS_REALSENSE)\nendif()\n"
},
{
"path": "cmake/ConfigureSensor.cmake",
"content": "#--- Choose a sensor\n\n#SET(SENSOR_DEPTHSENSEGRABBER 0 CACHE BOOL \"Use SoftKinetic with DepthSenseGrabber\")\n#SET(SENSOR_SOFTKIN 0 CACHE BOOL \"Use SoftKinetic with SoftKin\")\n#SET(SENSOR_REALSENSE 0 CACHE BOOL \"Use Intel RealSense\")\n#SET(SENSOR_LIBREALSENSE 0 CACHE BOOL \"Use Intel LibRealSense\")\n#SET(SENSOR_OPENNI 0 CACHE BOOL \"Use PrimeSense Carmine or ASUS Xtion with OpenNI\")\n\nSET(SENSOR \"librealsense\" CACHE STRING \"Define your own sensor while configuring CMAKE\")\nSET(SENSOR_LIST depthsensegrabber librealsense openni realsense softkin)\nSET_PROPERTY(CACHE SENSOR PROPERTY STRINGS ${SENSOR_LIST})\n\nif (\";${SENSOR_LIST};\" MATCHES \";${SENSOR};\")\n message(STATUS \"Sensor is in Sensor List\")\nelse (\";${SENSOR_LIST};\" MATCHES \";${SENSOR};\")\n message(STATUS \"${SENSOR} is not a valid option (${SENSOR_LIST}). Setting the SENSOR value to librealsense\")\n SET(SENSOR librealsense)\nendif (\";${SENSOR_LIST};\" MATCHES \";${SENSOR};\")\nmessage(STATUS \"SENSOR ${SENSOR}\")\n\nSET(SENSOR_COUNT 0)\n\n#macro(SENSOR_RESET SENSOR_1 SENSOR_2)\n# UNSET(SENSOR_DEPTHSENSEGRABBER CACHE)\n# UNSET(SENSOR_SOFTKIN CACHE)\n# UNSET(SENSOR_REALSENSE CACHE)\n# UNSET(SENSOR_LIBREALSENSE CACHE)\n# UNSET(SENSOR_OPENNI CACHE)\n# message(FATAL_ERROR \"Sensor conflict: both ${SENSOR_1} and ${SENSOR_2} are set to enabled. Resetting cache, please run cmake and choose a sensor again.\")\n#endmacro(SENSOR_RESET)\n\nif (SENSOR STREQUAL \"depthsensegrabber\")\n set (SENSOR_TEST DEPTHSENSEGRABBER)\n if (SENSOR_COUNT EQUAL 0)\n set(SENSOR_COUNT 1)\n set(SENSOR_TYPE ${SENSOR_TEST})\n message(STATUS \"Enabling ${SENSOR_TEST}\")\n else (SENSOR_COUNT EQUAL 0)\n SENSOR_RESET(${SENSOR_TYPE} ${SENSOR_TEST})\n endif (SENSOR_COUNT EQUAL 0)\nendif (SENSOR STREQUAL \"depthsensegrabber\")\n\nif (SENSOR STREQUAL \"softkin\")\n set (SENSOR_TEST SOFTKIN)\n if (SENSOR_COUNT EQUAL 0)\n set(SENSOR_COUNT 1)\n set(SENSOR_TYPE ${SENSOR_TEST})\n message(STATUS \"Enabling ${SENSOR_TEST}\")\n else (SENSOR_COUNT EQUAL 0)\n SENSOR_RESET(${SENSOR_TYPE} ${SENSOR_TEST})\n endif (SENSOR_COUNT EQUAL 0)\nendif (SENSOR STREQUAL \"softkin\")\n\nif (SENSOR STREQUAL \"realsense\")\n set (SENSOR_TEST REALSENSE)\n if (SENSOR_COUNT EQUAL 0)\n set(SENSOR_COUNT 1)\n set(SENSOR_TYPE ${SENSOR_TEST})\n message(STATUS \"Enabling ${SENSOR_TEST}\")\n else (SENSOR_COUNT EQUAL 0)\n SENSOR_RESET(${SENSOR_TYPE} ${SENSOR_TEST})\n endif (SENSOR_COUNT EQUAL 0)\nendif (SENSOR STREQUAL \"realsense\")\n\nif (SENSOR STREQUAL \"librealsense\")\n set (SENSOR_TEST LIBREALSENSE)\n if (SENSOR_COUNT EQUAL 0)\n set(SENSOR_COUNT 1)\n set(SENSOR_TYPE ${SENSOR_TEST})\n message(STATUS \"Enabling ${SENSOR_TEST}\")\n else (SENSOR_COUNT EQUAL 0)\n SENSOR_RESET(${SENSOR_TYPE} ${SENSOR_TEST})\n endif (SENSOR_COUNT EQUAL 0)\nendif (SENSOR STREQUAL \"librealsense\")\n\nif (SENSOR STREQUAL \"openni\")\n set (SENSOR_TEST OPENNI)\n if (SENSOR_COUNT EQUAL 0)\n set(SENSOR_COUNT 1)\n set(SENSOR_TYPE ${SENSOR_TEST})\n message(STATUS \"Enabling ${SENSOR_TEST}\")\n else (SENSOR_COUNT EQUAL 0)\n SENSOR_RESET(${SENSOR_TYPE} ${SENSOR_TEST})\n endif (SENSOR_COUNT EQUAL 0)\nendif (SENSOR STREQUAL \"openni\")\n\nif (NOT SENSOR_COUNT)\n message(FATAL_ERROR \"Please choose a sensor, example: cmake -DSENSOR=librealsense (valid options: ${SENSOR_LIST}), or use cmake-gui. realsense works on Windows with RealSense SDK while librealsense works on Linux with librealsense SDK\")\nendif (NOT SENSOR_COUNT)\n\nset(DEFINITION_SENSOR \"-D${SENSOR_TYPE}\")\n"
},
{
"path": "cmake/ConfigureSoftKinetic.cmake",
"content": "#--- OpenNI2\nfind_package(SoftKinetic) #NOT REQUIRED (mac doesn't have it)\nif(SOFTKINETIC_FOUND)\n include_directories(${SOFTKINETIC_INCLUDE_DIR})\n list(APPEND LIBRARIES ${SOFTKINETIC_LIBRARIES})\n add_definitions(-DHAS_SOFTKINETIC)\nendif()\n"
},
{
"path": "cmake/FindAntTweakBar.cmake",
"content": "#\n# Try to find AntTweakBar library and include path.\n# Once done this will define\n#\n# ANTTWEAKBAR_FOUND\n# ANTTWEAKBAR_INCLUDE_DIR\n# ANTTWEAKBAR_LIBRARY\n#\n\nFIND_PATH(ANTTWEAKBAR_INCLUDE_DIR AntTweakBar.h PATHS\n $ENV{ANTTWEAKBAR_ROOT}/include\n #--- External folder\n ${CMAKE_CURRENT_LIST_DIR}/../external/AntTweakBar/include/\n #--- Windows\n C:/Developer/include/AntTweakBar\n #--- Mac\n /usr/local/include\n /usr/X11/include\n /usr/include\n NO_DEFAULT_PATH\n DOC \"The directory where AntTweakBar.h resides\")\n\nif(WIN32)\n set(BITS \"64\")\nendif()\n\nFIND_LIBRARY( ANTTWEAKBAR_LIBRARY AntTweakBar${BITS} PATHS\n $ENV{ANTTWEAKBAR_ROOT}/lib\n #--- Windows\n C:/Developer/lib\n #---\n /usr/local/lib\n /usr/local\n /usr/X11\n /usr\n PATH_SUFFIXES a lib64 lib dylib NO_DEFAULT_PATH\n DOC \"The AntTweakBar library\")\n\nif(ANTTWEAKBAR_INCLUDE_DIR AND ANTTWEAKBAR_LIBRARY)\n message(STATUS \"Found ANTTWEAKBAR: ${ANTTWEAKBAR_LIBRARY}\")\n set(ANTTWEAKBAR_FOUND TRUE)\nendif()\n\n#--- DEBUG\n#message(STATUS \"ANTTWEAKBAR_INCLUDE_DIR: ${ANTTWEAKBAR_INCLUDE_DIR}\")\n#message(STATUS \"ANTTWEAKBAR_LIBRARY: ${ANTTWEAKBAR_LIBRARY}\")\n"
},
{
"path": "cmake/FindEigen3.cmake",
"content": "if(WIN32)\nset(EIGEN3_INCLUDE_DIRS \"C:/Developer/include\")\nelse()\nFIND_PATH( EIGEN3_INCLUDE_DIRS Eigen/Geometry\n $ENV{EIGEN3DIR}/include\n /usr/local/include/eigen3\n /usr/local/include\n /usr/local/X11R6/include\n /usr/X11R6/include\n /usr/X11/include\n /usr/include/X11\n /usr/include/eigen3/\n /usr/include\n /opt/X11/include\n /opt/include \n ${CMAKE_SOURCE_DIR}/external/eigen/include)\nendif()\n\nSET(EIGEN3_FOUND \"NO\")\nIF(EIGEN3_INCLUDE_DIRS)\n SET(EIGEN3_FOUND \"YES\")\nENDIF()\n"
},
{
"path": "cmake/FindGLEW.cmake",
"content": "FIND_PATH( GLEW_INCLUDE_DIRS GL/glew.h\n $ENV{GLEWDIR}/include\n /usr/local/include\n /usr/local/X11R6/include\n /usr/X11R6/include\n /usr/X11/include\n /usr/include/X11\n /usr/include\n /opt/X11/include\n /opt/include \n # FOR WINDOWS\n C:/Developer/include\n ${CMAKE_SOURCE_DIR}/external/glew/include)\n\nif(WIN32)\n SET(GLEWLIBNAME glew32s) # static\n# SET(GLEWLIBNAME glew32) # dyn\nelse()\n # IMPORTANT: uppercase otherwise problem on linux\n SET(GLEWLIBNAME GLEW)\nendif() \n\nFIND_LIBRARY( GLEW_LIBRARIES NAMES ${GLEWLIBNAME} PATHS\n $ENV{GLEWDIR}/lib\n /usr/local/lib\n /usr/local/X11R6/lib\n /usr/X11R6/lib\n /usr/X11/lib\n /usr/lib/X11\n /usr/lib\n /opt/X11/lib\n /opt/lib\n # FOR UBUNTU 12.04 LTS\n /usr/lib/x86_64-linux-gnu \n # FOR WINDOWS \n C:/Developer/lib\n ${CMAKE_SOURCE_DIR}/external/glew/lib)\n\n\nSET(GLEW_FOUND \"NO\")\nIF(GLEW_LIBRARIES AND GLEW_INCLUDE_DIRS)\n SET(GLEW_FOUND \"YES\")\nENDIF()\n\n#message(STATUS \"GLEW_LIBRARIES: ${GLEW_LIBRARIES}\")\n#message(STATUS \"GLEW_INCLUDE_DIRS: ${GLEW_INCLUDE_DIRS}\")\n"
},
{
"path": "cmake/FindGLFW.cmake",
"content": "# Locate the GLFW library (version 2.0)\n# This module defines the following variables:\n# GLFW_LIBRARIES, the name of the library;\n# GLFW_INCLUDE_DIRS, where to find GLFW include files.\n# GLFW_FOUND, true if library path was resolved\n#\n# Usage example to compile an \"executable\" target to the glfw library:\n#\n# FIND_PACKAGE (GLFW REQUIRED)\n# INCLUDE_DIRECTORIES (${GLFW_INCLUDE_DIRS})\n# ADD_EXECUTABLE (executable ${YOUR_EXECUTABLE_SRCS})\n# TARGET_LINK_LIBRARIES (executable ${GLFW_LIBRARIES})\n#\n# TODO:\n# Lookup for windows\n# Allow the user to select to link to a shared library or to a static library.\n#\n# SEE:\n# - https://raw.github.com/progschj/OpenGL-Examples/master/cmake_modules/FindGLFW.cmake\n# \n\nFIND_PATH( GLFW_INCLUDE_DIRS GL/glfw.h\n $ENV{GLFWDIR}/include\n /usr/local/include\n /usr/local/X11R6/include\n /usr/X11R6/include\n /usr/X11/include\n /usr/include/X11\n /usr/include\n /opt/X11/include\n /opt/include \n\t#--- FOR WINDOWS \n\tC:/Developer/include\n #--- Deployed \n\t${CMAKE_SOURCE_DIR}/external/glfw/include)\n\t\nmessage(STATUS \"GLFW_INCLUDE_DIRS: ${GLFW_INCLUDE_DIRS}\")\n\t\nFIND_LIBRARY( GLFW_LIBRARIES NAMES glfw PATHS \n $ENV{GLFWDIR}/lib\n /usr/local/lib\n /usr/local/X11R6/lib\n /usr/X11R6/lib\n /usr/X11/lib\n /usr/lib/X11\n /usr/lib\n /opt/X11/lib\n /opt/lib \t\n\t#--- FOR WINDOWS \n\tC:/Developer/lib\n\t#--- Deployed\n ${CMAKE_SOURCE_DIR}/external/glfw/lib)\n\nSET(GLFW_FOUND \"NO\")\nIF(GLFW_LIBRARIES AND GLFW_INCLUDE_DIRS)\n SET(GLFW_FOUND \"YES\")\nENDIF(GLFW_LIBRARIES AND GLFW_INCLUDE_DIRS)\n"
},
{
"path": "cmake/FindGLM.cmake",
"content": "# FIND_PACKAGE (GLM REQUIRED)\n# INCLUDE_DIRECTORIES (${GLM_INCLUDE_DIRS})\n# ADD_EXECUTABLE (executable ${YOUR_EXECUTABLE_SRCS})\n\nif(WIN32)\n set(GLM_INCLUDE_DIRS \"C:/Developer/include\")\nelse()\nFIND_PATH( GLM_INCLUDE_DIRS glm/glm.hpp\n $ENV{GLM_DIR}\n /usr/local/include\n /usr/include\n /opt/include\n ${CMAKE_SOURCE_DIR}/external)\nendif()\n\nSET(GLM_FOUND \"NO\")\nIF(GLM_INCLUDE_DIRS)\n SET(GLM_FOUND \"YES\")\nENDIF()\n"
},
{
"path": "cmake/FindOpenCV2.cmake",
"content": "# To find OpenCV 2 library visit http://opencv.willowgarage.com/wiki/\n#\n# The follwoing variables are optionally searched for defaults\n# OpenCV2_ROOT_DIR: Base directory of OpenCV 2 tree to use.\n#\n# The following are set after configuration is done:\n# OpenCV2_FOUND\n# OpenCV2_INCLUDE_DIRS\n# OpenCV2_LIBRARIES\n#\n# $Id: $\n# \n# Balazs [2011-01-18]:\n# - Created from scratch for the reorganized OpenCV 2 structure introduced at version 2.2\n# Jbohren [2011-06-10]:\n# - Added OpenCV_ROOT_DIR for UNIX platforms & additional opencv include dir\n# jmorrison [2013-11-14]:\n# - Added flag to disable GPU requirement (NO_OPENCV_GPU)\n# \n# This file should be removed when CMake will provide an equivalent\n\n#--- Select exactly ONE OpenCV 2 base directory to avoid mixing different version headers and libs\nfind_path(OpenCV2_ROOT_INC_DIR NAMES opencv2/opencv.hpp\n PATHS\n #--- WINDOWS\n C:/Developer/include # Windows\n \"$ENV{OpenCV_ROOT_DIR}/include\" # *NIX: custom install\n /usr/local/include # Linux: default dir by CMake\n /usr/include # Linux\n /opt/local/include # OS X: default MacPorts location\n NO_DEFAULT_PATH)\n\n#--- DEBUG\n#message(STATUS \"OpenCV2_ROOT_INC_DIR: ${OpenCV2_ROOT_INC_DIR}\")\n\n#--- OBSOLETE\n# Get parent of OpenCV2_ROOT_INC_DIR. We do this as it is more\n# reliable than finding include/opencv2/opencv.hpp directly.\n#GET_FILENAME_COMPONENT(OpenCV2_ROOT_DIR ${OpenCV2_ROOT_INC_DIR} PATH)\n#message(STATUS \"OpenCV2_ROOT_DIR: ${OpenCV2_ROOT_DIR}\")\n\nfind_path(OpenCV2_CORE_INCLUDE_DIR NAMES core.hpp PATHS \"${OpenCV2_ROOT_INC_DIR}/opencv2/core\")\nfind_path(OpenCV2_IMGPROC_INCLUDE_DIR NAMES imgproc.hpp PATHS \"${OpenCV2_ROOT_INC_DIR}/opencv2/imgproc\")\nfind_path(OpenCV2_CONTRIB_INCLUDE_DIR NAMES contrib.hpp PATHS \"${OpenCV2_ROOT_INC_DIR}/opencv2/contrib\")\nfind_path(OpenCV2_HIGHGUI_INCLUDE_DIR NAMES highgui.hpp PATHS \"${OpenCV2_ROOT_INC_DIR}/opencv2/highgui\")\nfind_path(OpenCV2_FLANN_INCLUDE_DIR NAMES flann.hpp PATHS \"${OpenCV2_ROOT_INC_DIR}/opencv2/flann\")\n\nset(OpenCV2_INCLUDE_DIRS\n ${OpenCV2_ROOT_INC_DIR}\n ${OpenCV2_ROOT_INC_DIR}/opencv2\n ${OpenCV2_CORE_INCLUDE_DIR}\n ${OpenCV2_IMGPROC_INCLUDE_DIR}\n ${OpenCV2_CONTRIB_INCLUDE_DIR}\n ${OpenCV2_HIGHGUI_INCLUDE_DIR}\n ${OpenCV2_FLANN_INCLUDE_DIR})\n\n# absolute path to all libraries \n# set(OPENCV2_LIBRARY_SEARCH_PATHS \"${OpenCV2_ROOT_DIR}/lib\")\n\n#--- Specify where DLL is searched for\n#message(STATUS \"OPENCV2_LIBRARY_SEARCH_PATHS ${OPENCV2_LIBRARY_SEARCH_PATHS}\")\nlist(APPEND OPENCV2_LIBRARY_SEARCH_PATHS $ENV{OpenCV_ROOT_DIR})\nlist(APPEND OPENCV2_LIBRARY_SEARCH_PATHS \"C:/Developer/lib\")\nlist(APPEND OPENCV2_LIBRARY_SEARCH_PATHS \"/usr/local/lib\")\nlist(APPEND OPENCV2_LIBRARY_SEARCH_PATHS \"/opt/local/lib\")\nlist(APPEND OPENCV2_LIBRARY_SEARCH_PATHS \"/usr/lib\")\n\n\n#--- FIND RELEASE LIBRARIES\nfind_library(OpenCV2_CORE_LIBRARY_REL NAMES opencv_core opencv_core230 opencv_core220 opencv_core2410 PATHS ${OPENCV2_LIBRARY_SEARCH_PATHS})\nfind_library(OpenCV2_IMGPROC_LIBRARY_REL NAMES opencv_imgproc opencv_imgproc230 opencv_imgproc220 opencv_imgproc2410 PATHS ${OPENCV2_LIBRARY_SEARCH_PATHS})\nfind_library(OpenCV2_CONTRIB_LIBRARY_REL NAMES opencv_contrib opencv_contrib230 opencv_contrib220 opencv_contrib2410 PATHS ${OPENCV2_LIBRARY_SEARCH_PATHS})\nfind_library(OpenCV2_HIGHGUI_LIBRARY_REL NAMES opencv_highgui opencv_highgui230 opencv_highgui220 opencv_highgui2410 PATHS ${OPENCV2_LIBRARY_SEARCH_PATHS})\nlist(APPEND OpenCV2_LIBRARIES_REL ${OpenCV2_CORE_LIBRARY_REL})\nlist(APPEND OpenCV2_LIBRARIES_REL ${OpenCV2_IMGPROC_LIBRARY_REL})\nlist(APPEND OpenCV2_LIBRARIES_REL ${OpenCV2_CONTRIB_LIBRARY_REL})\nlist(APPEND OpenCV2_LIBRARIES_REL ${OpenCV2_HIGHGUI_LIBRARY_REL})\n\n#--- FIND DEBUG LIBRARIES\nif(WIN32)\n find_library(OpenCV2_CORE_LIBRARY_DEB NAMES opencv_cored opencv_core230d opencv_core220d opencv_core2410d PATHS ${OPENCV2_LIBRARY_SEARCH_PATHS})\n find_library(OpenCV2_IMGPROC_LIBRARY_DEB NAMES opencv_imgprocd opencv_imgproc230d opencv_imgproc220d opencv_imgproc2410d PATHS ${OPENCV2_LIBRARY_SEARCH_PATHS})\n find_library(OpenCV2_CONTRIB_LIBRARY_DEB NAMES opencv_contribd opencv_contrib230d opencv_contrib220d opencv_contrib2410d PATHS ${OPENCV2_LIBRARY_SEARCH_PATHS})\n find_library(OpenCV2_HIGHGUI_LIBRARY_DEB NAMES opencv_highguid opencv_highgui230d opencv_highgui220d opencv_highgui2410d PATHS ${OPENCV2_LIBRARY_SEARCH_PATHS})\n list(APPEND OpenCV2_LIBRARIES_DEB ${OpenCV2_CORE_LIBRARY_DEB})\n list(APPEND OpenCV2_LIBRARIES_DEB ${OpenCV2_IMGPROC_LIBRARY_DEB})\n list(APPEND OpenCV2_LIBRARIES_DEB ${OpenCV2_CONTRIB_LIBRARY_DEB})\n list(APPEND OpenCV2_LIBRARIES_DEB ${OpenCV2_HIGHGUI_LIBRARY_DEB})\nendif()\n\n#--- Setup cross-config libraries\nset(OpenCV2_LIBRARIES \"\")\nif(WIN32)\n list(APPEND OpenCV2_LIBRARIES optimized ${OpenCV2_CORE_LIBRARY_REL} debug ${OpenCV2_CORE_LIBRARY_DEB})\n list(APPEND OpenCV2_LIBRARIES optimized ${OpenCV2_IMGPROC_LIBRARY_REL} debug ${OpenCV2_IMGPROC_LIBRARY_DEB})\n list(APPEND OpenCV2_LIBRARIES optimized ${OpenCV2_CONTRIB_LIBRARY_REL} debug ${OpenCV2_CONTRIB_LIBRARY_DEB})\n list(APPEND OpenCV2_LIBRARIES optimized ${OpenCV2_HIGHGUI_LIBRARY_REL} debug ${OpenCV2_HIGHGUI_LIBRARY_DEB})\nelse()\n list(APPEND OpenCV2_LIBRARIES ${OpenCV2_CORE_LIBRARY_REL} )\n list(APPEND OpenCV2_LIBRARIES ${OpenCV2_IMGPROC_LIBRARY_REL})\n list(APPEND OpenCV2_LIBRARIES ${OpenCV2_CONTRIB_LIBRARY_REL})\n list(APPEND OpenCV2_LIBRARIES ${OpenCV2_HIGHGUI_LIBRARY_REL})\nendif()\n\n#--- Verifies everything (include) was found\nset(OpenCV2_FOUND ON)\nFOREACH(NAME ${OpenCV2_INCLUDE_DIRS})\n IF(NOT EXISTS ${NAME})\n message(WARNING \"Could not find: ${NAME}\")\n set(OpenCV2_FOUND OFF)\n endif(NOT EXISTS ${NAME})\nENDFOREACH(NAME)\n\n#--- Verifies everything (release lib) was found\nFOREACH(NAME ${OpenCV2_LIBRARIES_REL})\n IF(NOT EXISTS ${NAME})\n message(WARNING \"Could not find: ${NAME}\")\n set(OpenCV2_FOUND OFF)\n endif(NOT EXISTS ${NAME})\n ENDFOREACH()\n\n#--- Verifies everything (debug lib) was found\nFOREACH(NAME ${OpenCV2_LIBRARIES_DEB})\n IF(NOT EXISTS ${NAME})\n message(WARNING \"Could not find: ${NAME}\")\n set(OpenCV2_FOUND OFF)\n endif(NOT EXISTS ${NAME})\nENDFOREACH()\n\n#--- Display help message\nIF(NOT OpenCV2_FOUND)\n IF(OpenCV2_FIND_REQUIRED)\n MESSAGE(FATAL_ERROR \"OpenCV 2 not found.\")\n else()\n MESSAGE(STATUS \"OpenCV 2 not found.\")\n endif()\nendif()\n"
},
{
"path": "cmake/FindOpenGP.cmake",
"content": "# Locate the OpenGP library (version 1.0)\n# This module defines the following variables:\n# OpenGP_INCLUDE_DIRS, where to find OpenGP include files.\n# OpenGP_FOUND and OPENGP_FOUND true if library path was resolved\n#\n# Usage example to compile an \"executable\" target:\n#\n# FIND_PACKAGE (OpenGP REQUIRED)\n# INCLUDE_DIRECTORIES (${OpenGP_INCLUDE_DIRS})\n# ADD_EXECUTABLE (executable ${YOUR_EXECUTABLE_SRCS})\n# \n# DEBUG: outputs given environment variable\n# message(STATUS OpenGPDIR $ENV{OpenGP_DIR})\n\nFIND_PATH( OpenGP_INCLUDE_DIRS OpenGP/Surface_mesh.h\n $ENV{OpenGP_DIR}\n /usr/local/include\n /usr/local/X11R6/include\n /usr/X11R6/include\n /usr/X11/include\n /usr/include/X11\n /usr/include\n /opt/X11/include\n /opt/include\n /Users/andrea/Developer/OpenGP/src # local build\n ${CMAKE_SOURCE_DIR}/external/opengp/include)\n\nSET(OPENGP_FOUND \"NO\")\nSET(OpenGP_FOUND \"NO\")\nIF(OpenGP_INCLUDE_DIRS)\n SET(OPENGP_FOUND \"YES\")\n SET(OpenGP_FOUND \"YES\")\nENDIF()\n"
},
{
"path": "cmake/FindOpenNI2.cmake",
"content": "# OPENNI2_INCLUDE_DIR\n# OPENNI2_LIBRARY\n# OPENNI2_FOUND\n\nfind_path(OPENNI2_INCLUDE_DIR \"OpenNI.h\"\n PATHS\n #--- MAC\n /usr/include/ni2\n /usr/local/include/ni2\n #--- WINDOWS\n C:/Developer/include/openni\n #--- LINUX (self deployed)\n ${CMAKE_SOURCE_DIR}/openni/include\n ${CMAKE_SOURCE_DIR}/../openni/include\n DOC \"OpenNI c++ interface header\")\n\nfind_library(OPENNI2_LIBRARY \"OpenNI2\"\n PATHS\n #--- MAC\n /usr/lib/ni2\n /usr/local/lib/ni2\n #--- LINUX (self deployed)\n /usr/lib\n #--- WINDOWS\n C:/Developer/lib\n C:/Program Files/OpenNI2/Lib\n ${CMAKE_SOURCE_DIR}/openni/lib\n ${CMAKE_SOURCE_DIR}/../openni/lib\n DOC \"OpenNI2 library\")\n\n#message(STATUS \"OPENNI2_LIBRARY: ${OPENNI2_LIBRARY}\")\n#message(STATUS \"OPENNI2_INCLUDE_DIR: ${OPENNI2_INCLUDE_DIR}\")\n\nif(OPENNI2_INCLUDE_DIR AND OPENNI2_LIBRARY)\n set(OPENNI2_FOUND TRUE)\nendif()\n\n#--- Notifications\nif(OPENNI2_FOUND AND NOT OpenNI2__FIND_QUIETLY)\n message(STATUS \"Found OpenNI: ${OPENNI2_LIBRARY}\")\nelse()\n if(OpenNI2_FIND_REQUIRED)\n message(STATUS OPENNI2_INCLUDE_DIR: ${OPENNI2_INCLUDE_DIR})\n message(STATUS OPENNI2_LIBRARY: ${OPENNI2_LIBRARY})\n message(FATAL_ERROR \"Could not find OpenNI2\")\n endif()\nendif()\n"
},
{
"path": "cmake/FindQGLViewer.cmake",
"content": "# - Try to find QGLViewer\n# Once done this will define\n#\n# QGLVIEWER_FOUND - system has QGLViewer\n# QGLVIEWER_INCLUDE_DIR - the QGLViewer include directory\n# QGLVIEWER_LIBRARIES - Link these to use QGLViewer\n# QGLVIEWER_DEFINITIONS - Compiler switches required for using QGLViewer\n#\n\nfind_path(QGLVIEWER_INCLUDE_DIR \n NAMES QGLViewer/qglviewer.h\n PATHS\n #--- Windows\n C:/Developer/include\n #--- Mac\n /Library/Frameworks\n #--- Linux\n /usr/include\n /usr/local/include\n #--- Environment\n ENV QGLVIEWERROOT\n PATH_SUFFIXES Headers)\n\nfind_library(QGLVIEWER_LIBRARY_RELEASE\n NAMES QGLViewer QGLViewer2 QGLViewer2\n HINTS\n #--- Windows\n C:/Developer/lib\n #--- Linux\n /usr/lib\n /usr/local/lib\n #--- Mac\n /Library/Frameworks\n #--- Environment\n ENV QGLVIEWERROOT\n ENV LD_LIBRARY_PATH\n ENV LIBRARY_PATH\n PATH_SUFFIXES\n QGLViewer\n QGLViewer/release)\n\nfind_library(QGLVIEWER_LIBRARY_DEBUG\n NAMES\n dqglviewer\n dQGLViewer\n dQGLViewer2\n QGLViewerd2\n PATHS\n #--- Windows\n C:/Developer/lib\n #--- Linux\n /usr/lib\n /usr/local/lib\n #--- Mac\n /Library/Frameworks\n #--- Environment\n ENV QGLVIEWERROOT\n ENV LD_LIBRARY_PATH\n ENV LIBRARY_PATH\n PATH_SUFFIXES\n QGLViewer\n QGLViewer/debug)\n\nif(QGLVIEWER_LIBRARY_RELEASE)\n if(QGLVIEWER_LIBRARY_DEBUG)\n set(QGLVIEWER_LIBRARIES_ optimized ${QGLVIEWER_LIBRARY_RELEASE} debug ${QGLVIEWER_LIBRARY_DEBUG})\n else()\n set(QGLVIEWER_LIBRARIES_ ${QGLVIEWER_LIBRARY_RELEASE})\n endif()\n set(QGLVIEWER_LIBRARIES ${QGLVIEWER_LIBRARIES_} CACHE FILEPATH \"The QGLViewer library\")\nendif()\n\n#message(STATUS \"QGLVIEWER_INCLUDE_DIR: ${QGLVIEWER_INCLUDE_DIR}\")\n#message(STATUS \"QGLVIEWER_LIBRARIES: ${QGLVIEWER_LIBRARIES}\")\n\nIF(QGLVIEWER_INCLUDE_DIR AND QGLVIEWER_LIBRARIES)\n SET(QGLVIEWER_FOUND TRUE)\nENDIF()\n\nIF(QGLVIEWER_FOUND)\n IF(NOT CMAKE_FIND_QUIETLY)\n MESSAGE(STATUS \"Found QGLViewer: ${QGLVIEWER_LIBRARIES}\")\n ENDIF()\nELSE()\n IF(QGLViewer_FIND_REQUIRED)\n MESSAGE(FATAL_ERROR \"Could not find QGLViewer\")\n ENDIF()\nENDIF()\n\n"
},
{
"path": "cmake/FindSoftKinetic.cmake",
"content": "FIND_PATH( SOFTKINETIC_INCLUDE_DIR DepthSenseTypes.h\n $ENV{SOFTKINETIC_DIR}\n /opt/softkinetic/DepthSenseSDK/include\n ${CMAKE_SOURCE_DIR}/external/softkinetic/DepthSenseSDK/include)\n\nfind_library(TURBOJPEG_LIB\n NAMES turbojpeg\n PATHS /opt/softkinetic/DepthSenseSDK/lib)\nfind_library(DEPTHSENSE_LIB\n NAMES DepthSense\n PATHS /opt/softkinetic/DepthSenseSDK/lib)\nfind_library(DEPTHSENSEPLUGINS_LIB\n NAMES DepthSensePlugins\n PATHS /opt/softkinetic/DepthSenseSDK/lib)\n\n#message(STATUS \"INCLUDES ${SOFTKINETIC_INCLUDE_DIRS}\")\n#message(STATUS \"LIBS ${DEPTHSENSE_LIB}, ${TURBOJPEG_LIB}, ${DEPTHSENSEPLUGINS_LIB}\")\n\nif(TURBOJPEG_LIB AND DEPTHSENSE_LIB AND DEPTHSENSEPLUGINS_LIB)\n LIST(APPEND SOFTKINETIC_LIBRARIES ${TURBOJPEG_LIB})\n LIST(APPEND SOFTKINETIC_LIBRARIES ${DEPTHSENSE_LIB})\n LIST(APPEND SOFTKINETIC_LIBRARIES ${DEPTHSENSEPLUGINS_LIB})\nendif()\n\n\nIF(SOFTKINETIC_INCLUDE_DIR AND SOFTKINETIC_LIBRARIES)\n SET(SOFTKINETIC_FOUND TRUE)\nelse()\n SET(SOFTKINETIC_FOUND FALSE)\nENDIF()\n\nIF(SOFTKINETIC_FOUND)\n IF(NOT CMAKE_FIND_QUIETLY)\n MESSAGE(STATUS \"Found SoftKinetic: ${SOFTKINETIC_INCLUDE_DIR}\")\n ENDIF()\nELSE()\n IF(SOFTKINETIC_FOUND_REQUIRED)\n MESSAGE(FATAL_ERROR \"Could not find SoftKinetic\")\n ENDIF()\nENDIF()\n"
},
{
"path": "cudax/CMakeLists.txt",
"content": "if(NOT WITH_CUDA)\n return()\nendif()\n\n#--- Dummy rule to show whole cudax folder in explorer\nfile(GLOB CUDA_FILES \"*\")\nadd_custom_target(cudax_files SOURCES ${CUDA_FILES})\n\n#--- C++ sources (non-kernel) that need cuda are appended\nfile(GLOB_RECURSE CUDAX_CPP \"${CMAKE_CURRENT_LIST_DIR}/*.cpp\")\nfile(GLOB_RECURSE CUDAX_CU \"${CMAKE_CURRENT_LIST_DIR}/*.cu\")\nfile(GLOB_RECURSE CUDAX_H \"${CMAKE_CURRENT_LIST_DIR}/*.h\")\n\n#--- Create the cudax static library & add it\nINCLUDE_DIRECTORIES(.)\nINCLUDE_DIRECTORIES(../) #so we can say #include \"cudax/...\"\ncuda_add_library(cudax STATIC ${CUDAX_CPP} ${CUDAX_CU} ${CUDAX_H})\n\n"
},
{
"path": "cudax/CublasHelper.h",
"content": "#pragma once\n#include \n#include \n#include \n#include \n#include \n#include \"thrust/device_vector.h\"\n#include \n#include \"util/singleton.h\"\n#include \"externs.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\n\nclass CublasHelper{\n SINGLETON(CublasHelper)\n\npublic:\n cublasHandle_t _handle;\n \npublic:\n static cublasHandle_t handle(){ return instance()._handle; }\n static void init(){\n std::cout << \"Starting up CUBLAS\" << std::endl;\n cublasStatus_t status = cublasCreate(&(instance()._handle));\n if (status != CUBLAS_STATUS_SUCCESS){\n fprintf(stderr, \"!!!! CUBLAS initialization error\\n\");\n exit(EXIT_FAILURE);\n }\n }\n static void cleanup(){\n std::cout << \"Shutting down CUBLAS\" << std::endl; \n cublasStatus_t status = cublasDestroy(instance()._handle);\n if (status != CUBLAS_STATUS_SUCCESS) {\n fprintf(stderr, \"!!!! CUBLAS shutdown error\\n\");\n exit(EXIT_FAILURE);\n } \n }\n\n\n//-----------------------------------------------------------------------------\n\n\npublic:\n static void outer_product_J(const Jacobian& J, ///< input\n thrust::device_vector& JtJ, ///< output\n int num_constr, ///< #rows of J\n int num_pars) ///< #cols of J\n {\n assert(J.size()==(num_constr)); ///< check jacobian rows\n assert(JtJ.size()==(num_pars*num_pars));\n outer_product((float*)thrust::raw_pointer_cast(J.data()),\n thrust::raw_pointer_cast(&JtJ[0]),\n num_constr,\n num_pars);\n }\n \npublic:\n static void vector_product_J(const Jacobian& J, ///< input\n const thrust::device_vector& e, ///< input\n thrust::device_vector& Jte, ///< output\n int num_constr, ///< #rows of J and e\n int num_pars) ///< #cols of J\n {\n assert(J.size()==(num_constr)); ///< check jacobian rows\n assert(e.size()==(num_constr));\n assert(Jte.size()==(num_pars));\n vector_product((float*)thrust::raw_pointer_cast(J.data()),\n thrust::raw_pointer_cast(&e[0]),\n thrust::raw_pointer_cast(&Jte[0]),\n num_constr,\n num_pars);\n }\n \npublic:\n static void dot_product_e(const thrust::device_vector& e, ///< input\n float& ete, ///< output\n int num_constr) ///< # elements of vector e\n {\n assert(e.size()==(num_constr));\n dot_product(thrust::raw_pointer_cast(&e[0]),\n thrust::raw_pointer_cast(&e[0]),\n &ete, num_constr);\n }\n \n \n//-----------------------------------------------------------------------------\n\n\npublic:\n static void outer_product(const thrust::device_vector& J, ///< input\n thrust::device_vector& JtJ, ///< output\n int num_constr, ///< #rows of J\n int num_pars) ///< #cols of J\n {\n assert(J.size()==(num_constr*num_pars));\n assert(JtJ.size()==(num_pars*num_pars));\n outer_product((float*)thrust::raw_pointer_cast(J.data()),\n (float*)thrust::raw_pointer_cast(&JtJ[0]),\n num_constr,\n num_pars);\n }\n \npublic:\n static void vector_product(const thrust::device_vector& J, ///< input\n const thrust::device_vector& e, ///< input\n thrust::device_vector& Jte, ///< output\n int num_constr, ///< #rows of J and e\n int num_pars) ///< #cols of J\n {\n assert(J.size()==(num_constr*num_pars));\n assert(e.size()==(num_constr));\n assert(Jte.size()==(num_pars));\n vector_product((float*)thrust::raw_pointer_cast(J.data()),\n (float*)thrust::raw_pointer_cast(&e[0]),\n (float*)thrust::raw_pointer_cast(&Jte[0]),\n num_constr,\n num_pars);\n }\n \n \n//-----------------------------------------------------------------------------\n \n\nprivate:\n /// Computes J^t*J and stores in pre-allocated matrix JtJ\n static void outer_product(const float* J, float* JtJ, int num_constr, int num_pars /*num_thetas*/){\n // C = \\beta C + \\alpha op(A) op(B);\n //\n // \"ld\" refers to the leading dimension of the matrix, which in the case of column-major \n // storage is the number of rows of the allocated matrix (even if only a submatrix of \n // it is being used).\n //\n const float alpha = 1.0;\n const float beta = 0.0;\n\n#define ROW_MAJOR_INPUT\n#ifdef ROW_MAJOR_INPUT\n // Cublas expects column major matrices, but our input is row major.\n // Therefore we let cublas treat our row major input as column major\n // and compute: J_colmajor * J_colmajor^T == J_rowmajor^T * J_rowmajor\n cublasStatus_t status = cublasSgemm(CublasHelper::handle(), \n CUBLAS_OP_N, // J_rowmajor^T == J_colmajor\n CUBLAS_OP_T, // J_rowmajor == J_colmajor^T\n num_pars, num_pars, num_constr, \n &alpha,\n J, // A \n num_pars, // ld_A\n J, // B, \n num_pars, // ld_B\n &beta,\n JtJ, // C\n num_pars // ld_C\n );\n#else\n // column major input matrix\n cublasStatus_t status = cublasSgemm(CublasHelper::handle(), \n CUBLAS_OP_T, //J^t\n CUBLAS_OP_N, //J\n num_pars, num_pars, num_constr, \n &alpha,\n J, // A \n num_constr, // ld_A\n J, // B, \n num_constr, // ld_B\n &beta,\n JtJ, // C\n num_pars // ld_C\n );\n#endif\n\n if(status != CUBLAS_STATUS_SUCCESS){\n fprintf(stderr, \"!!!! CUBLAS matrix multiplication (constr: %d pars: %d) failure!\\n\", num_constr, num_pars);\n // fprintf(stderr, \"!!!! CUBLAS matrix multiplication failure!\\n\");\n exit(EXIT_FAILURE);\n } \n }\n\nprivate:\n /// Computes J^t*e and stores in pre-allocated matrix Jte\n static void vector_product(\n const float* J,\n const float* e,\n float* Jte,\n int num_constr,\n int num_pars /*num_thetas*/)\n {\n // y = \\alpha op(A) x + \\beta y\n const float alpha = 1.0;\n const float beta = 0.0;\n const int inc1 = 1;\n\n // Cublas expects column major matrices, but our input is row major.\n // Therefore we let cublas treat our row major input as column major\n // and compute: J_colmajor * e == J_rowmajor^T * e\n#if 1\n cublasStatus_t status = cublasSgemv(CublasHelper::handle(), \n CUBLAS_OP_N, // J_rowmajor^T == J_colmajor\n num_pars, num_constr, \n &alpha, // 1\n J, // A \n num_pars, // ld_A\n e, // x\n inc1, // stride of x\n &beta, // 0\n Jte, // y\n inc1 // stride of y\n );\n#else\n cublasStatus_t status = cublasSgemm(CublasHelper::handle(), \n CUBLAS_OP_N, // J_rowmajor^T == J_colmajor\n CUBLAS_OP_T, // e_rowmajor == e_colmajor^T\n num_pars, 1, num_constr, \n &alpha,\n J, // A \n num_pars, // ld_A\n e, // B, \n inc1, // ld_B\n &beta,\n Jte, // C\n inc1 // ld_C\n );\n#endif\n\n if(status != CUBLAS_STATUS_SUCCESS){\n fprintf(stderr, \"!!!! CUBLAS matrix-vector multiplication (constr: %d pars: %d) failure!\\n\", num_constr, num_pars);\n exit(EXIT_FAILURE);\n } \n }\n \nprivate:\n /// Computes u^t*v and stores in referenced variable utv\n static void dot_product(\n const float* u,\n const float* v,\n float* utv,\n int dim)\n {\n /*\n cublasStatus_t cublasSdot (cublasHandle_t handle, int n,\n const float *x, int incx,\n const float *y, int incy,\n float *result)\n */\n \n cublasStatus_t status = cublasSdot(CublasHelper::handle(),\n dim,\n u, 1,\n v, 1,\n utv);\n \n if(status != CUBLAS_STATUS_SUCCESS){\n fprintf(stderr, \"!!!! CUBLAS vector-vector multiplication (d: %d) failure!\\n\", dim);\n exit(EXIT_FAILURE);\n } \n }\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/CudaHelper.h",
"content": "/// @warning this cannot contain any c++11!!\n#pragma once\n#include \n#include \"util/gl_wrapper.h\"\n#include \n#include \"util/singleton.h\"\n#include \"cudax/helper_cuda.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\nclass CudaHelper{\n SINGLETON(CudaHelper)\n \npublic:\n /// @note to be done ***after*** OpenGL for optimal OpenGL/CUDA performance\n static void init(){\n int devID = gpuGetMaxGflopsDeviceId();\n cudaError status = cudaGLSetGLDevice(devID);\n if(status!=cudaSuccess){\n std::cout << \"Could not get OpenGL compliant device... exiting\" << std::endl;\n exit(0);\n }\n }\n static void cleanup(){\n std::cout << \"Shutting down CUDA device\" << std::endl;\n cudaDeviceReset();\n }\n \npublic:\n /// To debug calls to: cudaBindTextureToArray\n static void check_array(cudaArray* array){\n struct cudaChannelFormatDesc desc;\n checkCudaErrors(cudaGetChannelDesc(&desc, array));\n printf(\"CUDA Array channel descriptor, bits per component:\\n\");\n printf(\"X %d Y %d Z %d W %d, kind %d\\n\",\n desc.x,desc.y,desc.z,desc.w,desc.f);\n printf(\"Possible values for channel format kind: i %d, u%d, f%d:\\n\",\n cudaChannelFormatKindSigned, cudaChannelFormatKindUnsigned,\n cudaChannelFormatKindFloat); \n }\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n\n"
},
{
"path": "cudax/CudaTimer.h",
"content": "#pragma once\n#include \n#include \n#include \n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\n// http://devblogs.nvidia.com/parallelforall/how-implement-performance-metrics-cuda-cc/\nstruct CudaTimer{\n cudaEvent_t _start, _stop;\n std::string message;\n std::string prefix;\n bool event_on_destroy;\n /// Same as create + restart\n CudaTimer(const std::string& message){\n cudaEventCreate(&_start);\n cudaEventCreate(&_stop); \n this->message = message;\n cudaEventRecord(_start);\n event_on_destroy = true;\n std::cout << std::setprecision(3);\n prefix = \"Executed \";\n }\n CudaTimer(){\n prefix = \"Executed \";\n event_on_destroy = false;\n cudaEventCreate(&_start);\n cudaEventCreate(&_stop); \n }\n ~CudaTimer(){\n if(event_on_destroy)\n display();\n cudaEventDestroy(_start);\n cudaEventDestroy(_stop);\n }\n void set_prefix(const std::string& prefix){\n this->prefix = prefix;\n }\n void restart(const std::string& message){\n this->message = message;\n cudaEventRecord(_start); \n }\n void display(){\n static std::ofstream out(\"cuda.log\");\n cudaEventRecord(_stop); \n cudaEventSynchronize(_stop);\n float milliseconds = 0;\n cudaEventElapsedTime(&milliseconds, _start, _stop);\n \n std::cout << prefix << \"[\"<< message <<\"] in [\" << milliseconds << \"ms]\" << std::endl;\n }\n\tfloat elapsed(){\n cudaEventRecord(_stop); \n cudaEventSynchronize(_stop);\n float milliseconds = 0;\n cudaEventElapsedTime(&milliseconds, _start, _stop);\n\t\treturn milliseconds;\n\t}\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n\n#define CUDA_TIMED_BLOCK(obj, blockName) for ( struct { int i; cudax::CudaTimer timer; } obj = { 0, cudax::CudaTimer(blockName) }; obj.i < 1; ++obj.i)\n"
},
{
"path": "cudax/KinectCamera.h",
"content": "#pragma once\n#include \n#include \"cuda_runtime.h\"\n#include \"cuda_glm.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\nstruct KinectCamera{\n thrust::device_vector inv_proj_matrix; ///< only containts one\n glm::mat3x3* D_mat_ptr; ///< device pointer to its content\n \n KinectCamera(const float* H_inv_proj_matrix){\n inv_proj_matrix.resize(1);\n thrust::device_ptr mat = &inv_proj_matrix[0];\n D_mat_ptr = thrust::raw_pointer_cast(mat);\n cudaMemcpy((void*) D_mat_ptr, H_inv_proj_matrix, 9*sizeof(float), cudaMemcpyHostToDevice);\n }\n const glm::mat3x3& D_inv_proj_matrix(){\n return (*D_mat_ptr);\n }\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/Kinematic.h",
"content": "#pragma once\n#include \n#include \"tracker/DataStructure/CustomJointInfo.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\nstruct Kinematic{\n /// These hold memory\n thrust::device_vector D_jointinfos;\n thrust::device_vector D_chains;\n /// These are used to access data in the kernel\n CustomJointInfo* jointinfos; ///< @note device raw pointer\n ChainElement* chains; ///< @note device raw pointer\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n\n\n"
},
{
"path": "cudax/MeshGrid.h",
"content": "#pragma once\n#include \n#include \"thrust/device_vector.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\n/// Device array containing MATLAB meshgrid like data\n/// int4:\n/// x) i: row\n/// y) j: col\n/// z) off: linear array iterator (i*width+j)\n/// w) id: recycled for computation later (constraint id)\nstruct MeshGrid{\n typedef int4 Elem;\n typedef thrust::device_vector Offsets;\n int width;\n int height;\n Offsets offsets;\n\n MeshGrid(int width, int height){ \n this->width = width;\n this->height = height;\n offsets.resize(width*height);\n thrust::counting_iterator fst_index(0);\n thrust::counting_iterator lst_index(width*height);\n thrust::transform(fst_index, lst_index, offsets.begin(), index_to_offset(width,height) );\n }\n Offsets::iterator begin(){ return offsets.begin(); }\n Offsets::iterator end(){ return offsets.end(); }\n \n /// a functor hashing indices to image-space coordinates\n struct index_to_offset {\n int n_rows, n_cols;\n \n __host__ __device__\n index_to_offset(int n_rows, int n_cols){\n this->n_rows = n_rows;\n this->n_cols = n_cols;\n }\n __host__ __device__\n int4 operator()(int index) {\n int4 offset;\n offset.y = index/n_rows; // j\n offset.x = index-(n_rows*offset.y); // i\n offset.z = index;\n offset.w = -1; ///< invalid index\n return offset;\n }\n };\n \n struct GetPixelIndex : public thrust::unary_function{\n __device__\n int operator()(MeshGrid::Elem& off){ return off.w; }\n };\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n\n/// Ability to output Elem values to std::cout\ninline std::ostream& operator<< (std::ostream& d, cudax::MeshGrid::Elem val) { \n return d << val.x << \" \" << val.y << \" \" << val.z << \" \" << val.w;\n}\n"
},
{
"path": "cudax/OpenCVOutputBuffer.h",
"content": "#pragma once\n#include \n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\n///--- Deals with debug memory copy&mapping\nclass OpenCVOutputBuffer{\n typedef unsigned char uchar;\n uchar* host_mem;\n thrust::device_vector dev_mem;\n int _width, _height;\npublic:\n OpenCVOutputBuffer(uchar* host_mem, int width, int height) : \n host_mem(host_mem),\n dev_mem(host_mem, host_mem+(width*height)),\n _width(width), _height(height){}\n ~OpenCVOutputBuffer(){\n thrust::copy(dev_mem.begin(), dev_mem.end(), host_mem); \n }\n uchar* get(){ return dev_mem.data().get(); } \n int width(){ return _width; }\n int height(){ return _height; }\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/PixelIndexer.h",
"content": "#pragma once\n#include \"kernel.h\"\n#include \n#include \"cudax/functors/IsMatchingDepth.h\"\n#include \"cudax/functors/IsSilhouetteBoundary.h\"\n#include \"cudax/functors/IsSilhouette.h\"\n#include \"cudax/MeshGrid.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\nstruct PixelIndexer : public thrust::unary_function{\n const int INVALID;\n thrust::device_vector counters_memory; \n thrust::device_vector render_indexes_memory; ///< row index of a pixel in the render cloud\n thrust::device_vector sensor_indexes_memory; ///< row index of a pixel in the sensor cloud \n int* counters; ///< raw devive pointer!! \n int* render_indexes; ///< raw devive pointer!!\n int* sensor_indexes; ///< raw devive pointer!!\n int2* cnstr_indexes; ///< raw devive pointer!!\n \npublic: \n /// @see https://github.com/thrust/thrust/blob/master/examples/arbitrary_transformation.cu\n PixelIndexer(thrust::device_vector& indexes)\n : INVALID(-1),\n counters_memory(PixelType::SIZE, 0 /*init*/),\n render_indexes_memory(H_width*H_height, PixelIndexer::INVALID),\n sensor_indexes_memory(H_width*H_height, PixelIndexer::INVALID)\n {\n this->counters = thrust::raw_pointer_cast(&counters_memory[0]);\n this->render_indexes = thrust::raw_pointer_cast(&render_indexes_memory[0]);\n this->sensor_indexes = thrust::raw_pointer_cast(&sensor_indexes_memory[0]); \n this->cnstr_indexes = thrust::raw_pointer_cast(&indexes[0]);\n }\n \n void clear(){\n thrust::fill(counters_memory.begin(), counters_memory.end(), 0);\n /// @todo these could be done during operator() for efficiency\n thrust::fill(render_indexes_memory.begin(), render_indexes_memory.end(), PixelIndexer::INVALID);\n thrust::fill(sensor_indexes_memory.begin(), sensor_indexes_memory.end(), PixelIndexer::INVALID);\n }\n \n int num_silho_constraints(){ return counters_memory[PixelType::CONSTRAINT_SILHO]; }\n int num_depth_constraints(){ return counters_memory[PixelType::CONSTRAINT_DEPTH]; }\n int num_extra_pull_constraints(){ return 3*counters_memory[PixelType::CONSTRAINT_EXTRA_PULL]; }\n int num_extra_push_constraints(){ return 2*counters_memory[PixelType::CONSTRAINT_EXTRA_PUSH]; }\n \n int num_silho_sensor(){ return counters_memory[PixelType::SENSOR_SILHOUETTE]; }\n int num_silho_render(){ return counters_memory[PixelType::RENDER_SILHOUETTE]; }\n int num_silho_overlap(){ return counters_memory[PixelType::OVERLAP_SILHOUETTE]; }\n int num_silho_union(){ return counters_memory[PixelType::UNION_SILHOUETTE]; }\n \n void print_constraints(){\n // printf(\" #silho: %d\\n\", num_silho_constraints());\n // printf(\" #depth: %d\\n\", num_depth_constraints());\n printf(\" #extra_pull: %d\\n\", num_extra_pull_constraints());\n // printf(\" #extra_push: %d\\n\", num_extra_push_constraints());\n // printf(\" #rendered: %d\\n\", num_silho_render());\n }\n \n __device__ int type(const MeshGrid::Elem& off){ return cnstr_indexes[off.z].x; }\n __device__ int constraint_index(const MeshGrid::Elem& off){ return cnstr_indexes[off.z].y; }\n __device__ int render_cloud_index(const MeshGrid::Elem& off){ return render_indexes[off.z]; }\n __device__ int sensor_cloud_index(const MeshGrid::Elem& off){ return sensor_indexes[off.z]; }\n \n void exec(){\n clear();\n Functor functor(counters, render_indexes, sensor_indexes, cnstr_indexes);\n thrust::for_each(meshgrid->begin(), meshgrid->end(), functor);\n }\n \n struct IsExtraPullConstraint{\n IsSensorSilhouette is_sensor_silhouette;\n IsExtraPullConstraint() : is_sensor_silhouette(*silhouette_sensor){}\n\n __device__\n bool operator()(const int4& off){\n#ifndef DISCARD_BAD_SENSOR\n return is_sensor_silhouette(off);\n#else\n if(!is_sensor_silhouette(off)) return false;\n return true;\n float4 sensor_normal = SENSOR_NORMALS(off);\n // printf(\"sensor_normal %f %f %f\\n\", sensor_normal.x, sensor_normal.y, sensor_normal.z);\n return (-sensor_normal.z > .05); ///< minus: normal point toward camera\n#endif \n }\n };\n \n struct IsExtraPushConstraint{\n IsRenderedSilhouette is_r_silho;\n IsSensorSilhouette is_s_silho;\n IsExtraPushConstraint() : is_s_silho(*silhouette_sensor){}\n\n __device__\n bool operator()(const int4& off){\n return is_r_silho(off) && !is_s_silho(off);\n }\n };\n\n ///--- @note unfortunately functors cannot contain device_vector members, so we need to move \n /// operator() in a nested functor class\n struct Functor{\n // typedef IsSensorSilhouette IsExtraPullConstraint; ///< TEMP \n // typedef IsRenderedSilhouette IsExtraPushConstraint; ///< TEMP\n IsDepthConstraint is_depth_constraint;\n IsSilhouetteBoundary is_silhouette_boundary;\n IsRenderedSilhouette is_rendered_silhouette;\n IsSensorSilhouette is_sensor_silhouette;\n IsExtraPullConstraint is_extra_pull_constraint;\n IsExtraPushConstraint is_extra_push_constraint;\n \n int* counters; ///< global memory holding pixels in \n int* render_indexes; ///< row associated to pixel in the render cloud\n int* sensor_indexes; ///< row associated to pixel in the sensor cloud\n int2* cnstr_indexes;\n \n bool silho_enabled;\n bool depth_enabled;\n bool extra_pull_enabled;\n bool extra_push_enabled;\n int extra_skip_every;\n \n Functor(int* counters, int* render_indexes, int* sensor_indexes, int2* cnstr_indexes) : \n is_depth_constraint(*silhouette_sensor),\n is_sensor_silhouette(*silhouette_sensor)\n {\n this->counters = counters;\n this->render_indexes = render_indexes;\n this->sensor_indexes = sensor_indexes; \n this->cnstr_indexes = cnstr_indexes;\n \n silho_enabled = settings->silho_enable;\n depth_enabled = settings->depth_enable;\n extra_push_enabled = settings->fit2D_enable;\n extra_pull_enabled = settings->fit3D_enable;\n extra_skip_every = settings->fit3D_stepsize;\n }\n\n __device__\n void operator()(MeshGrid::Elem& off){\n ///--- Invalidate constraints\n cnstr_indexes[off.z] = make_int2( PixelType::INVALID, PixelType::INVALID );\n\n ///--- Update counters for tracking failure detection\n\t\t\t{ \n\t\t\t\tbool is_rendered = is_rendered_silhouette(off);\n\t\t\t\tbool is_sensor = is_sensor_silhouette(off);\n if( is_rendered) atomicAdd(&counters[PixelType::RENDER_SILHOUETTE],1);\n if( is_sensor)\tatomicAdd(&counters[PixelType::SENSOR_SILHOUETTE],1);\n if( is_rendered && is_sensor ) atomicAdd(&counters[PixelType::OVERLAP_SILHOUETTE],1);\n if( is_rendered || is_sensor ) atomicAdd(&counters[PixelType::UNION_SILHOUETTE],1);\n }\n \n ///--- Mark constraints\n if( silho_enabled && is_silhouette_boundary(off) ){\n cnstr_indexes[off.z] = make_int2(PixelType::CONSTRAINT_SILHO, atomicAdd(&counters[PixelType::CONSTRAINT_SILHO],1));\n return;\n }\n\n if( depth_enabled && is_depth_constraint(off) && /*for safety only*/ !is_silhouette_boundary(off) ){\n cnstr_indexes[off.z] = make_int2(PixelType::CONSTRAINT_DEPTH, atomicAdd(&counters[PixelType::CONSTRAINT_DEPTH],1));\n return;\n }\n \n ///--- Anything not taken care by depth and silhouette arrives here\n if( extra_pull_enabled && is_extra_pull_constraint(off) ){\n cnstr_indexes[off.z] = make_int2(PixelType::CONSTRAINT_EXTRA_PULL, atomicAdd(&counters[PixelType::CONSTRAINT_EXTRA_PULL],1)); \n return;\n }\n if( extra_push_enabled && is_extra_push_constraint(off) ){\n cnstr_indexes[off.z] = make_int2(PixelType::CONSTRAINT_EXTRA_PUSH, atomicAdd(&counters[PixelType::CONSTRAINT_EXTRA_PUSH],1));\n return;\n }\n }\n };\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/Timer.h",
"content": "/// @note this measures wall clock times, not GPU times!!\n/// You'd need to sync the GPU (at the cost of a stall) to get\n/// the real times\n#pragma once\n\n#include \n#include \n#include \n#include \n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\nstruct Timer {\n clock_t start;\n clock_t end;\n static const size_t buffer_length=256;\n char buffer[buffer_length];\n\n Timer(void) {\n restart(\"\");\n //std::cout << \"!!! WARNING: obsolete, why are you using it?\" << std::endl;\n }\n\n void restart(const char* format, ...) {\n va_list args;\n va_start (args, format);\n /// @note http://www.tin.org/bin/man.cgi?section=3&topic=vsnprintf\n vsnprintf (buffer, buffer_length, format, args);\n va_end (args);\n start = clock();\n }\n\n double elapsed(void) {\n end = clock();\n return static_cast(end - start) / static_cast(CLOCKS_PER_SEC);\n }\n\n double epsilon(void) {\n return 1.0 / static_cast(CLOCKS_PER_SEC);\n }\n\n void display() {\n #ifndef DISABLE_TIMER_PRINTF\n printf(\"[%s]: %.2fms\\n\",buffer,1e3 * elapsed());\n fflush(stdout);\n #endif\n }\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/cuda_glm.h",
"content": "#pragma once\n//#define GLM_COMPILER 0\n#define CUDA_VERSION 7000\n\n#if __unix__\n// GLM wants to redefine these functions, which causes \n// compilation errors in Linux. Undef'ing them WorksForMe...\n#undef isnan\n#undef isinf\n#endif\n\n#include \"glm/glm.hpp\"\n\n/// To access raw pointer: glm::value_ptr(glm_mat4_variable)\n// #include \n"
},
{
"path": "cudax/externs.h",
"content": "#pragma once\n#include \n#include \n#include \n#include \"cudax/cuda_glm.h\"\n#include \n\nnamespace energy{namespace fitting{struct Settings;}}\nstruct CustomJointInfo;\nstruct ChainElement;\ntypedef unsigned char uchar;\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\n///--- Jacobian type\n#define NUM_THETAS 29 ///< hand parameter size (size of jacobian row)\nstruct J_row{ float data[NUM_THETAS]; }; ///< Row of Jacobian\ntypedef thrust::device_vector Jacobian; ///< ROW major!!!\n\n///--- Externally defined resources\nextern cudaArray* render_color;\nextern cudaArray* render_points;\nextern cudaArray* render_normals;\nextern cudaArray* sensor_depth;\nextern cudaArray* sensor_normals;\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n\nextern \"C\"\nvoid kernel_init(energy::fitting::Settings* settings,\n int _width,\n int _height,\n int thetas_size,\n float H_focal_length_x,\n float H_focal_length_y,\n const float *H_inv_proj_matrix);\n\nextern \"C\" void kernel_upload_kinematic(const std::vector& jointinfos, const std::vector& H_kinchains);\nextern \"C\" void kernel_upload_cylinders(const float* H_cylinders);\nextern \"C\" void kernel_upload_sensor_data(uchar* H_silhouette_sensor);\nextern \"C\" void kernel_upload_dtform_idxs(int* H_dtform_idxs);\n\nextern \"C\" void kernel_bind();\nextern \"C\" void kernel(float* eigen_JtJ, float* eigen_Jte, float & push_error, float & pull_error, bool eval_metric, bool reweight);\nextern \"C\" void kernel_unbind();\n\nextern \"C\"\nvoid kernel_copy_extra_corresp(thrust::host_vector& H_queries, \n thrust::host_vector& H_target, \n thrust::host_vector& H_idxs);\n\nextern \"C\"\nvoid kernel_store_closedform_corresp(int num);\n\nextern \"C\"\nvoid kernel_copy_closedform_corresp(thrust::host_vector &H_closedform_corrs);\n\nextern \"C\"\nvoid kernel_cleanup();\n\nextern \"C\"\nvoid kernel_memory_tests();\n\nextern \"C\"\nvoid kernel_constraint_type_image(uchar *, int, int);\n\nextern \"C\"\nvoid kernel_simplify_jacobian();\n\n"
},
{
"path": "cudax/functors/ClosestPoint.h",
"content": "#include \"cudax/kernel.h\"\n#include \"cudax/cuda_glm.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\nstruct ClosestPoint {\n\n float *_data_cylinders; ///< raw\n bool do_backface_check;\n\npublic:\n\n ClosestPoint(){\n _data_cylinders = thrust::raw_pointer_cast(cylinder_segments->data());\n do_backface_check = settings->fit3D_backface_check;\n }\n\n //-------------------------------------------------------------//\n\n __device__\n float SAFE_DOT(glm::vec3 u, glm::vec3 v){\n return u.x*v.x + u.y*v.y + u.z*v.z;\n }\n\n __device__\n float SAFE_LENGTH(glm::vec3 u){\n assert(u.x==u.x);\n return sqrt(u.x*u.x + u.y*u.y + u.z*u.z);\n }\n\n __device__\n glm::vec3 SAFE_NORMALIZE(glm::vec3 v, glm::vec3 fallback){\n glm::vec3 ret = fallback;\n if(SAFE_DOT(v, v) > FLT_MIN)\n ret = glm::normalize(v);\n return ret;\n }\n\n //-------------------------------------------------------------//\n\n __device__\n void line_segment_distance(glm::vec3 point,\n const glm::vec3 &start, const glm::vec3 &end,\n glm::vec3 &p, float &d)\n {\n glm::vec3 d1 = point - start;\n glm::vec3 d2 = end - start;\n glm::vec3 min_v = start;\n\n float t = SAFE_DOT(d2, d2);\n\n if(t > FLT_MIN){\n t = SAFE_DOT(d1, d2) / t;\n if (t > 1.0f) d1 = point - (min_v = end);\n else if (t > 0.0f) d1 = point - (min_v = start + d2*t);\n }\n\n p = min_v;\n assert(d1.x==d1.x);\n d = SAFE_LENGTH(d1);\n }\n\n //-------------------------------------------------------------//\n\n __device__\n void backface_check(glm::vec3 point, glm::vec3 &p,\n const glm::vec3 &n, const glm::vec3 &v,\n const glm::vec3 &start, const glm::vec3 &end,\n float r1, float r2, float r1y, float r2y, float l)\n {\n // check angle between normal and view direction\n float nv = SAFE_DOT(n, v);\n if(nv > 0) return; // point is front-facing\n\n // compute intersection planes\n // normal vectors n*, support vectors s*\n glm::vec3 n1, n2, n3, s1, s2, s3, c, h;\n {\n // start sphere plane\n n1 = n;\n s1 = start;\n\n // end sphere plane\n n2 = n;\n s2 = end;\n\n // cone segment plane\n c = SAFE_NORMALIZE(end - start, v);\n h = SAFE_NORMALIZE(glm::cross(v, c), v);\n n3 = SAFE_NORMALIZE(glm::cross(h, c), n1);\n s3 = start;\n }\n\n // project point to intersection planes\n glm::vec3 p1, p2, p3, o1, o2, o3;\n {\n p1 = point - SAFE_DOT(point - s1, n1) * n1;\n p2 = point - SAFE_DOT(point - s2, n2) * n2;\n p3 = point - SAFE_DOT(point - s3, n3) * n3;\n\n glm::vec3 x(1,0,0), y(0,1,0);\n\n if(fabs(SAFE_DOT(y, n1)) != 1.0f){\n o1 = SAFE_NORMALIZE(y - SAFE_DOT(y, n1) * n1, y);\n }else{\n o1 = SAFE_NORMALIZE(x - SAFE_DOT(x, n1) * n1, y);\n }\n\n if(fabs(SAFE_DOT(y, n2)) != 1.0f){\n o2 = SAFE_NORMALIZE(y - SAFE_DOT(y, n2) * n2, y);\n }else{\n o2 = SAFE_NORMALIZE(x - SAFE_DOT(x, n2) * n2, y);\n }\n\n if(fabs(SAFE_DOT(y, n3)) != 1.0f){\n o3 = SAFE_NORMALIZE(y - SAFE_DOT(y, n3) * n3, y);\n }else{\n o3 = SAFE_NORMALIZE(x - SAFE_DOT(x, n3) * n3, y);\n }\n }\n\n // project onto intersection curves\n glm::vec3 u1, v1, u2, v2, u3, v3;\n {\n // start sphere\n u1 = p1 - s1;\n v1 = SAFE_NORMALIZE(u1, o1) * r1;\n p1 -= u1 - v1;\n\n // end sphere\n u2 = p2 - s2;\n v2 = SAFE_NORMALIZE(u2, o2) * r2;\n p2 -= u2 - v2;\n\n // cone segment\n glm::vec3 s_; float d;\n line_segment_distance(p3, start, end, s_, d);\n glm::vec3 tmp = end-start; assert(tmp.x==tmp.x);\n float le = SAFE_LENGTH(end - start);\n glm::vec3 tmp2 = s_-start; assert(tmp2.x==tmp2.x);\n float lp = SAFE_LENGTH(s_ - start);\n float t = lp / le;\n float r_ = t * r2 + (1 - t) * r1;\n float ry = t * r2y + (1 - t) * r1y;\n float ratio = ry/r_;\n u3 = p3 - s_;\n v3 = SAFE_NORMALIZE(u3, o3) * r_ * ratio;\n p3 -= u3 - v3;\n }\n\n // select closest point to query\n {\n glm::vec3 tmp3 = p1-point; assert(tmp3.x==tmp3.x);\n float d1 = SAFE_LENGTH(p1 - point);\n glm::vec3 tmp4 = p2-point; assert(tmp4.x==tmp4.x);\n float d2 = SAFE_LENGTH(p2 - point);\n glm::vec3 tmp5 = p3-point; assert(tmp5.x==tmp5.x);\n float d3 = SAFE_LENGTH(p3 - point);\n\n p = (d1 < d2) ? ((d1 < d3) ? p1 : p3) : (d2 < d3) ? p2 : p3;\n }\n }\n\n //-------------------------------------------------------------//\n\n __device__\n void cylinder_distance(glm::vec3 point,\n const glm::vec3 &start, const glm::vec3 &end,\n float r1, float r2, float r1y, float r2y, float l,\n const glm::mat4 &T, const glm::mat4 &Ti,\n glm::vec3 &p, glm::vec3 &n, float &d)\n {\n // compute projection on center line segment\n line_segment_distance(point, start, end, p, d);\n\n // interpolate start/end radius\n glm::vec3 tmp1 = end-start; assert(tmp1.x==tmp1.x);\n float le = SAFE_LENGTH(end - start);\n glm::vec3 tmp2 = p-start; assert(tmp2.x==tmp2.x);\n float lp = SAFE_LENGTH(p - start);\n float t = lp / le;\n float r = t * r2 + (1 - t) * r1;\n float ry = t * r2y + (1 - t) * r1y;\n float ratio = ry/r;\n\n // scale from elliptical to circular\n glm::vec3 p0 = point;\n glm::vec3 pt = glm::vec3(Ti * glm::vec4(point, 1));\n pt.x *= ratio;\n point = glm::vec3(T * glm::vec4(pt, 1));\n\n // project onto cylindroid surface\n glm::vec3 view(0,0,-1);\n n = SAFE_NORMALIZE(point - p, -view);\n p += n * r * ratio;\n\n#define ENABLE_BACKFACE_CHECK\n#ifdef ENABLE_BACKFACE_CHECK\n // only allow front-facing points\n if(do_backface_check)\n backface_check(point, p, n, view, start, end, r1, r2, r1y, r2y, l);\n#endif\n\n // unscale from circular to elliptical\n pt = glm::vec3(Ti * glm::vec4(p, 1));\n pt.x /= ratio;\n p = glm::vec3(T * glm::vec4(pt, 1));\n\n // compute correct normal at this point\n pt = glm::vec3(Ti * glm::vec4(n, 0));\n pt.x *= ratio;\n n = SAFE_NORMALIZE(glm::vec3(T * glm::vec4(pt, 0)), -view);\n\n // compute distance\n glm::vec3 tmp3 = p-p0; assert(tmp3.x==tmp3.x);\n if(ratio!=1.0f) d = SAFE_LENGTH(p - p0);\n }\n\n //-------------------------------------------------------------//\n\n __device__\n void closest_point(const float4 &p_sensor, float4 &p_model, float4 &n_model, int &joint_id){\n p_model = p_sensor;\n joint_id = -1;\n float min_dist = FLT_MAX;\n\n for(int i = 0; i < SEGMENT_JOINTS; ++i){\n int id, k = 0;\n glm::vec3 start, end;\n float r1, r2, r1y, r2y, l;\n glm::mat4 T, Ti;\n\n // joint id\n id = (int)_data_cylinders[i*SEGMENT_VALUES + k++];\n if(id == -1) continue;\n\n // start position\n start.x = _data_cylinders[i*SEGMENT_VALUES + k++];\n start.y = _data_cylinders[i*SEGMENT_VALUES + k++];\n start.z = _data_cylinders[i*SEGMENT_VALUES + k++];\n\n // end position\n end.x = _data_cylinders[i*SEGMENT_VALUES + k++];\n end.y = _data_cylinders[i*SEGMENT_VALUES + k++];\n end.z = _data_cylinders[i*SEGMENT_VALUES + k++];\n\n // segment parameters\n r1 = _data_cylinders[i*SEGMENT_VALUES + k++];\n r2 = _data_cylinders[i*SEGMENT_VALUES + k++];\n r1y = _data_cylinders[i*SEGMENT_VALUES + k++];\n r2y = _data_cylinders[i*SEGMENT_VALUES + k++];\n l = _data_cylinders[i*SEGMENT_VALUES + k++];\n\n // joint transform matrices\n for(int j = 0; j < 16; ++j){\n int r = j % 4;\n int c = j / 4;\n T[c][r] = _data_cylinders[i*SEGMENT_VALUES + k];\n Ti[c][r] = _data_cylinders[i*SEGMENT_VALUES + k + 16];\n ++k;\n }\n\n float d;\n glm::vec3 p, n;\n glm::vec3 point(p_sensor.x, p_sensor.y, p_sensor.z);\n cylinder_distance(point, start, end, r1, r2, r1y, r2y, l, T, Ti, p, n, d);\n\n if(d < min_dist){\n min_dist = d;\n joint_id = id;\n\n p_model.x = p.x;\n p_model.y = p.y;\n p_model.z = p.z;\n p_model.w = 0;\n\n n_model.x = n.x;\n n_model.y = n.y;\n n_model.z = n.z;\n n_model.w = 0;\n }\n }\n }\n\n //-------------------------------------------------------------//\n\n __device__\n void relocate_target(float4 &p_sensor, float4 &p_model, float4 &n_model){\n glm::vec3 ps(p_sensor.x, p_sensor.y, p_sensor.z);\n glm::vec3 pm(p_model.x, p_model.y, p_model.z);\n glm::vec3 nm(n_model.x, n_model.y, n_model.z);\n glm::vec3 p = pm + SAFE_DOT(ps - pm, nm) * nm;\n p_sensor.x = p.x;\n p_sensor.y = p.y;\n p_sensor.z = p.z;\n }\n\n //-------------------------------------------------------------//\n\n __device__\n bool is_nan(float4 n){\n return n.x != n.x\n || n.y != n.y\n || n.z != n.z;\n }\n\n //-------------------------------------------------------------//\n\n __device__\n bool is_valid(float4 &p_sensor, float4 &p_model, float4 &n_model, int joint_id){\n return joint_id != -1 && !is_nan(p_sensor) && !is_nan(p_model) && !is_nan(n_model);\n }\n\n //-------------------------------------------------------------//\n\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/functors/ComputeJacobianRow.h",
"content": "#pragma once\n#include \"cudax/kernel.h\"\n#include \"cudax/MeshGrid.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\nclass ComputeJacobianRow : public thrust::unary_function{\nprotected:\n J_row* J_raw; ///< array of rows \n float* e_raw; ///< right hand side (constraints) \n int2* cnstr_indexes; ///< raw\n CustomJointInfo* jointinfos; ///< raw\n ChainElement* chains; ///< raw\npublic:\n ComputeJacobianRow(J_row* J_raw, float* e_raw){\n assert(J_raw!=NULL);\n assert(e_raw!=NULL); \n this->J_raw = J_raw;\n this->e_raw = e_raw;\n this->cnstr_indexes = ::pixel_indexer->cnstr_indexes;\n this->jointinfos = ::kinematic->jointinfos;\n this->chains = ::kinematic->chains;\n }\n\nprotected:\n inline __device__ int type(const MeshGrid::Elem& off){ return cnstr_indexes[off.z].x; }\n inline __device__ int constraint_index(const MeshGrid::Elem& off){ return cnstr_indexes[off.z].y; }\n \n __device__\n glm::mat3x2 projection_jacobian(const glm::vec3& pos){\n // printf(\"focal length: %f\", focal_length);\n glm::mat3x2 M(0); ///< remember column major!\n M[0][0] = focal_length_x / pos[2];\n M[1][1] = focal_length_y / pos[2];\n M[2][0] = -pos[0] * focal_length_x / ( pos[2]*pos[2] );\n M[2][1] = -pos[1] * focal_length_y / ( pos[2]*pos[2] );\n return M;\n }\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/functors/ComputeJacobianRowDepth.h",
"content": "#include \"cudax/kernel.h\"\n#include \"cudax/functors/ImageGradientDepth.h\"\n#include \"cudax/functors/IsMatchingDepth.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\n/// Computes the content of a row of the jacobian\nstruct ComputeJacobianRowDepth : public thrust::unary_function{\n ImageGradientDepth gradient;\n CustomJointInfo* jointinfos; ///< device\n ChainElement* chains; ///< device \n int2* cnstr_indexes; ///< raw\n uchar* silhouette_sensor; ///< raw \n J_row* J_raw; ///< array of rows \n float* e_raw; ///< right hand side (constraints)\n float weight;\n \n ComputeJacobianRowDepth(J_row* J_raw, float* e_raw) :\n J_raw(J_raw), e_raw(e_raw)\n {\n this->jointinfos = kinematic->jointinfos;\n this->chains = kinematic->chains;\n this->cnstr_indexes = pixel_indexer->cnstr_indexes;\n this->silhouette_sensor = thrust::raw_pointer_cast(cudax::silhouette_sensor->data());\n\n weight = settings->depth_weight;\n }\n \n __device__\n glm::mat3x2 projection_jacobian(const glm::vec3& pos){\n // printf(\"focal length: %f\", focal_length); \n glm::mat3x2 M(0); ///< remember column major!\n M[0][0] = focal_length_x / pos[2];\n M[1][1] = focal_length_y / pos[2];\n M[2][0] = -pos[0] * focal_length_x / ( pos[2]*pos[2] );;\n M[2][1] = -pos[1] * focal_length_y / ( pos[2]*pos[2] );;\n return M;\n }\n \n __device__ int type(const MeshGrid::Elem& off){ return cnstr_indexes[off.z].x; }\n __device__ int constraint_index(const MeshGrid::Elem& off){ return cnstr_indexes[off.z].y; }\n \n __device__\n void operator()(MeshGrid::Elem& off){\n if( type(off) != PixelType::CONSTRAINT_DEPTH) return;\n \n int row_index = constraint_index(off);\n J_row* J_sub = J_raw + row_index;\n float* e_sub = e_raw + row_index;\n int joint_id = (int) tex2D(color_tex, off.x, off.y);\n \n ///--- Joint axis\n glm::vec3 pos;\n pos[0] = tex2D(extra_tex, off.x, off.y).x;\n pos[1] = tex2D(extra_tex, off.x, off.y).y;\n pos[2] = tex2D(extra_tex, off.x, off.y).z;\n \n /// Gradient of the depth image\n glm::vec2 grad = gradient(off);\n /// Jacobian of the projection matrix \n glm::mat3x2 J_proj = projection_jacobian(pos);\n \n glm::vec3 projector = grad * J_proj;\n \n ///--- Two depth values\n float d_real = (float) SENSOR_DEPTH(off);\n float d_rend = (float) tex2D(extra_tex, off.x, off.y).z;\n\n// #define DEPTH_RE_WEIGHTING\n#ifdef DEPTH_RE_WEIGHTING\n float weight = std::sqrt( 1 / ( std::abs(d_real-d_rend) + 1e-5 ) );\n#endif\n\n for(int i_column=0; i_columndata[jinfo.index] = weight * ( glm::dot(projector, col) + col.z );\n break;\n }\n case 0: // ROT\n {\n glm::vec3 t(jointinfos[jointinfo_id].mat[3][0],jointinfos[jointinfo_id].mat[3][1],jointinfos[jointinfo_id].mat[3][2]);\n glm::vec3 a = glm::normalize(glm::vec3(jointinfos[jointinfo_id].mat * glm::vec4( axis, 1 )) - t);\n glm::vec3 col = glm::cross(a, pos - t);\n J_sub->data[jinfo.index] = weight * ( glm::dot(projector, col) + col.z );\n break;\n }\n }\n }\n\n ///--- Compute right hand side\n *e_sub = weight * ( d_real-d_rend );\n }\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/functors/ComputeJacobianRowExtraClosedForm.h",
"content": "#include \"cudax/kernel.h\"\n#include \"cudax/MeshGrid.h\"\n#include \"cudax/PixelIndexer.h\"\n#include \"ClosestPoint.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\n/// Computes the content of a row of the jacobian\nstruct ComputeJacobianRowExtraClosedForm : public ComputeJacobianRow{\n const glm::mat3x3& iproj; ///< to compute cloud from depth\n ClosestPoint matcher;\n\n bool debug_store;\n float *debug_correspondences_raw;\n\n float weight;\n bool point_to_plane;\n bool reweight;\n\npublic:\n ComputeJacobianRowExtraClosedForm(J_row* J_raw, float* e_raw, bool reweight) : \n ComputeJacobianRow(J_raw, e_raw), \n iproj( cudax::camera_matrix->D_inv_proj_matrix() )\n {\n point_to_plane = settings->fit3D_point2plane;\n weight = settings->fit3D_weight;\n this->reweight = reweight;\n debug_store = false;\n debug_correspondences_raw = NULL;\n }\n\n void store_data(float *debug_correspondences)\n {\n if(debug_correspondences != NULL){\n debug_store = true;\n debug_correspondences_raw = debug_correspondences;\n } else {\n debug_store = false;\n debug_correspondences_raw = NULL;\n }\n }\n\n ///--- Computes 3D point\n inline __device__ float4 sensor_point_at(const MeshGrid::Elem off){ \n float depth = (float) SENSOR_DEPTH(off);\n glm::vec3 wrld = iproj * glm::vec3( off.x*depth, off.y*depth, depth);\n return make_float4(wrld[0], wrld[1], wrld[2], 0 /*unused*/);\n }\n\n // dot product\n inline __device__ float dot(float2 a, float2 b)\n {\n return a.x * b.x + a.y * b.y;\n }\n inline __device__ float2 difference(float2 a, float2 b)\n {\n return make_float2(a.x - b.x, a.y - b.y);\n }\n \n inline __device__ float4 difference(float4 a, float4 b)\n {\n return make_float4(a.x - b.x, a.y - b.y, a.z - b.z, 0);\n }\n inline __device__ float norm(float4 a)\n {\n return sqrt(a.x*a.x + a.y*a.y + a.z*a.z);\n }\n\n __device__\n float SAFE_DOT(glm::vec3 u, glm::vec3 v){\n return u.x*v.x + u.y*v.y + u.z*v.z;\n }\n\n /// Last argument accesses THREE rows!\n __device__\n void skeleton_jacobian(const int joint_id, const glm::vec3& pos, J_row* sub_J, glm::vec3 nrm=glm::vec3(0), bool project=false){\n for(int i_column=0; i_column jointinfo_id: %d %d\\n\", i_column, jointinfo_id);\n int jointinfo_id = chains[joint_id].data[i_column];\n if(jointinfo_id==-1) break;\n const CustomJointInfo& jinfo = jointinfos[jointinfo_id];\n glm::vec3& axis = jointinfos[jointinfo_id].axis;\n\n glm::vec3 col;\n switch(jinfo.type){\n case 1 /*TRA*/:\n {\n col = glm::vec3( jointinfos[jointinfo_id].mat * glm::vec4( axis, 1 ) );\n break;\n }\n case 0 /*ROT*/:\n {\n glm::vec3 t(jointinfos[jointinfo_id].mat[3][0],jointinfos[jointinfo_id].mat[3][1],jointinfos[jointinfo_id].mat[3][2]);\n glm::vec3 a = glm::normalize(glm::vec3(jointinfos[jointinfo_id].mat * glm::vec4( axis, 1 )) - t);\n col = glm::cross(a, pos - t);\n break;\n }\n }\n\n if(point_to_plane || project){\n sub_J->data[jinfo.index] = weight * SAFE_DOT( col, nrm );\n } else {\n (sub_J+0)->data[jinfo.index] = weight * col[0];\n (sub_J+1)->data[jinfo.index] = weight * col[1];\n (sub_J+2)->data[jinfo.index] = weight * col[2];\n }\n }\n }\n\n __device__\n void operator()(MeshGrid::Elem& off){\n if( type(off) != PixelType::CONSTRAINT_EXTRA_PULL) return;\n // printf(\"processing pixel[%d %d - %d] \\n \", off.x, off.y, off.z);\n\n ///--- Access to a 3xN block of Jacobian\n // printf(\" constraint_index(off): %d\\n\", constraint_index(off));\n J_row* J_sub = J_raw + 3*constraint_index(off);\n float* e_sub = e_raw + 3*constraint_index(off);\n\n float4 p_sensor = sensor_point_at(off);\n\n float4 p_model, n_model;\n int joint_id;\n matcher.closest_point(p_sensor, p_model, n_model, joint_id);\n if(!matcher.is_valid(p_sensor, p_model, n_model, joint_id)) return;\n\n // Project sensor point onto the line along the model point's normal.\n // This relocates the target point such that the corresponding source\n // point is its orthogonal projection onto the model, which stabilizes\n // the solution at the expense of slightly wrong target positions.\n // (Note: this is only relevant for palm segment constraints!)\n matcher.relocate_target(p_sensor, p_model, n_model);\n\n if(debug_store){\n#if 0\n debug_correspondences_raw[6 * constraint_index(off) + 0] = p_model.x + 10*n_model.x;\n debug_correspondences_raw[6 * constraint_index(off) + 1] = p_model.y + 10*n_model.y;\n debug_correspondences_raw[6 * constraint_index(off) + 2] = p_model.z + 10*n_model.z;\n#else\n debug_correspondences_raw[6 * constraint_index(off) + 0] = p_sensor.x;\n debug_correspondences_raw[6 * constraint_index(off) + 1] = p_sensor.y;\n debug_correspondences_raw[6 * constraint_index(off) + 2] = p_sensor.z;\n#endif\n debug_correspondences_raw[6 * constraint_index(off) + 3] = p_model.x;\n debug_correspondences_raw[6 * constraint_index(off) + 4] = p_model.y;\n debug_correspondences_raw[6 * constraint_index(off) + 5] = p_model.z;\n }\n\n //printf(\" p_model: %f %f %f %f\\n\", p_model.x, p_model.y, p_model.z, p_model.w);\n //printf(\" joint_id: %d\\n\", joint_id);\n\n if(reweight){\n float d = norm(difference(p_sensor, p_model));\n //float w = sqrt(1.0f / (d + 1e-3));\n float w = rsqrt(d + 1e-3);\n if(d > 1e-3) weight *= w * 3.5f;\n // factor 3.5 compensates for residual magnitude change\n }\n \n if(point_to_plane){\n ///--- Fills LHS\n float4 n = n_model;\n //float4 n = SENSOR_NORMALS(off);\n //if( isnan(n.x) || isnan(n.y) || isnan(n.z) ) printf(\"ERROR: %f %f %f %f\\n\",n.x, n.y, n.z, n.w);\n glm::vec3 normal(n.x, n.y, n.z);\n skeleton_jacobian(joint_id, glm::vec3(p_model.x, p_model.y, p_model.z), J_sub, normal);\n ///--- Fills RHS\n glm::vec3 residual(p_sensor.x-p_model.x, p_sensor.y-p_model.y, p_sensor.z-p_model.z);\n *e_sub = weight * SAFE_DOT( residual, normal );\n } else {\n skeleton_jacobian(joint_id, glm::vec3(p_model.x, p_model.y, p_model.z), J_sub);\n e_sub[0] = weight * ( p_sensor.x - p_model.x );\n e_sub[1] = weight * ( p_sensor.y - p_model.y );\n e_sub[2] = weight * ( p_sensor.z - p_model.z );\n }\n }\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/functors/ComputeJacobianRowPush.h",
"content": "#pragma once\n#include \"ComputeJacobianRow.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\nclass ComputeJacobianRowPush : public ComputeJacobianRow{\nprivate:\n ///--- These are for the extra_push\n int* sensor_dtform_idxs;\n float weight;\npublic:\n ComputeJacobianRowPush(J_row* J_raw, float* e_raw) : ComputeJacobianRow(J_raw, e_raw){\n this->sensor_dtform_idxs = thrust::raw_pointer_cast(::sensor_dtform_idxs->data());\n weight = settings->fit2D_weight;\n \n assert(cudax::render_color!=NULL);\n assert(render_points!=NULL);\n }\n \npublic:\n __device__\n void operator()(MeshGrid::Elem& off){\n if( type(off) != PixelType::CONSTRAINT_EXTRA_PUSH) return;\n \n int row_index = constraint_index(off);\n J_row* J_sub = J_raw + row_index;\n float* e_sub = e_raw + row_index;\n \n int joint_id = (int) tex2D(color_tex, off.x, off.y);\n \n ///--- Fetch closest point on sensor data\n int closest_idx = sensor_dtform_idxs[off.z];\n int row = closest_idx / width;\n int col = closest_idx - width*row;\n glm::vec2 p_rend(off.x, off.y);\n glm::vec2 p_sens(col, row);\n glm::vec2 p_diff = p_sens-p_rend;\n\n//#define PAD_DISTANCE_TRANSFORM\n#ifdef PAD_DISTANCE_TRANSFORM\n float threshold = 3.0f;\n float l_orig = glm::length(p_diff);\n if(l_orig < threshold)\n p_diff = glm::vec2(0);\n else\n p_diff *= (l_orig - threshold) / l_orig;\n#endif\n \n /// Fills LHS \n glm::vec3 p_rend_3D;\n p_rend_3D[0] = tex2D(extra_tex, off.x, off.y).x;\n p_rend_3D[1] = tex2D(extra_tex, off.x, off.y).y;\n p_rend_3D[2] = tex2D(extra_tex, off.x, off.y).z;\n \n glm::mat3x2 J_proj = projection_jacobian(p_rend_3D);\n // skeleton_jacobian(joint_id, p_rend_3D, J_sub, projector, true);\n \n// #define BIAS_PALM_SILHO\n#ifdef BIAS_PALM_SILHO\n int weight = this->weight;\n if(joint_id==3)\n weight = this->weight/**10*/;\n else\n weight = 0; //this->weight;\n#endif\n \n ///--- Compute LHS\n for(int i_column=0; i_columndata[jinfo.index] = weight * jcol.x;\n (J_sub+1)->data[jinfo.index] = weight * jcol.y;\n break;\n }\n case 0: // ROT\n {\n glm::vec3 t(jointinfos[jointinfo_id].mat[3][0],jointinfos[jointinfo_id].mat[3][1],jointinfos[jointinfo_id].mat[3][2]);\n glm::vec3 a = glm::normalize(glm::vec3(jointinfos[jointinfo_id].mat * glm::vec4( axis, 1 )) - t);\n glm::vec3 col = glm::cross(a, p_rend_3D - t);\n glm::vec2 jcol = J_proj * col;\n (J_sub+0)->data[jinfo.index] = weight * jcol.x;\n (J_sub+1)->data[jinfo.index] = weight * jcol.y; \n break;\n }\n }\n }\n \n /// Fills RHS\n *(e_sub+0) = weight * p_diff.x;\n *(e_sub+1) = weight * p_diff.y;\n }\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/functors/ComputeJacobianRowSilho.h",
"content": "#include \"cudax/kernel.h\"\n#include \"cudax/functors/ImageGradient.h\"\n#include \"cudax/Kinematic.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\n/// Computes the content of a row of the jacobian\nstruct ComputeJacobianRowSilho : public thrust::unary_function{\n ImageGradient gradient;\n CustomJointInfo* jointinfos; ///< device\n ChainElement* chains; ///< device \n int2* cnstr_indexes; ///< raw\n uchar* silhouette_sensor; ///< raw\n J_row* J_raw; ///< array of rows \n float* e_raw; ///< right hand side (constraints)\n float weight;\n \n ComputeJacobianRowSilho(J_row* J_raw, float* e_raw) :\n J_raw(J_raw), e_raw(e_raw)\n {\n this->jointinfos = kinematic->jointinfos;\n this->chains = kinematic->chains;\n this->cnstr_indexes = pixel_indexer->cnstr_indexes;\n this->silhouette_sensor = thrust::raw_pointer_cast(cudax::silhouette_sensor->data());\n \n weight = settings->silho_weight;\n }\n \n __device__\n glm::mat3x2 projection_jacobian(const glm::vec3& pos){\n // printf(\"focal length: %f\", focal_length);\n glm::mat3x2 M(0); ///< remember column major!\n M[0][0] = focal_length_x / pos[2];\n M[1][1] = focal_length_y / pos[2];\n M[2][0] = -pos[0] * focal_length_x / ( pos[2]*pos[2] );\n M[2][1] = -pos[1] * focal_length_y / ( pos[2]*pos[2] );\n return M;\n }\n \n __device__ int type(const MeshGrid::Elem& off){ return cnstr_indexes[off.z].x; }\n __device__ int constraint_index(const MeshGrid::Elem& off){ return cnstr_indexes[off.z].y; } \n \n __device__\n void operator()(MeshGrid::Elem& off){\n if( type(off) != PixelType::CONSTRAINT_SILHO) return;\n \n int row_index = constraint_index(off);\n J_row* J_sub = J_raw + row_index;\n float* e_sub = e_raw + row_index;\n int joint_id = (int) tex2D(color_tex, off.x, off.y);\n \n ///--- Joint axis\n glm::vec3 pos;\n pos[0] = tex2D(extra_tex, off.x, off.y).x;\n pos[1] = tex2D(extra_tex, off.x, off.y).y;\n pos[2] = tex2D(extra_tex, off.x, off.y).z;\n \n /// Gradient of the silhouette image\n glm::vec2 grad = gradient(off);\n /// Jacobian of the projection matrix \n glm::mat3x2 J_proj = projection_jacobian(pos);\n \n glm::vec3 projector = grad * J_proj;\n \n int Ss = (silhouette_sensor[off.z]>125); \n int Sr = (joint_id<255); ///< white is BG\n\n#define SKIP_INSIDE_CONSTRAINTS\n#ifdef SKIP_INSIDE_CONSTRAINTS\n if(Ss==true)\n return; \n#endif\n\n ///--- Compute RHS\n *e_sub = weight*(Ss-Sr);\n \n ///--- Compute LHS\n for(int i_column=0; i_columndata[jinfo.index] = weight * glm::dot(projector, col);\n break;\n }\n case 0: // ROT\n {\n glm::vec3 t(jointinfos[jointinfo_id].mat[3][0],jointinfos[jointinfo_id].mat[3][1],jointinfos[jointinfo_id].mat[3][2]);\n glm::vec3 a = glm::normalize(glm::vec3(jointinfos[jointinfo_id].mat * glm::vec4( axis, 1 )) - t);\n glm::vec3 col = glm::cross(a, pos - t);\n J_sub->data[jinfo.index] = weight * glm::dot(projector, col);\n break;\n }\n }\n }\n }\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/functors/CopyOver.h",
"content": "// #include \"cudax/kernel.h\"\n#include \"cudax/OpenCVOutputBuffer.h\"\n#include \"cudax/MeshGrid.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\n/// http://docs.thrust.googlecode.com/hg/structthrust_1_1unary__function.html\nstruct CopyOver : public thrust::unary_function{\n enum MODE{_color, _idxs} mode;\n uchar* out;\n float width, height;\n CopyOver(uchar* out, int width, int height):out(out),width(width),height(height){}\n \n __device__\n void operator()(int4 off){\n switch(mode){\n case _color: out[off.z] = tex2D(color_tex, off.x, off.y); break; ///< Simply copies in to out \n case _idxs: out[off.z] = off.w*255/counter; break; ///< see correct indexes \n }\n\n // out[off.z] = tex2D(extra_tex, off.x, off.y).x; ///< test \n // out[off.z] = tex2D(depth_tex, off.x, off.y).x; ///< test \n // out[off.z] = (off.x/width)*255; ///< print x coords\n // out[off.z] = (off.y/height)*255; ///< print y coords \n } \n \n static void copyover(MeshGrid* meshgrid, uchar* output, CopyOver::MODE mode){\n OpenCVOutputBuffer _output(output, meshgrid->width, meshgrid->height);\n CopyOver functor(_output.get(), meshgrid->width, meshgrid->height);\n functor.mode = mode;\n thrust::for_each(meshgrid->begin(), meshgrid->end(), functor);\n }\n static void color(MeshGrid* meshgrid, uchar* output){copyover(meshgrid, output, _idxs);}\n static void idxs(MeshGrid* meshgrid, uchar* output){copyover(meshgrid, output, _color);}\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/functors/ImageGradient.h",
"content": "#include \"cudax/kernel.h\"\n#include \"cudax/functors/IsSilhouette.h\"\n#include \"cudax/cuda_glm.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\n///--- anonymous so it's not exposed outside\nnamespace { __constant__ float gradient_kernel[3][3]; }\n\nstruct ImageGradient{\n IsRenderedSilhouette is_silhouette; ///< @todo this might be changed with other functors if needed\n \n ImageGradient(){\n ///--- Initialization of constant memory\n float sobel[3][3] = {{-1, 0, 1}, {-2, 0, 2}, {-1, 0, 1}};\n cudaMemcpyToSymbol(gradient_kernel, sobel, 9*sizeof(float));\n }\n\n __device__\n glm::vec2 operator()(const MeshGrid::Elem& off){\n glm::vec2 ret;\n \n // printf(\"kernel gradient: \\n\");\n #pragma unroll\n for(int i = -1; i <= 1; ++i){\n #pragma unroll \n for(int j = -1; j <= 1; ++j){\n int x = off.x+i;\n int y = off.y+j;\n float value = (float) is_silhouette(x,y);\n ret[0] += gradient_kernel[i+1][j+1] * value;\n ret[1] += gradient_kernel[j+1][i+1] * value;\n // printf(\"%d \", is_silhouette(x,y)); \n }\n // printf(\"\\n\");\n }\n if(glm::dot(ret,ret) < 0.1f){\n return glm::vec2(0,0);\n } else {\n ret = glm::normalize(ret);\n }\n \n#define ENABLE_MATCH_CPU_GRADIENT\n#ifdef ENABLE_MATCH_CPU_GRADIENT\n float tmp = -ret[0];\n ret[0] = -ret[1];\n ret[1] = tmp;\n#endif\n \n return ret;\n }\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/functors/ImageGradientDepth.h",
"content": "#pragma once\n#include \"cudax/kernel.h\"\n#include \"cudax/cuda_glm.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\n///--- anonymous so it's not exposed outside\nnamespace { __constant__ float gradient_kernel_depth[3][3]; }\n\nstruct ImageGradientDepth{\n ImageGradientDepth(){\n ///--- Initialization of constant memory\n float sobel[3][3] = {{-1, 0, 1}, {-2, 0, 2}, {-1, 0, 1}};\n cudaMemcpyToSymbol(gradient_kernel_depth, sobel, 9*sizeof(float));\n }\n\n __device__\n glm::vec2 operator()(const MeshGrid::Elem& off){\n glm::vec2 ret;\n \n // printf(\"kernel gradient: \\n\");\n #pragma unroll\n for(int i = -1; i <= 1; ++i){\n #pragma unroll \n for(int j = -1; j <= 1; ++j){\n int x = off.x+i;\n int y = off.y+j;\n float value = (float)tex2D(extra_tex, x, y).z;\n ret[0] += gradient_kernel_depth[i+1][j+1] * value;\n ret[1] += gradient_kernel_depth[j+1][i+1] * value;\n // printf(\"%d \", is_silhouette(x,y)); \n }\n // printf(\"\\n\");\n }\n //ret = glm::normalize(ret);\n \n#define ENABLE_MATCH_CPU_GRADIENT\n#ifdef ENABLE_MATCH_CPU_GRADIENT\n float tmp = -ret[0];\n ret[0] = -ret[1]/8.0f;\n ret[1] = tmp/8.0f;\n#endif\n \n return ret;\n }\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/functors/ImageHighlighter.h",
"content": "#pragma once\n#include \"cudax/kernel.h\"\n#include \"cudax/functors/IsSilhouetteBoundary.h\"\n#include \"cudax/functors/IsSilhouette.h\"\n#include \"cudax/OpenCVOutputBuffer.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\ntemplate \nstruct ImageHighlighter{\n MeshGridElemBoolFunctor condition;\n uchar* out;\n ImageHighlighter(OpenCVOutputBuffer& opencv){\n out = opencv.get(); \n }\n \n __device__\n void operator()(MeshGrid::Elem& off){\n if(condition(off))\n out[off.z] = 255;\n else\n out[off.z] = 0;\n }\n};\n\n/// Specializations\ntypedef ImageHighlighter SilhouetteBoundaryHighlighter;\ntypedef ImageHighlighter SilhouetteHighlighter;\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/functors/IsMatchingDepth.h",
"content": "#pragma once\n#include \"cudax/kernel.h\"\n#include \"IsSilhouette.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\n//== NAMESPACE ================================================================\nnamespace hidden {\n//=============================================================================\n\nstruct IsMatchingDepth{\n float z_th;\n IsMatchingDepth(){\n z_th = settings->depth_z_th; \n }\n\n __device__ \n bool operator()(const int4& off){\n float d_real = (float)SENSOR_DEPTH(off);\n float d_rend = (float)RENDER_DEPTH(off);\n float diff = fabs(d_real - d_rend);\n \n/// This is the one used by chen_cvpr14\n//#define ENABLE_OCCLUSION_ENERGY\n#ifdef ENABLE_OCCLUSION_ENERGY\n if(d_rend& silhouette_sensor) : \n test_1(silhouette_sensor){}\n\n __device__\n bool operator()(const int4& off){\n return test_1(off) && test_2(off);\n }\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/functors/IsSilhouette.h",
"content": "#pragma once\n#include \"cudax/kernel.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\nstruct IsRenderedSilhouette{\n __device__\n bool operator()(const int4& off){\n return (tex2D(color_tex, off.x, off.y)<255);\n }\n __device__\n bool operator()(int x, int y){\n return (tex2D(color_tex, x, y)<255);\n }\n};\n\nstruct IsSensorSilhouette{\n uchar* silhouette_sensor;\n IsSensorSilhouette(thrust::device_vector& silhouette_sensor){\n this->silhouette_sensor = thrust::raw_pointer_cast(&silhouette_sensor[0]);\n }\n\n __device__\n bool operator()(const int4& off){\n return (silhouette_sensor[off.z] > 125);\n }\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/functors/IsSilhouetteBoundary.h",
"content": "#pragma once\n#include \"cudax/kernel.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\nstruct IsSilhouetteBoundary{\n __device__\n bool operator()(const int4 off){\n uchar p0 = tex2D(color_tex, off.x, off.y);\n\n /// Don't bother processing outside pixels\n if(p0==255) {\n return false;\n }\n \n /// Inside pixels, keep only the ones that see outside \n for(int i= -1; i<=1; i++){\n for(int j=-1; j<=1; j++){\n if( tex2D(color_tex,off.x+i,off.y+j)==255 )\n return true;\n }\n }\n \n /// This one didn't see any outside\n return false;\n }\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n"
},
{
"path": "cudax/functors/IsTopLeft3x3Block.h",
"content": "#pragma once\n#include \"cudax/kernel.h\"\n\n//== NAMESPACE ================================================================\nnamespace cudax {\n//=============================================================================\n\nstruct IsTopLeft3x3Block : public thrust::unary_function{\n __device__\n bool operator()(MeshGrid::Elem off){\n return ((off.x<3) && (off.y<3));\n }\n};\n\n//=============================================================================\n} // namespace cudax\n//=============================================================================\n\n\n\n\n"
},
{
"path": "cudax/functors/SkeletonJacobian.h",
"content": "#pragma once\n#include