alicevision · simogasp · Aug 16, 2016 · Aug 16, 2016 · Aug 16, 2016 · Aug 16, 2016
diff --git a/.gitignore b/.gitignore
@@ -38,6 +38,9 @@ popsift/playground/try-libav
 *.out
 *.app
 
+# Support files
+*.nvvp
+
 # Temporary files
 .DS_Store
 
diff --git a/.travis.yml b/.travis.yml
@@ -10,17 +10,28 @@ cache:
 addons:
   apt:
     packages:
-      - libboost-filesystem-dev 
-      - libboost-system-dev 
+      - libboost-filesystem1.55-dev 
+      - libboost-system1.55-dev
+      - libboost-program-options1.55-dev
+      - libboost-thread1.55-dev
 
 env:
+  matrix:
+    - CUDA_VERSION_MAJOR="7" CUDA_VERSION_MINOR="0" CUDA_PKG_LONGVERSION="${CUDA_VERSION_MAJOR}.${CUDA_VERSION_MINOR}-28" CUDA_PKG_VERSION="${CUDA_VERSION_MAJOR}-${CUDA_VERSION_MINOR}"
+    - CUDA_VERSION_MAJOR="7" CUDA_VERSION_MINOR="5" CUDA_PKG_LONGVERSION="${CUDA_VERSION_MAJOR}.${CUDA_VERSION_MINOR}-18" CUDA_PKG_VERSION="${CUDA_VERSION_MAJOR}-${CUDA_VERSION_MINOR}"
+    - CUDA_VERSION_MAJOR="8" CUDA_VERSION_MINOR="0" CUDA_PKG_LONGVERSION="${CUDA_VERSION_MAJOR}.${CUDA_VERSION_MINOR}.61-1" CUDA_PKG_VERSION="${CUDA_VERSION_MAJOR}-${CUDA_VERSION_MINOR}" 
+
   global:
     - NUM_CPU="`grep processor /proc/cpuinfo | wc -l`"; echo $NUM_CPU
     - BUILD_TYPE="RELEASE"
     - BUILD_SYSTEM="`uname -s`"
     - BUILD_PROCESSOR="`uname -p`"
     - POPSIFT_SOURCE=${TRAVIS_BUILD_DIR}
     - POPSIFT_BUILD=${TRAVIS_BUILD_DIR}/build
+    - POPSIFT_INSTALL=${POPSIFT_BUILD}/install
+    - POPSIFT_APP_SRC=${POPSIFT_SOURCE}/src/application
+    - POPSIFT_APP_BUILD=${POPSIFT_APP_SRC}/build
+    - POPSIFT_APP_INSTALL=${POPSIFT_APP_BUILD}/install
     # CMAKE
     # - CMAKE_URL="https://cmake.org/files/v3.6/cmake-3.6.1-Linux-x86_64.tar.gz"
     - CMAKE_URL="https://cmake.org/files/v3.4/cmake-3.4.1-Linux-x86_64.tar.gz"
@@ -46,30 +57,34 @@ before_install:
     fi
 
 install:
-  - CUDA_REPO_PKG=cuda-repo-ubuntu1404_7.5-18_amd64.deb
+  - CUDA_REPO_PKG=cuda-repo-ubuntu1404_${CUDA_PKG_LONGVERSION}_amd64.deb
   - wget http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1404/x86_64/$CUDA_REPO_PKG
   - sudo dpkg -i $CUDA_REPO_PKG
-  - rm $CUDA_REPO_PKG
+  - rm ${CUDA_REPO_PKG}
   - sudo apt-get -y update
-  - CUDA_PKG_VERSION="7-5"
-  - CUDA_VERSION="7.5"
   - sudo apt-get install -y --no-install-recommends  cuda-core-$CUDA_PKG_VERSION  cuda-cudart-dev-$CUDA_PKG_VERSION  cuda-cublas-dev-$CUDA_PKG_VERSION cuda-curand-dev-$CUDA_PKG_VERSION
-  - sudo ln -s /usr/local/cuda-$CUDA_VERSION /usr/local/cuda
+  - sudo ln -s /usr/local/cuda-${CUDA_VERSION_MAJOR}.${CUDA_VERSION_MINOR} /usr/local/cuda
 
 before_script:
   # Create build folder
-  - mkdir $POPSIFT_BUILD
-  - cd $POPSIFT_BUILD
+  - mkdir -p ${POPSIFT_BUILD}
+  - cd ${POPSIFT_BUILD}
   # Classic release build
   - >
-     cmake . $POPSIFT_SOURCE
+     cmake . ${POPSIFT_SOURCE} -DCMAKE_INSTALL_PREFIX=${POPSIFT_INSTALL}
 
 script:
 # limit GCC builds to a reduced number of thread for the virtual machine
-  - make -j 2 VERBOSE=1
+  - make install -j 2 VERBOSE=1
 # Perform unit tests
   # - make test
+# Perform tests building application with PopSift as 3rd party
+  - cd ${POPSIFT_APP_SRC}
+  - mkdir -p ${POPSIFT_APP_BUILD}
+  - cd ${POPSIFT_APP_BUILD}
+  - cmake .. -DPopSift_DIR=${POPSIFT_INSTALL}/lib/cmake/PopSift/ -DCMAKE_INSTALL_PREFIX=${POPSIFT_APP_INSTALL}
+  - make install -j 2 VERBOSE=1
 
 cache:
   directories:
-    - $CMAKE_INSTALL
+    - ${CMAKE_INSTALL}
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,61 +1,146 @@
 # CMake below 3.4 does not work with CUDA separable compilation at all
-CMAKE_MINIMUM_REQUIRED(VERSION 3.4)
+cmake_minimum_required(VERSION 3.4)
 
-PROJECT( PopSift )
+project(PopSift VERSION 1.0.0)
+
+OPTION(PopSift_BUILD_EXAMPLES "Build PopSift applications."  ON)
+OPTION(PopSift_USE_NVTX_PROFILING     "Use CUDA NVTX for profiling." OFF)
+OPTION(PopSift_ERRCHK_AFTER_KERNEL     "Synchronize and check CUDA error after every kernel." OFF)
+OPTION(PopSift_USE_POSITION_INDEPENDENT_CODE "Generate position independent code." ON)
+OPTION(PopSift_USE_GRID_FILTER "Switch off grid filtering to massively reduce compile time while debugging other things." ON)
+
+if(PopSift_USE_POSITION_INDEPENDENT_CODE)
+  set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+endif()
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake")
 
-set(CMAKE_BUILD_TYPE Release) # Debug, Release
-
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_DEBUG} -O3")
-set(CMAKE_C_FLAGS_RELEASE   "${CMAKE_C_FLAGS_DEBUG}   -O3")
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DGRIFF_DEBUG")
-set(CMAKE_C_FLAGS_DEBUG   "${CMAKE_C_FLAGS_DEBUG}   -DGRIFF_DEBUG")
-
-find_package(Boost 1.53.0 REQUIRED COMPONENTS system filesystem)
-
-if(Boost_FOUND)
-  include_directories(${Boost_INCLUDE_DIRS})
-  # link_directories(${Boost_LIB_DIR})
-  add_definitions(${Boost_DEFINITIONS})
-  message( STATUS "Found BOOST: ${Boost_LIBRARIES}" )
-else(Boost_FOUND)
-  message( FATAL_ERROR "Boost not found" )
-endif(Boost_FOUND)
-
-find_package(CUDA 7.0)
-
-IF(CUDA_FOUND)
-  SET(CUDA_SEPARABLE_COMPILATION ON)
-  include_directories(${CUDA_INCLUDE_DIRS})
-  add_definitions("-DWITH_CUDA")
-  set(CUDA_NVCC_FLAGS_DEBUG   "${CUDA_NVCC_FLAGS_DEBUG};-G;-g")
-  set(CUDA_NVCC_FLAGS_RELEASE "${CUDA_NVCC_FLAGS_RELEASE};-O3")
-  set(CUDA_NVCC_FLAGS         "${CUDA_NVCC_FLAGS};-gencode;arch=compute_30,code=sm_30")
-  set(CUDA_NVCC_FLAGS         "${CUDA_NVCC_FLAGS};-gencode;arch=compute_35,code=sm_35")
-  set(CUDA_NVCC_FLAGS         "${CUDA_NVCC_FLAGS};-gencode;arch=compute_50,code=sm_50")
-  set(CUDA_NVCC_FLAGS         "${CUDA_NVCC_FLAGS};-gencode;arch=compute_52,code=sm_52")
-  set(CUDA_NVCC_FLAGS         "${CUDA_NVCC_FLAGS};-gencode;arch=compute_52,code=compute_52")
-  # default stream legacy implies that the 0 stream synchronizes all streams
-  set(CUDA_NVCC_FLAGS         "${CUDA_NVCC_FLAGS};--default-stream;legacy")
-  # default stream per-thread implies that each host thread has one non-synchronizing 0-stream
-  # set(CUDA_NVCC_FLAGS         "${CUDA_NVCC_FLAGS};--default-stream;per-thread")
-  # print local memory usage per kernel: -Xptxas;-v
-  # CUDA >= 7.5: -Xptxas;--warn-on-local-memory-usage;-Xptxas;--warn-on-spills
-  message(STATUS "CUDA Version is ${CUDA_VERSION}")
-  if(CUDA_VERSION>=7.5)
-    set(CUDA_NVCC_FLAGS         "${CUDA_NVCC_FLAGS};-Xptxas;--warn-on-local-memory-usage")
-    set(CUDA_NVCC_FLAGS         "${CUDA_NVCC_FLAGS};-Xptxas;--warn-on-spills")
-  else(CUDA_VERSION>=7.5)
-  endif(CUDA_VERSION>=7.5)
-
-  # library required for CUDA dynamic parallelism, forgotten by CMake 3.4
-  cuda_find_library_local_first(CUDA_CUDADEVRT_LIBRARY cudadevrt "\"cudadevrt\" library")
-
-  include_directories("${CMAKE_SOURCE_DIR}/popsift/Cuda-7.0-cub")
-ELSE(CUDA_FOUND)
-  message( FATAL_ERROR "Could not find CUDA >= 7.0" )
-ENDIF(CUDA_FOUND)
+# set(CMAKE_BUILD_TYPE Debug)
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release)
+  message(STATUS "Build type not set, building in Release configuration")
+else()
+  message(STATUS "Building in ${CMAKE_BUILD_TYPE} configuration")
+endif()
+
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
+set(CMAKE_C_FLAGS_RELEASE   "${CMAKE_C_FLAGS_RELEASE}   -O3")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -G")
+# set(CMAKE_C_FLAGS_DEBUG   "${CMAKE_C_FLAGS_DEBUG}   -G")
+
+find_package(Boost 1.53.0 REQUIRED COMPONENTS system thread)
+if(WIN32)
+  add_definitions("-DBOOST_ALL_NO_LIB")
+  link_directories(Boost_LIBRARRY_DIR_DEBUG)
+  link_directories(Boost_LIBRARRY_DIR_RELEASE)
+endif(WIN32)
+
+find_package(CUDA 7.0 REQUIRED)
+
+if(NOT CUDA_FOUND)
+  message(FATAL_ERROR "Could not find CUDA >= 7.0")
+endif()
+
+#
+# Default setting of the CUDA CC versions to compile.
+# Shortening the lists saves a lot of compile time.
+#
+if(CUDA_VERSION_MAJOR GREATER 7)
+  set(PopSift_CUDA_CC_LIST_BASIC 30 35 50 52 60 61 62)
+else(CUDA_VERSION_MAJOR GREATER 7)
+  set(PopSift_CUDA_CC_LIST_BASIC 30 35 50 52 )
+endif(CUDA_VERSION_MAJOR GREATER 7)
+set(PopSift_CUDA_CC_LIST ${PopSift_CUDA_CC_LIST_BASIC} CACHE STRING "CUDA CC versions to compile")
+
+if(PopSift_USE_NVTX_PROFILING)
+  message(STATUS "PROFILING CPU CODE: NVTX is in use")
+endif(PopSift_USE_NVTX_PROFILING)
+
+if(PopSift_ERRCHK_AFTER_KERNEL)
+  message(STATUS "Synchronizing and checking errors after every kernel call")
+  set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS};-DERRCHK_AFTER_KERNEL")
+endif(PopSift_ERRCHK_AFTER_KERNEL)
+
+set(CUDA_SEPARABLE_COMPILATION ON)
+
+if(UNIX AND NOT APPLE)
+  set(CUDA_NVCC_FLAGS         "${CUDA_NVCC_FLAGS};-Xcompiler;-rdynamic;-lineinfo")
+  # set(CUDA_NVCC_FLAGS         "${CUDA_NVCC_FLAGS};-Xptxas;-v")
+  # set(CUDA_NVCC_FLAGS         "${CUDA_NVCC_FLAGS};-Xptxas;-warn-double-usage")
+  set(CUDA_NVCC_FLAGS         "${CUDA_NVCC_FLAGS};--keep")
+  set(CUDA_NVCC_FLAGS         "${CUDA_NVCC_FLAGS};--source-in-ptx")
+endif(UNIX AND NOT APPLE)
+
+# The following if should not be necessary, but apparently there is a bug in FindCUDA.cmake that
+# generate an empty string in the nvcc command line causing the compilation to fail.
+# see https://gitlab.kitware.com/cmake/cmake/issues/16411
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+  message(STATUS "Building in debug mode")
+  set(CUDA_NVCC_FLAGS_DEBUG   "${CUDA_NVCC_FLAGS_DEBUG};-G")
+endif()
+set(CUDA_NVCC_FLAGS_RELEASE "${CUDA_NVCC_FLAGS_RELEASE};-O3")
+
+if(PopSift_USE_POSITION_INDEPENDENT_CODE)
+  set(CUDA_NVCC_FLAGS         "${CUDA_NVCC_FLAGS};-Xcompiler;-fPIC")
+endif()
+
+#
+# Add all requested CUDA CCs to the command line for offline compilation
+#
+list(SORT PopSift_CUDA_CC_LIST)
+foreach(PopSift_CC_VERSION ${PopSift_CUDA_CC_LIST})
+  set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS};-gencode;arch=compute_${PopSift_CC_VERSION},code=sm_${PopSift_CC_VERSION}")
+endforeach(PopSift_CC_VERSION)
+
+#
+# Use the highest request CUDA CC for CUDA JIT compilation
+#
+list(LENGTH PopSift_CUDA_CC_LIST PopSift_CC_LIST_LEN)
+MATH(EXPR PopSift_CC_LIST_LEN "${PopSift_CC_LIST_LEN}-1")
+list(GET PopSift_CUDA_CC_LIST ${PopSift_CC_LIST_LEN} PopSift_CUDA_CC_LIST_LAST)
+set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS};-gencode;arch=compute_${PopSift_CUDA_CC_LIST_LAST},code=compute_${PopSift_CUDA_CC_LIST_LAST}")
+
+# default stream legacy implies that the 0 stream synchronizes all streams
+# default stream per-thread implies that each host thread has one non-synchronizing 0-stream
+# currently, the code requires legacy mode
+set(CUDA_NVCC_FLAGS         "${CUDA_NVCC_FLAGS};--default-stream;legacy")
+# set(CUDA_NVCC_FLAGS         "${CUDA_NVCC_FLAGS};--default-stream;per-thread")
+
+message(STATUS "CUDA Version is ${CUDA_VERSION}")
+message(STATUS "Compiling for CUDA CCs: ${PopSift_CUDA_CC_LIST}")
+if(CUDA_VERSION>=7.5)
+  set(CUDA_NVCC_FLAGS_RELEASE "${CUDA_NVCC_FLAGS_RELEASE};-Xptxas;-warn-lmem-usage")
+  set(CUDA_NVCC_FLAGS_RELEASE "${CUDA_NVCC_FLAGS_RELEASE};-Xptxas;-warn-spills")
+  set(CUDA_NVCC_FLAGS_RELEASE "${CUDA_NVCC_FLAGS_RELEASE};-Xptxas;--warn-on-local-memory-usage")
+  set(CUDA_NVCC_FLAGS_RELEASE "${CUDA_NVCC_FLAGS_RELEASE};-Xptxas;--warn-on-spills")
+else(CUDA_VERSION>=7.5)
+endif(CUDA_VERSION>=7.5)
+
+# library required for CUDA dynamic parallelism, forgotten by CMake 3.4
+cuda_find_library_local_first(CUDA_CUDADEVRT_LIBRARY cudadevrt "\"cudadevrt\" library")
+
+if(PopSift_USE_NVTX_PROFILING)
+  # library required for NVTX profiling of the CPU
+  cuda_find_library_local_first(CUDA_NVTX_LIBRARY nvToolsExt "NVTX library")
+  add_definitions(-DUSE_NVTX)
+endif(PopSift_USE_NVTX_PROFILING)
+
+if(NOT PopSift_USE_GRID_FILTER)
+  message(STATUS "Disabling grid filter compilation")
+  add_definitions(-DDISABLE_GRID_FILTER)
+endif(NOT PopSift_USE_GRID_FILTER)
 
 add_subdirectory(src)
 
+########### Add uninstall target ###############
+CONFIGURE_FILE(
+  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"
+  "${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake"
+  IMMEDIATE @ONLY)
+ADD_CUSTOM_TARGET(uninstall
+  "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake") 
+
diff --git a/README.md b/README.md
@@ -1,14 +1,19 @@
+
 PopSift
 =======
 
 PopSift is an implementation of the SIFT algorithm in CUDA.
 PopSift tries to stick as closely as possible to David Lowe's famous paper (Lowe, D. G. (2004). Distinctive Image Features from Scale-Invariant Keypoints. International Journal of Computer Vision, 60(2), 91–110. doi:10.1023/B:VISI.0000029664.99615.94), while extracting features from an image in real-time at least on an NVidia GTX 980 Ti GPU.
 
+
 Build
 -----
 
-PopSift has been developed and tested on Linux machines, mostly a variant of Ubuntu, but compiles on MacOSX as well. It comes as a CMake project and requires at least CUDA 7.0. It is known to compile and work with NVidia cards of compute capability 3.0 (including the GT 650M), but the code is developed with the compute capability 5.2 card GTX 980 Ti in mind.
-PopSift requires boost to compile the test application.
+PopSift has been developed and tested on Linux machines, mostly a variant of Ubuntu, but compiles on MacOSX as well. It comes as a CMake project and requires at least CUDA 7.0 and Boost >= 1.55. It is known to compile and work with NVidia cards of compute capability 3.0 (including the GT 650M), but the code is developed with the compute capability 5.2 card GTX 980 Ti in mind.
+
+If you want to avoid building the application you can run cmake with the option `-DPopSift_BUILD_EXAMPLES:BOOL=OFF`.
+
+In order to build the library you can run:
 
 ```
 mkdir build && cd build
@@ -18,24 +23,61 @@ make install
 ```
 
 Continuous integration: 
- - [![Build Status](https://travis-ci.org/poparteu/popsift.svg?branch=master)](https://travis-ci.org/poparteu/popsift) master branch.
- - [![Build Status](https://travis-ci.org/poparteu/popsift.svg?branch=develop)](https://travis-ci.org/poparteu/popsift) develop branch.
+- [![Build Status](https://travis-ci.org/alicevision/popsift.svg?branch=master)](https://travis-ci.org/alicevision/popsift) master branch.
+- [![Build Status](https://travis-ci.org/alicevision/popsift.svg?branch=develop)](https://travis-ci.org/alicevision/popsift) develop branch.
+
+
 
 Usage
 -----
 
-Two artifacts are made: libpopsift and the test application popsift-demo. Calling popsift-demo without parameters shows an option.
+Two artifacts are made: `libpopsift` and the test application `popsift-demo`. Calling popsift-demo without parameters shows the options.
 
-To integrate PopSift into other software, link with libpopsift.  The caller must create a popart::Config struct (documented in src/sift/sift_conf.h) to control the behaviour of the PopSift, and instantiate an object of class PopSift (found in src/sift/popsift.h).  After creating an instance, it must be configured to the constant width and height of the input image (init()).  After that, it can be fed a one image at a time (execute()). The only valid input format is a single plane of grayscale unsigned characters. The execute() function returns a pointer to an object of type Features that must be deleted by the caller after use. Features offer iterators that iterate over objects of type Feature. Both classes are documented in sift_extremum.h. Each feature represents a feature point in the coordinate system of the input image, providing X and Y coordinates and scale (sigma), as well as several alternative descriptors for the feature point (according to Lowe, 15% of the feature points should be expected to have 2 or more descriptors).
+### Using PopSift as third party
+
+To integrate PopSift into other software, link with `libpopsift`.  If your are using CMake for building your project you can easily add PopSift to your project. Once you have built and installed PopSift in a directory (say, `<prefix>`), in your `CMakeLists.txt` file just add the dependency
+
+```cmake
+# Find the package from the PopSiftConfig.cmake 
+# in <prefix>/lib/cmake/PopSift/. Under the namespace PopSift::
+# it exposes the target popsift that allows you to compile
+# and link with the library
+find_package(PopSift CONFIG REQUIRED)
+...
+# suppose you want to try it out in a executable
+add_executable(poptest yourfile.cpp)
+# add link to the library
+target_link_libraries(poptest PUBLIC PopSift::popsift)
+```
+
+Then, in order to build just pass the location of `PopSiftConfig.cmake` from the cmake command line:
+
+```bash
+cmake .. -DPopSift_DIR=<prefix>/lib/cmake/PopSift/
+```
+
+
+
+### Calling the API
+
+The caller must create a `popart::Config` struct (documented in `src/sift/sift_conf.h`) to control the behaviour of the PopSift, and instantiate an object of class `PopSift` (found in `src/sift/popsift.h`).
+
+After this, images can be enqueued for SIFT extraction using (`enqueue()`).  The only valid input format is a single plane of grayscale unsigned characters. Only host memory limits the number of images that can be enqueued. The `enqueue` function returns a pointer to a `SiftJob` immediately and performs the feature extraction asynchronously. The memory of the image passed to enqueue remains the caller's responsibility. Calling `SiftJob::get` on the returned job blocks until features are extracted, and returns them.
+
+Features offer iterators that iterate over objects of type `Feature`. Both classes are documented in `sift_extremum.h`. Each feature represents a feature point in the coordinate system of the input image, providing X and Y coordinates and scale (sigma), as well as several alternative descriptors for the feature point (according to Lowe, 15% of the feature points should be expected to have 2 or more descriptors).
+
+In an alternate, deprecated, blocking API, `init()` must be called to pass image width and height to PopSift, followed by a call to `executed()` that takes image data and returns the extracted features. `execute()` is synchronous and blocking.
 
 As far as we know, no implementation that is faster than PopSift at the time of PopSift's release comes under a license that allows commercial use and sticks close to the original paper at the same time as well. PopSift can be configured at runtime to use constants that affect it behaviours. In particular, users can choose to generate results very similar to VLFeat or results that are closer (but not as close) to the SIFT implementation of the OpenCV extras. We acknowledge that there is at least one SIFT implementation that is vastly faster, but it makes considerable sacifices in terms of accuracy and compatibility.
 
+
 License
 -------
 
 PopSift is licensed under [MPL v2 license](LICENSE.md).
 However, SIFT is patented in the US and perhaps other countries, and this license does not release users of this code from any requirements that may arise from such patents.
 
+
 Authors
 -------
 

diff --git a/cmake/cmake_uninstall.cmake.in b/cmake/cmake_uninstall.cmake.in
@@ -0,0 +1,23 @@
+IF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+  MESSAGE(FATAL_ERROR "Cannot find install manifest: @CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+ENDIF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
+
+FILE(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
+# STRING(REGEX REPLACE " " ";" files "${files}")
+STRING(REGEX REPLACE "\n" ";" file_list "${files}")
+FOREACH(file ${file_list})
+  MESSAGE(STATUS "Uninstalling $ENV{DESTDIR}${file}")
+  IF(EXISTS "$ENV{DESTDIR}${file}")
+    EXEC_PROGRAM(
+      "@CMAKE_COMMAND@" ARGS "-E remove $ENV{DESTDIR}${file}"
+      OUTPUT_VARIABLE rm_out
+      RETURN_VALUE rm_retval
+      )
+    IF(NOT "${rm_retval}" STREQUAL 0)
+      MESSAGE(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}")
+    ENDIF(NOT "${rm_retval}" STREQUAL 0)
+  ELSE(EXISTS "$ENV{DESTDIR}${file}")
+    MESSAGE(STATUS "File $ENV{DESTDIR}${file} does not exist.")
+  ENDIF(EXISTS "$ENV{DESTDIR}${file}")
+ENDFOREACH(file)
+