gproshan pi v3.14 new version coming: updating GUI, new features, ray tracing

.github/workflows/build.yml

@@ -0,0 +1,71 @@
+name: Build
+
+on: [push]
+
+env:
+  CUDA_BIN: /usr/local/cuda/bin
+
+jobs:
+  build:
+    name: ${{ matrix.os }} (${{ matrix.config }}) ${{ matrix.cuda }}
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-20.04]
+        config: [Release, Debug]
+        cuda: [cuda, '']
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Install Dependencies
+      run: |
+        sudo apt remove --purge cmake
+        sudo snap install cmake --classic
+        sudo apt update
+        sudo apt install \
+                          libarmadillo-dev \
+                          libeigen3-dev \
+                          libcgal-dev \
+                          libsuitesparse-dev \
+                          libopenblas-dev \
+                          libglew-dev \
+                          libglfw3-dev \
+                          libglm-dev \
+                          cimg-dev
+
+    - name: Install Cuda
+      if: matrix.cuda == 'cuda'
+      run: |
+        wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/cuda-ubuntu2004.pin
+        sudo mv cuda-ubuntu2004.pin /etc/apt/preferences.d/cuda-repository-pin-600
+        sudo apt-key adv --fetch-keys https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/7fa2af80.pub
+        sudo add-apt-repository "deb https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2004/x86_64/ /"
+        sudo apt update
+        sudo apt -y install cuda
+
+    - name: Create Build Environment
+      # Some projects don't allow in-source building, so create a separate build directory
+      # We'll use this as our working directory for all subsequent commands
+      run: cmake -E make_directory ${{runner.workspace}}/build
+
+    - name: Configure CMake
+      # Use a bash shell so we can use the same syntax for environment variable
+      # access regardless of the host operating system
+      shell: bash
+      working-directory: ${{runner.workspace}}/build
+      # Note the current convention is to use the -S and -B options here to specify source 
+      # and build directories, but this is only available with CMake 3.13 and higher.  
+      # The CMake binaries on the Github Actions machines are (as of this writing) 3.12
+      run: |
+        export PATH=${CUDA_BIN}:${PATH}
+        cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=${{ matrix.config }}
+
+    - name: Build
+      working-directory: ${{runner.workspace}}/build
+      shell: bash
+      # Execute the build.  You can specify a specific target with "--target <NAME>"
+      run: cmake --build . --config ${{ matrix.config }}
+

.gitignore

@@ -8,3 +8,5 @@ tmp/*
 *.user
 .vscode/*
 .DS_Store
+
+src/.vscode/settings.json

CHANGELOG.md

@@ -0,0 +1,11 @@
+Version History
+---------------
+
+### gproshan 3.0.0
+- Upgraded version of the sparse mesh coding with feature aware sampling module and published paper reference.
+- Updated save mesh with options for file types, normals, and point-cloud.
+- Added render option using [Embree](https://www.embree.org/) ray tracing.
+- Implemented the loading and rendering of point-clouds.
+- Added heatmap viewer options and loading vertex color from a file.
+- New user interface implemented with [ImGui](https://github.com/ocornut/imgui).
+- Viewer upgraded using GLEW, GLFW, and GLM.

CMakeLists.txt

@@ -1,77 +1,117 @@
-cmake_minimum_required(VERSION 3.12)
+cmake_minimum_required(VERSION 3.18)
 
-project(gproshan VERSION 2.0 LANGUAGES CXX)
+project(gproshan VERSION 3.0)
 
 list(APPEND CMAKE_MODULE_PATH "${gproshan_SOURCE_DIR}/cmake")
 
-find_package(CUDA 10.1)
-if(CUDA_FOUND)
+if(NOT CMAKE_BUILD_TYPE)
+	set(CMAKE_BUILD_TYPE Release)
+endif()
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+find_package(CUDAToolkit 11)
+if(CUDAToolkit_FOUND)
 	enable_language(CUDA)
-endif(CUDA_FOUND)
+	set(CMAKE_CUDA_STANDARD 17)
+	set(CMAKE_CUDA_STANDARD_REQUIRED ON)
+
+	add_definitions(-DGPROSHAN_CUDA)
+	include_directories(${CUDAToolkit_INCLUDE_DIRS})
+
+	find_package(OptiX 7.1)
+	if(OptiX_INCLUDE)
+		set(CUDA_HOST_COMPILER ${CMAKE_CUDA_HOST_COMPILER})
+		add_definitions(-DGPROSHAN_OPTIX)
+		include_directories(${OptiX_INCLUDE})
+	endif(OptiX_INCLUDE)
+endif(CUDAToolkit_FOUND)
+
+
+find_package(embree 3.10)
+if(embree_FOUND)
+	add_definitions(-DGPROSHAN_EMBREE)
+	include_directories(${embree_INCLUDE_DIRS})
+endif(embree_FOUND)
+
 
 find_package(Threads REQUIRED)
 find_package(OpenMP REQUIRED)
 find_package(OpenGL REQUIRED)
-find_package(GLEW REQUIRED)
-find_package(GLUT REQUIRED)
+find_package(GLEW 2 REQUIRED)
+find_package(glfw3 3 REQUIRED)
+find_package(glm REQUIRED)
 find_package(X11 REQUIRED)
 find_package(Armadillo REQUIRED)
 find_package(CGAL REQUIRED)
 find_package(Eigen3 REQUIRED)
 find_package(SuiteSparse REQUIRED)
+find_package(Boost COMPONENTS thread system)
 
-if(NOT CMAKE_BUILD_TYPE)
-	set(CMAKE_BUILD_TYPE Release)
-endif()
-
-set(CMAKE_CXX_FLAGS "-fopenmp -Wall -Wno-unused-result")
-set(CMAKE_CUDA_FLAGS "-Xcompiler -fopenmp")
 
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 
-add_definitions(${EIGEN3_DEFINITIONS})
-
-# ARMA warning ARMA_ALLOW_FAKE_GCC with g++-9
-add_definitions(-DARMA_ALLOW_FAKE_GCC)
-
-if(CUDA_FOUND)
-	add_definitions(-DGPROSHAN_CUDA)
-	include_directories(${CUDA_INCLUDE_DIRS})
-endif(CUDA_FOUND)
 
 include_directories(${OPENGL_INCLUDE_DIR})
 include_directories(${GLEW_INCLUDE_DIRS})
-include_directories(${GLUT_INCLUDE_DIR})
+include_directories(${GLFW3_INCLUDE_DIRS})
 include_directories(${X11_INCLUDE_DIR})
 include_directories(${AMADILLO_INCLUDE_DIR})
 include_directories(${EIGEN3_INCLUDE_DIR})
 include_directories(${SuiteSparse_INCLUDE_DIRS})
 include_directories(${CGAL_INCLUDE_DIRS})
 
 include_directories(${gproshan_SOURCE_DIR}/include)
-include_directories(${gproshan_SOURCE_DIR}/include/viewer)
-include_directories(${gproshan_SOURCE_DIR}/include/mdict)
-include_directories(${gproshan_SOURCE_DIR}/include/cuda)
+include_directories(${gproshan_SOURCE_DIR}/imgui)
+
+FILE(GLOB_RECURSE imgui_sources ${gproshan_SOURCE_DIR}/imgui/*.cpp)
+add_library(imgui STATIC ${imgui_sources})
+
+set(ptx_code "")
+if(OptiX_INCLUDE)
+	cuda_compile_ptx(ptx_files "${gproshan_SOURCE_DIR}/src/raytracing/rt_optix.cu")
+	list(GET ptx_files 0 ptx_file)
+	set(ptx_code ptx_code.c)
+	add_custom_command(	OUTPUT ${ptx_code} 
+						COMMAND bin2c --const --padd 0 --type char --name ptx_code ${ptx_file} > ${ptx_code}
+						DEPENDS ${ptx_file} 
+						)
+endif(OptiX_INCLUDE)
 
 FILE(GLOB_RECURSE cpp_sources ${gproshan_SOURCE_DIR}/src/*.cpp)
-add_library(gproshan_cpp STATIC ${cpp_sources})
+add_library(gproshan_cpp STATIC ${cpp_sources} ${ptx_code})
 
-target_link_libraries(gproshan_cpp ${OpenMP_CXX_LIBRARIES})
-target_link_libraries(gproshan_cpp ${OPENGL_LIBRARIES})
-target_link_libraries(gproshan_cpp ${GLEW_LIBRARIES})
-target_link_libraries(gproshan_cpp ${GLUT_LIBRARIES})
+target_compile_options(gproshan_cpp PRIVATE -Wall -Wno-unused-result)
+
+target_link_libraries(gproshan_cpp OpenMP::OpenMP_CXX)
+target_link_libraries(gproshan_cpp OpenGL::GL)
+target_link_libraries(gproshan_cpp GLEW::GLEW)
+target_link_libraries(gproshan_cpp glfw)
 target_link_libraries(gproshan_cpp ${X11_X11_LIB})
 target_link_libraries(gproshan_cpp ${ARMADILLO_LIBRARIES})
-target_link_libraries(gproshan_cpp CGAL::CGAL)
 target_link_libraries(gproshan_cpp ${SuiteSparse_LIBRARIES})
+target_link_libraries(gproshan_cpp CGAL::CGAL)
+target_link_libraries(gproshan_cpp ${OptiX_LIBRARY})
+target_link_libraries(gproshan_cpp imgui)
 
-if(CUDA_FOUND)
+if(embree_FOUND)
+	target_link_libraries(gproshan_cpp embree)
+endif(embree_FOUND)
+
+if(CUDAToolkit_FOUND)
 	FILE(GLOB_RECURSE cu_sources ${gproshan_SOURCE_DIR}/src/*.cu)
 	add_library(gproshan_cu STATIC ${cu_sources})
+	target_compile_options(gproshan_cu PRIVATE -Xcompiler -fopenmp)
 	set_target_properties(gproshan_cu PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
+	set_property(TARGET gproshan_cu PROPERTY CUDA_ARCHITECTURES 52 53 60 61 62 70 72 75 80)
+
 	target_link_libraries(gproshan_cu gproshan_cpp)
-	target_link_libraries(gproshan_cu ${CUDA_LIBRARIES} ${CUDA_cublas_LIBRARY} ${CUDA_cusolver_LIBRARY} ${CUDA_cusparse_LIBRARY})
-endif(CUDA_FOUND)
+	target_link_libraries(gproshan_cu CUDA::cudart)
+	target_link_libraries(gproshan_cu CUDA::cublas)
+	target_link_libraries(gproshan_cu CUDA::cusolver)
+	target_link_libraries(gproshan_cu CUDA::cusparse)
+endif(CUDAToolkit_FOUND)
 
 add_executable(gproshan gproshan.cpp)
 add_executable(test_geodesics test_geodesics.cpp)
@@ -81,11 +121,11 @@ target_link_libraries(gproshan gproshan_cpp)
 target_link_libraries(test_geodesics gproshan_cpp)
 target_link_libraries(test_image_denoising gproshan_cpp)
 
-if(CUDA_FOUND)
+if(CUDAToolkit_FOUND)
 	target_link_libraries(gproshan gproshan_cu)
 	target_link_libraries(test_geodesics gproshan_cu)
 	target_link_libraries(test_image_denoising gproshan_cu)
-endif(CUDA_FOUND)
+endif(CUDAToolkit_FOUND)
 
 file(MAKE_DIRECTORY tmp)