4f12b484f180574c6eb9e28ac739e76d44c165853db056d7b668b65be58331d0

third-party/DPVO/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Princeton Vision & Learning Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

third-party/DPVO/Pangolin/.clang-format

@@ -0,0 +1,2 @@
+DisableFormat: true
+SortIncludes: false

third-party/DPVO/Pangolin/CMakeLists.txt

@@ -0,0 +1,186 @@
+cmake_minimum_required(VERSION 3.10)
+
+project("Pangolin")
+set(PANGOLIN_VERSION_MAJOR 0)
+set(PANGOLIN_VERSION_MINOR 8)
+set(PANGOLIN_VERSION ${PANGOLIN_VERSION_MAJOR}.${PANGOLIN_VERSION_MINOR})
+
+if(NOT CMAKE_CXX_STANDARD)
+    set(CMAKE_CXX_STANDARD 17)
+    set(CMAKE_CXX_STANDARD_REQUIRED ON)
+endif()
+
+add_definitions(-D_GLIBCXX_USE_CXX11_ABI=0)
+
+# Prevent in source builds
+if(EXISTS "${PROJECT_BINARY_DIR}/CMakeLists.txt")
+    message(FATAL_ERROR "Source build detected: please use a subdir. You may remove 'CMakeCache.txt' and 'CMakeFiles'.")
+endif()
+
+# Make our own cmake imports accessible
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake")
+
+include(SetPlatformVars)
+include(PangolinFactory)
+
+option( BUILD_TOOLS "Build Tools" ON )
+option( BUILD_EXAMPLES "Build Examples" ON )
+option( BUILD_ASAN "Enable AddressSanitizer for Debug builds" OFF )
+
+# Default build type (Override with cmake .. -DCMAKE_BUILD_TYPE=...)
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build." FORCE)
+  message(STATUS "Setting build type to '${CMAKE_BUILD_TYPE}' as none was specified.")
+  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+endif()
+
+if(_WIN_)
+    option( BUILD_SHARED_LIBS    "Build Shared Library" OFF)
+    option( MSVC_USE_STATIC_CRT  "Use static C Runtime with MSVC, /MT instead of /MD" ON)
+
+    # Make sure there are no erroneous C Runtime flags
+    list(APPEND FLAG_VARS
+        CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO
+        CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO
+    )
+    if(MSVC_USE_STATIC_CRT)
+        foreach(FLAG_VAR ${FLAG_VARS})
+            string(REGEX REPLACE "/MD" "/MT" NEW_FLAGS "${${FLAG_VAR}}")
+            set(${FLAG_VAR} "${NEW_FLAGS}" CACHE STRING "" FORCE)
+        endforeach()
+    else()
+        foreach(FLAG_VAR ${FLAG_VARS})
+            string(REGEX REPLACE "/MT" "/MD" NEW_FLAGS "${${FLAG_VAR}}")
+            set(${FLAG_VAR} "${NEW_FLAGS}" CACHE STRING "" FORCE)
+        endforeach()
+    endif()
+elseif(_OSX_)
+    option( BUILD_SHARED_LIBS "Build Shared Library" ON)
+    set(CMAKE_MACOSX_RPATH ON)
+elseif(EMSCRIPTEN)
+    set(BUILD_SHARED_LIBS OFF)
+    include(EmscriptenUtils)
+    set(CMAKE_EXE_LINKER_FLAGS "-sASYNCIFY=1 -sDISABLE_EXCEPTION_CATCHING=0 -sGL_ASSERTIONS=1 -sFULL_ES2=1 -sFULL_ES3=1 --bind")
+else()
+    option( BUILD_SHARED_LIBS "Build Shared Library" ON)
+endif()
+
+# run with "ASAN_OPTIONS=fast_unwind_on_malloc=0" to print stack with more details
+if(BUILD_ASAN)
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} \
+        -fsanitize=address \
+        -fsanitize=bool \
+        -fsanitize=bounds \
+        -fsanitize=enum \
+        -fsanitize=float-cast-overflow \
+        -fsanitize=float-divide-by-zero \
+        -fsanitize=nonnull-attribute \
+        -fsanitize=returns-nonnull-attribute \
+        -fsanitize=signed-integer-overflow \
+        -fsanitize=undefined \
+        -fsanitize=vla-bound \
+        -fno-sanitize=alignment \
+        -fsanitize=leak \
+        -fsanitize=object-size \
+    ")
+endif()
+
+#######################################################
+## Testing setup
+
+option( BUILD_TESTS "Build Tests" OFF)
+find_package(Catch2 2 QUIET)
+if(Catch2_FOUND)
+    include(CTest)
+    include(Catch)
+else()
+    if(BUILD_TESTS)
+        message(WARNING "Building Tests requested, but Catch2 library not found.")
+        set( BUILD_TESTS OFF)
+    endif()
+endif()
+
+#######################################################
+## Add all pangolin components
+
+file(GLOB components_cmake "${CMAKE_CURRENT_LIST_DIR}/components/*/CMakeLists.txt")
+set(component_list "")
+foreach(component_cmake ${components_cmake})
+    get_filename_component(component_dir ${component_cmake} DIRECTORY)
+    get_filename_component(component_name ${component_dir} NAME)
+    add_library(${component_name} "")
+    list(APPEND component_list ${component_name})
+endforeach()
+
+foreach(component_cmake ${components_cmake})
+    include(${component_cmake})
+endforeach()
+
+#######################################################
+## Build Tree Export
+
+# Export Targets
+export(TARGETS ${component_list} FILE PangolinTargets.cmake)
+export(PACKAGE Pangolin)
+
+# Version information
+configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/${PROJECT_NAME}ConfigVersion.cmake.in
+"${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake" @ONLY)
+
+# Build tree config
+configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/cmake/${PROJECT_NAME}Config.cmake.in
+${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake @ONLY IMMEDIATE )
+
+
+#######################################################
+## Install headers / targets
+
+# This relative path allows installed files to be relocatable.
+set( CMAKECONFIG_INSTALL_DIR lib/cmake/${PROJECT_NAME} )
+file( RELATIVE_PATH REL_INCLUDE_DIR
+    "${CMAKE_INSTALL_PREFIX}/${CMAKECONFIG_INSTALL_DIR}"
+    "${CMAKE_INSTALL_PREFIX}/include"
+)
+
+install(
+    TARGETS ${component_list}
+    EXPORT ${PROJECT_NAME}Targets
+    LIBRARY DESTINATION lib
+    ARCHIVE DESTINATION lib
+    RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
+)
+
+install(
+    FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
+          "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
+    DESTINATION ${CMAKECONFIG_INSTALL_DIR}
+)
+install(
+    EXPORT ${PROJECT_NAME}Targets DESTINATION ${CMAKECONFIG_INSTALL_DIR}
+)
+
+# uninstall target
+if(NOT TARGET uninstall)
+  configure_file(
+    "${CMAKE_CURRENT_LIST_DIR}/cmake/cmake_uninstall.cmake.in"
+    "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
+    IMMEDIATE @ONLY)
+
+  add_custom_target(uninstall
+    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
+endif()
+
+
+#######################################################
+## Tools / Examples
+
+set(Pangolin_DIR ${CMAKE_CURRENT_BINARY_DIR})
+
+if(BUILD_EXAMPLES)
+    add_subdirectory(examples)
+endif()
+
+if(BUILD_TOOLS)
+    add_subdirectory(tools)
+endif()

third-party/DPVO/Pangolin/cmake/AndroidUtils.cmake

@@ -0,0 +1,245 @@
+if(NOT ANDROID_PACKAGE_NAME)
+  set(ANDROID_PACKAGE_NAME "com.github.stevenlovegrove.pangolin")
+endif()
+
+if(NOT ANDROID_DEFERRED_ENTRY_SO)
+  set(ANDROID_DEFERRED_ENTRY_SO "libpangolin.so")
+endif()
+
+# Configure build environment to automatically generate APK's instead of executables.
+if(ANDROID AND NOT TARGET apk)
+    # virtual targets which we'll add apks and push actions to.
+    add_custom_target( apk )
+    add_custom_target( push )
+    add_custom_target( run )
+
+    # Reset output directories to be in binary folder (rather than source)
+    set(LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_CURRENT_BINARY_DIR})
+    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME})
+    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME})
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH_ROOT}/bin/${ANDROID_NDK_ABI_NAME})
+    
+    macro( create_android_manifest_xml filename prog_name package_name activity_name)
+        file( WRITE ${filename}
+"<?xml version=\"1.0\" encoding=\"utf-8\"?>
+<!-- BEGIN_INCLUDE(manifest) -->
+<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\"
+        package=\"${package_name}.${prog_name}\"
+        android:versionCode=\"1\"
+        android:versionName=\"1.0\">
+
+    <!-- This is the platform API where NativeActivity was introduced. -->
+    <uses-sdk android:minSdkVersion=\"14\" />
+    <uses-feature android:glEsVersion=\"0x00020000\" />
+    <uses-feature android:name=\"android.hardware.camera\" />
+    <uses-permission android:name=\"android.permission.CAMERA\"/>
+    <uses-permission android:name=\"android.permission.WRITE_EXTERNAL_STORAGE\"/>
+    <uses-permission android:name=\"android.permission.READ_EXTERNAL_STORAGE\"/>
+
+    <!-- This .apk has no Java code itself, so set hasCode to false. -->
+    <application android:label=\"${activity_name}\" android:hasCode=\"false\">
+
+        <!-- Our activity is the built-in NativeActivity framework class.
+             This will take care of integrating with our NDK code. -->
+        <activity android:name=\"android.app.NativeActivity\"
+                android:label=\"${activity_name}\"
+                android:screenOrientation=\"landscape\"
+                android:configChanges=\"orientation|keyboard|keyboardHidden\"
+                android:theme=\"@android:style/Theme.NoTitleBar.Fullscreen\"
+                >
+            <!-- Tell NativeActivity the name of our .so -->
+            <meta-data android:name=\"android.app.lib_name\"
+                    android:value=\"${prog_name}_start\" />
+            <intent-filter>
+                <action android:name=\"android.intent.action.MAIN\" />
+                <category android:name=\"android.intent.category.LAUNCHER\" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest> 
+<!-- END_INCLUDE(manifest) -->" )        
+    endmacro()
+
+    macro( create_bootstrap_library prog_name package_name)
+        set(bootstrap_cpp "${CMAKE_CURRENT_BINARY_DIR}/${prog_name}_start.cpp" )
+        file( WRITE ${bootstrap_cpp}
+"#include <android/native_activity.h>
+#include <android/log.h>
+#include <dlfcn.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <cstdio>
+
+#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, \"AndroidUtils.cmake\", __VA_ARGS__))
+#define LIB_PATH \"/data/data/${package_name}.${prog_name}/lib/\"
+
+void * load_lib(const char * l) {
+    void * handle = dlopen(l, RTLD_NOW | RTLD_GLOBAL);
+    if (!handle) LOGE( \"dlopen('%s'): %s\", l, strerror(errno) );
+    return handle;
+}
+
+void ANativeActivity_onCreate(ANativeActivity * app, void * ud, size_t udsize) {
+    #include \"${prog_name}_shared_load.h\"
+
+    // Look for standard entrypoint in user lib
+    void (*stdentrypoint)(ANativeActivity*, void*, size_t);
+    *(void **) (&stdentrypoint) = dlsym(load_lib( LIB_PATH \"lib${prog_name}.so\"), \"ANativeActivity_onCreate\");
+    if (stdentrypoint) {
+        (*stdentrypoint)(app, ud, udsize);
+    }else{
+        // Look for deferred load entry point
+        void (*exdentrypoint)(ANativeActivity*, void*, size_t, const char*);
+        *(void **) (&exdentrypoint) = dlsym(load_lib( LIB_PATH \"lib${prog_name}.so\"), \"DeferredNativeActivity_onCreate\");
+        if (!exdentrypoint) {
+            // Look in specific shared lib
+            *(void **) (&exdentrypoint) = dlsym(load_lib( LIB_PATH \"${ANDROID_DEFERRED_ENTRY_SO}\"), \"DeferredNativeActivity_onCreate\");
+        }
+        if(exdentrypoint) {
+            (*exdentrypoint)(app, ud, udsize, LIB_PATH \"lib${prog_name}.so\" );
+        }else{
+            LOGE( \"Unable to find compatible entry point\" );
+        }
+    }
+}" )
+        add_library( "${prog_name}_start" SHARED ${bootstrap_cpp} )
+        target_link_libraries( "${prog_name}_start" android log )
+        add_dependencies( ${prog_name} "${prog_name}_start" )
+    endmacro()
+
+    macro( android_update android_project_name)
+        # Find which android platforms are available.
+        execute_process(
+            COMMAND android list targets -c
+            OUTPUT_VARIABLE android_target_list
+        )
+
+        # Pick first platform from this list.
+        string(REGEX MATCH "^[^\n]+" android_target "${android_target_list}" )
+        message(STATUS "Android Target: ${android_target}")
+        
+        if( NOT "${android_target}" STREQUAL "" )        
+            # Generate ant build scripts for making APK
+            execute_process(
+                COMMAND android update project --name ${android_project_name} --path . --target ${android_target} --subprojects
+                WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+            )
+        else()
+            message( FATAL_ERROR "No Android SDK platforms found. Please install an Android platform SDK. On Linux, run 'android'." )
+        endif()
+    endmacro()
+
+    # Override add_executable to build android .so instead!
+    macro( add_executable prog_name)
+        set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libs/${ANDROID_NDK_ABI_NAME})
+        add_library( ${prog_name} SHARED ${ARGN} )
+
+        # Add required link libs for android
+        target_link_libraries(${prog_name} log android )
+
+        # Create manifest required for APK
+        create_android_manifest_xml(
+            "${CMAKE_CURRENT_BINARY_DIR}/AndroidManifest.xml" "${prog_name}"
+            "${ANDROID_PACKAGE_NAME}" "${prog_name}"
+        )
+
+        # Create library that will launch this program and load shared libs
+        create_bootstrap_library( ${prog_name} ${ANDROID_PACKAGE_NAME} )
+
+        # Generate ant build system for APK
+        android_update( ${prog_name} )
+
+        # Target to invoke ant build system for APK
+        set( APK_FILE "${CMAKE_CURRENT_BINARY_DIR}/bin/${prog_name}-debug.apk" )
+        add_custom_command(
+            OUTPUT ${APK_FILE}
+            COMMAND ant debug
+            DEPENDS ${prog_name}
+            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+        )
+
+        # Target to install on device
+        add_custom_target( ${prog_name}-apk
+            DEPENDS ${APK_FILE}
+        )
+        add_dependencies(apk ${prog_name}-apk)
+
+        # Target to install on device
+        add_custom_target( ${prog_name}-push
+            COMMAND adb install -r ${APK_FILE}
+            DEPENDS ${APK_FILE}
+        )
+        add_dependencies(push ${prog_name}-push)
+
+        # install and run on device
+        add_custom_target( ${prog_name}-run
+            COMMAND adb shell am start -n ${ANDROID_PACKAGE_NAME}.${prog_name}/android.app.NativeActivity
+            DEPENDS ${prog_name}-push
+            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        )
+        add_dependencies(run ${prog_name}-run)
+
+        # Flag to package dependent libs
+        set_property(TARGET ${prog_name} APPEND PROPERTY MAKE_APK 1 )        
+
+        # Clear shared library loading header
+        file( WRITE "${CMAKE_CURRENT_BINARY_DIR}/${prog_name}_shared_load.h" "")
+    endmacro()
+
+    macro( package_with_target prog_name lib_path )
+        # Mark lib_path as dependent of prog_name
+        set_property(TARGET ${prog_name} APPEND PROPERTY IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE ${lib_path} )
+
+        # If prog_name is to be packaged, add file copy command to package .so's.
+        get_target_property( package_dependent_libs ${prog_name} MAKE_APK )
+        if( package_dependent_libs )
+            get_filename_component(target_filename ${lib_path} NAME)
+            file( APPEND ${depend_file} "load_lib(LIB_PATH \"${target_filename}\" );\n")
+            add_custom_command(TARGET ${prog_name} POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                ${lib_path} "${CMAKE_CURRENT_BINARY_DIR}/libs/${ANDROID_NDK_ABI_NAME}/"
+            )
+        endif()
+    endmacro()
+
+    macro( add_to_depend_libs prog_name depend_file lib_name )
+        # Recursively Process dependents of lib_name
+        get_target_property(TARGET_LIBS ${lib_name} IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE)
+        if(NOT TARGET_LIBS)
+            get_target_property(TARGET_LIBS ${lib_name} IMPORTED_LINK_INTERFACE_LIBRARIES_NOCONFIG)
+        endif()
+        if(NOT TARGET_LIBS)
+            get_target_property(TARGET_LIBS ${lib_name} IMPORTED_LINK_INTERFACE_LIBRARIES_DEBUG)
+        endif()
+
+        foreach(SUBLIB ${TARGET_LIBS})
+            if(SUBLIB)
+                add_to_depend_libs( ${prog_name} ${depend_file} ${SUBLIB} )
+            endif()
+        endforeach()
+
+        # Check if lib itself is an external shared library
+        if("${lib_name}" MATCHES "\\.so$")
+            package_with_target( ${prog_name} ${lib_name} )
+        endif()
+
+        # Check if lib itself is an internal shared library
+        get_target_property(TARGET_LIB ${lib_name} LOCATION)
+        if("${TARGET_LIB}" MATCHES "\\.so$")
+            package_with_target( ${prog_name} ${TARGET_LIB} )
+        endif()
+    endmacro()
+
+    macro( target_link_libraries prog_name)
+        # _target_link_libraries corresponds to original
+        _target_link_libraries( ${prog_name} ${ARGN} )
+
+        # Recursively process dependencies
+        set(depend_file "${CMAKE_CURRENT_BINARY_DIR}/${prog_name}_shared_load.h" )
+        foreach( LIB ${ARGN} )
+            add_to_depend_libs( ${prog_name} ${depend_file} ${LIB} )
+        endforeach()
+    endmacro()
+
+endif()

third-party/DPVO/Pangolin/cmake/CreateMethodCallFile.cmake

@@ -0,0 +1,11 @@
+macro( CreateMethodCallFile filename namespace function symbols)
+    file(WRITE ${filename} "// CMake generated file. Do Not Edit.\n\n#pragma once\n\nnamespace ${namespace} {\n\n")
+    foreach( symbol ${symbols} )
+        file(APPEND ${filename} "void ${symbol}();\n")
+    endforeach()
+    file(APPEND ${filename} "\ninline bool ${function}()\n{\n")
+    foreach( symbol ${symbols} )
+        file(APPEND ${filename} "    ${symbol}();\n")
+    endforeach()
+    file(APPEND ${filename} "    return true;\n}\n\n} // ${namespace}\n")
+endmacro()

third-party/DPVO/Pangolin/cmake/EmbedBinaryFiles.cmake

@@ -0,0 +1,37 @@
+# Creates C resources file from specified files
+# Based on http://stackoverflow.com/a/27206982
+function(embed_binary_files_now output binary_files)
+    # Create empty output file
+    file(WRITE ${output} "")
+    # Iterate through input files
+    foreach(bin ${binary_files})
+        # Get short filename
+        string(REGEX MATCH "([^/]+)$" filename ${bin})
+        # Replace filename spaces & extension separator for C compatibility
+        string(REGEX REPLACE "\\.| " "_" filename ${filename})
+        # Read hex data from file
+        file(READ ${bin} filedata HEX)
+        # Convert hex data for C compatibility
+        string(REGEX REPLACE "([0-9a-f][0-9a-f])" "0x\\1," filedata ${filedata})
+        # Append data to output file
+        file(APPEND ${output} "extern const unsigned char ${filename}[] = {${filedata}};\nextern const unsigned ${filename}_size = sizeof(${filename});\n")
+    endforeach()
+endfunction()
+
+# Sets up rule for embedding files when they are newer than the output file (or it doesn't exist yet)
+function(embed_binary_files_rule output binary_files)
+    add_custom_command(
+        OUTPUT ${output}
+        DEPENDS ${binary_files}
+        COMMAND
+            ${CMAKE_COMMAND} -DINPUT_BINARY_FILES=${binary_files}
+                             -DOUTPUT_SRC_FILE=${output}
+                             -P ${PROJECT_SOURCE_DIR}/cmake/EmbedBinaryFiles.cmake
+        COMMENT "Embedding ${binary_files} into ${output}"
+    )
+endfunction()
+
+if(CMAKE_SCRIPT_MODE_FILE AND NOT CMAKE_PARENT_LIST_FILE)
+    # Running in script mode as part of build-time procedure to actually to the embedding
+    embed_binary_files_now(${OUTPUT_SRC_FILE} ${INPUT_BINARY_FILES} )
+endif()

third-party/DPVO/Pangolin/cmake/EmscriptenUtils.cmake

@@ -0,0 +1,37 @@
+if(EMSCRIPTEN)
+    macro( create_host_index_html filename prog_name)
+        file( WRITE ${filename}
+"<!doctype html>
+<head>
+    <meta charset=\"utf-8\">
+    <title>${prog_name}</title>
+</head>
+<body oncontextmenu=\"return false;\">
+    <canvas id=\"canvas\" tabindex=-1></canvas>
+    <script type=\"text/javascript\">
+        var canvas = document.getElementById(\"canvas\");
+        canvas.width = window.innerWidth;
+        canvas.height = window.innerHeight;
+        var Module = {};
+        Module.canvas = canvas;
+        Module.arguments = ['test://'];
+        window.onerror = function(message, source, lineno, colno, error) {
+          console.log(Module.pango_get_exception_message(error));
+          return false;
+        };
+        window.addEventListener(\"unhandledrejection\", function(promiseRejectionEvent) {
+            console.log(Module.pango_get_exception_message(promiseRejectionEvent.reason));
+        });
+    </script>
+    <script type=\"text/javascript\" src=\"${prog_name}.js\"></script>
+</body>
+</html>")
+    endmacro()
+
+    # Override add_executable to make webpage instead
+    macro( add_executable prog_name)
+        # Create manifest required for APK
+        create_host_index_html("${CMAKE_CURRENT_BINARY_DIR}/index.html" "${prog_name}")
+        _add_executable(${prog_name} ${ARGN})
+    endmacro()
+endif()

third-party/DPVO/Pangolin/cmake/FindDC1394.cmake

@@ -0,0 +1,32 @@
+# Try to find the dc1394 v2 lib and include files
+#
+# DC1394_INCLUDE_DIR
+# DC1394_LIBRARIES
+# DC1394_FOUND
+
+FIND_PATH( DC1394_INCLUDE_DIR dc1394/control.h
+  /usr/include
+  /usr/local/include
+)
+
+FIND_LIBRARY( DC1394_LIBRARY dc1394
+  /usr/lib64
+  /usr/lib
+  /usr/local/lib
+)
+
+IF(DC1394_INCLUDE_DIR AND DC1394_LIBRARY)
+  SET( DC1394_FOUND TRUE )
+  SET( DC1394_LIBRARIES ${DC1394_LIBRARY} )
+ENDIF(DC1394_INCLUDE_DIR AND DC1394_LIBRARY)
+
+IF(DC1394_FOUND)
+   IF(NOT DC1394_FIND_QUIETLY)
+      MESSAGE(STATUS "Found DC1394: ${DC1394_LIBRARY}")
+   ENDIF(NOT DC1394_FIND_QUIETLY)
+ELSE(DC1394_FOUND)
+   IF(DC1394_FIND_REQUIRED)
+      MESSAGE(FATAL_ERROR "Could not find libdc1394")
+   ENDIF(DC1394_FIND_REQUIRED)
+ENDIF(DC1394_FOUND)
+

third-party/DPVO/Pangolin/cmake/FindDepthSense.cmake

@@ -0,0 +1,43 @@
+# Try to find the DepthSense SDK For SoftKinetic Cameras
+#
+# DepthSense_INCLUDE_DIRS
+# DepthSense_LIBRARIES
+# DepthSense_FOUND
+
+FIND_PATH( DepthSense_INCLUDE_DIR DepthSense.hxx
+  PATHS
+      "${PROGRAM_FILES}/SoftKinetic/DepthSenseSDK/include"
+      "${PROGRAM_FILES}/Meta/DepthSenseSDK/include"
+      /usr/include
+      /usr/local/include
+      /opt/local/include
+      /opt/softkinetic/DepthSenseSDK/include
+)
+
+FIND_LIBRARY( DepthSense_LIBRARY DepthSense
+  PATHS
+      "${PROGRAM_FILES}/SoftKinetic/DepthSenseSDK/lib"
+      "${PROGRAM_FILES}/Meta/DepthSenseSDK/lib"
+      /usr/lib64
+      /usr/lib
+      /usr/local/lib
+      /opt/local/lib
+      /opt/softkinetic/DepthSenseSDK/lib
+)
+
+IF(DepthSense_INCLUDE_DIR AND DepthSense_LIBRARY)
+  SET( DepthSense_FOUND TRUE )
+  SET( DepthSense_LIBRARIES ${DepthSense_LIBRARY} )
+  SET( DepthSense_INCLUDE_DIRS ${DepthSense_INCLUDE_DIR} )
+ENDIF()
+
+IF(DepthSense_FOUND)
+   IF(NOT DepthSense_FIND_QUIETLY)
+      MESSAGE(STATUS "Found DepthSense: ${DepthSense_LIBRARY}")
+   ENDIF()
+ELSE()
+   IF(DepthSense_FIND_REQUIRED)
+      MESSAGE(FATAL_ERROR "Could not find DepthSense")
+   ENDIF()
+ENDIF()
+

third-party/DPVO/Pangolin/cmake/FindFFMPEG.cmake

@@ -0,0 +1,97 @@
+# Try to find the ffmpeg libraries and headers for avcodec avformat swscale
+#
+# FFMPEG_INCLUDE_DIRS
+# FFMPEG_LIBRARIES
+# FFMPEG_FOUND
+
+# Find header files
+FIND_PATH(
+  AVCODEC_INCLUDE_DIR libavcodec/avcodec.h
+  /usr/include /usr/local/include /opt/local/include /usr/include/x86_64-linux-gnu
+)
+FIND_PATH(
+  AVFORMAT_INCLUDE_DIR libavformat/avformat.h
+  /usr/include /usr/local/include /opt/local/include /usr/include/x86_64-linux-gnu
+)
+FIND_PATH(
+  AVDEVICE_INCLUDE_DIR libavdevice/avdevice.h
+  /usr/include /usr/local/include /opt/local/include /usr/include/x86_64-linux-gnu
+)
+FIND_PATH(
+  AVUTIL_INCLUDE_DIR libavutil/avutil.h
+  /usr/include /usr/local/include /opt/local/include /usr/include/x86_64-linux-gnu
+)
+FIND_PATH(
+  SWSCALE_INCLUDE_DIR libswscale/swscale.h
+  /usr/include /usr/local/include /opt/local/include /usr/include/x86_64-linux-gnu
+)
+
+# Find Library files
+FIND_LIBRARY(
+  AVCODEC_LIBRARY
+  NAMES avcodec
+  PATH /usr/lib /usr/local/lib /opt/local/lib /usr/lib/x86_64-linux-gnu
+)
+FIND_LIBRARY(
+  AVFORMAT_LIBRARY
+  NAMES avformat
+  PATH /usr/lib /usr/local/lib /opt/local/lib /usr/lib/x86_64-linux-gnu
+)
+FIND_LIBRARY(
+  AVDEVICE_LIBRARY
+  NAMES avdevice
+  PATH /usr/lib /usr/local/lib /opt/local/lib /usr/lib/x86_64-linux-gnu
+)
+FIND_LIBRARY(
+  AVUTIL_LIBRARY
+  NAMES avutil
+  PATH /usr/lib /usr/local/lib /opt/local/lib /usr/lib/x86_64-linux-gnu
+)
+FIND_LIBRARY(
+  SWSCALE_LIBRARY
+  NAMES swscale
+  PATH /usr/lib /usr/local/lib /opt/local/lib /usr/lib/x86_64-linux-gnu
+)
+
+IF( EXISTS "${AVUTIL_INCLUDE_DIR}/libavutil/pixdesc.h" )
+  SET( AVUTIL_HAVE_PIXDESC TRUE)
+endif()
+
+IF(AVCODEC_INCLUDE_DIR AND AVFORMAT_INCLUDE_DIR AND AVUTIL_INCLUDE_DIR AND AVDEVICE_INCLUDE_DIR AND SWSCALE_INCLUDE_DIR AND AVCODEC_LIBRARY AND AVFORMAT_LIBRARY AND AVUTIL_LIBRARY AND SWSCALE_LIBRARY AND AVDEVICE_LIBRARY AND AVUTIL_HAVE_PIXDESC)
+   SET(FFMPEG_FOUND TRUE)
+   SET(FFMPEG_LIBRARIES ${AVCODEC_LIBRARY} ${AVFORMAT_LIBRARY} ${AVUTIL_LIBRARY} ${SWSCALE_LIBRARY} ${AVDEVICE_LIBRARY})
+   SET(FFMPEG_INCLUDE_DIRS ${AVCODEC_INCLUDE_DIR} ${AVFORMAT_INCLUDE_DIR} ${AVUTIL_INCLUDE_DIR} ${SWSCALE_INCLUDE_DIR} ${AVDEVICE_INCLUDE_DIR})
+
+   include(CheckCXXSourceCompiles)
+
+   SET(CMAKE_REQUIRED_INCLUDES ${FFMPEG_INCLUDE_DIRS})
+
+   CHECK_CXX_SOURCE_COMPILES(
+     "#include \"${AVCODEC_INCLUDE_DIR}/libavformat/avformat.h\"
+      int main() {
+        sizeof(AVFormatContext::max_analyze_duration);
+      }" HAVE_FFMPEG_MAX_ANALYZE_DURATION
+   )
+   CHECK_CXX_SOURCE_COMPILES(
+     "#include \"${AVCODEC_INCLUDE_DIR}/libavformat/avformat.h\"
+      int main() {
+        &avformat_alloc_output_context2;
+      }" HAVE_FFMPEG_AVFORMAT_ALLOC_OUTPUT_CONTEXT2
+   )
+   CHECK_CXX_SOURCE_COMPILES(
+     "#include \"${AVCODEC_INCLUDE_DIR}/libavutil/pixdesc.h\"
+      int main() {
+        AVPixelFormat test = AV_PIX_FMT_GRAY8;
+      }" HAVE_FFMPEG_AVPIXELFORMAT
+   )
+ENDIF()
+
+IF (FFMPEG_FOUND)
+   IF (NOT FFMPEG_FIND_QUIETLY)
+      MESSAGE(STATUS "Found FFMPEG: ${FFMPEG_LIBRARIES}")
+   ENDIF (NOT FFMPEG_FIND_QUIETLY)
+ELSE (FFMPEG_FOUND)
+   IF (FFMPEG_FIND_REQUIRED)
+      MESSAGE(FATAL_ERROR "Could not find FFMPEG")
+   ENDIF (FFMPEG_FIND_REQUIRED)
+ENDIF (FFMPEG_FOUND)

third-party/DPVO/Pangolin/cmake/FindGLEW.cmake

@@ -0,0 +1,53 @@
+#
+# Try to find GLEW library and include path.
+# Once done this will define
+#
+# GLEW_FOUND
+# GLEW_INCLUDE_DIR
+# GLEW_LIBRARY
+# 
+
+IF (WIN32)
+    FIND_PATH( GLEW_INCLUDE_DIR GL/glew.h
+        $ENV{PROGRAMFILES}/GLEW/include
+        ${PROJECT_SOURCE_DIR}/src/nvgl/glew/include
+        DOC "The directory where GL/glew.h resides")
+    FIND_LIBRARY( GLEW_LIBRARY
+        NAMES glew GLEW glew32 glew32s
+        PATHS
+        $ENV{PROGRAMFILES}/GLEW/lib
+        ${PROJECT_SOURCE_DIR}/src/nvgl/glew/bin
+        ${PROJECT_SOURCE_DIR}/src/nvgl/glew/lib
+        DOC "The GLEW library")
+ELSE (WIN32)
+    FIND_PATH( GLEW_INCLUDE_DIR GL/glew.h
+        /usr/include
+        /usr/local/include
+        /sw/include
+        /opt/local/include
+        DOC "The directory where GL/glew.h resides")
+    FIND_LIBRARY( GLEW_LIBRARY
+        NAMES GLEW glew
+        PATHS
+        /usr/lib64
+        /usr/lib
+        /usr/local/lib64
+        /usr/local/lib
+        /sw/lib
+        /opt/local/lib
+        DOC "The GLEW library")
+ENDIF (WIN32)
+
+IF (GLEW_INCLUDE_DIR AND GLEW_LIBRARY)
+        SET( GLEW_FOUND TRUE )
+ENDIF (GLEW_INCLUDE_DIR AND GLEW_LIBRARY)
+
+IF (GLEW_FOUND)
+   IF (NOT GLEW_FIND_QUIETLY)
+      MESSAGE(STATUS "Found GLEW: ${GLEW_LIBRARY}")
+   ENDIF (NOT GLEW_FIND_QUIETLY)
+ELSE (GLEW_FOUND)
+   IF (GLEW_FIND_REQUIRED)
+      MESSAGE(FATAL_ERROR "Could not find GLEW")
+   ENDIF (GLEW_FIND_REQUIRED)
+ENDIF (GLEW_FOUND)

third-party/DPVO/Pangolin/cmake/FindGLUES.cmake

@@ -0,0 +1,38 @@
+# Try to find the GLUES lib and include files
+#
+# GLUES_INCLUDE_DIR
+# GLUES_LIBRARIES
+# GLUES_FOUND
+
+FIND_PATH( GLUES_INCLUDE_DIR glues/glues.h
+  /usr/include
+  /usr/local/include
+  /opt/include
+  /opt/local/include
+  ${CMAKE_INSTALL_PREFIX}/include
+)
+
+FIND_LIBRARY( GLUES_LIBRARY glues
+  /usr/lib64
+  /usr/lib
+  /usr/local/lib
+  /opt/local/lib
+  /opt/local/lib64
+  ${CMAKE_INSTALL_PREFIX}/lib
+)
+
+IF(GLUES_INCLUDE_DIR AND GLUES_LIBRARY)
+  SET( GLUES_FOUND TRUE )
+  SET( GLUES_LIBRARIES ${GLUES_LIBRARY} )
+ENDIF(GLUES_INCLUDE_DIR AND GLUES_LIBRARY)
+
+IF(GLUES_FOUND)
+   IF(NOT GLUES_FIND_QUIETLY)
+      MESSAGE(STATUS "Found GLUES: ${GLUES_LIBRARY}")
+   ENDIF(NOT GLUES_FIND_QUIETLY)
+ELSE(GLUES_FOUND)
+   IF(GLUES_FIND_REQUIRED)
+      MESSAGE(FATAL_ERROR "Could not find GLUES")
+   ENDIF(GLUES_FIND_REQUIRED)
+ENDIF(GLUES_FOUND)
+

third-party/DPVO/Pangolin/cmake/FindLibraw.cmake

@@ -0,0 +1,41 @@
+# - Try to find libraw
+#
+#  libraw_FOUND - system has libraw
+#  libraw_INCLUDE_DIRS - the libraw include directories
+#  libraw_LIBRARIES - link these to use libraw
+
+FIND_PATH(
+  libraw_INCLUDE_DIRS
+  NAMES libraw/libraw.h
+  PATHS
+    ${LIBRAW_DIR}
+    ${LIBRAW_DIR}/include
+    /usr/include/
+    /usr/local/include
+    /opt/local/include
+)
+
+FIND_LIBRARY(
+  libraw_LIBRARIES
+  NAMES raw_r
+  PATHS
+    ${LIBRAW_DIR}
+    ${LIBRAW_DIR}/lib
+    /usr/lib
+    /usr/local/lib
+    /opt/local/lib
+)
+
+IF (libraw_INCLUDE_DIRS AND libraw_LIBRARIES)
+   SET(libraw_FOUND TRUE)
+ENDIF (libraw_INCLUDE_DIRS AND libraw_LIBRARIES)
+
+IF (libraw_FOUND)
+   IF (NOT libraw_FIND_QUIETLY)
+      MESSAGE(STATUS "Found libraw: ${libraw_LIBRARIES}")
+   ENDIF (NOT libraw_FIND_QUIETLY)
+ELSE (libraw_FOUND)
+   IF (libraw_FIND_REQUIRED)
+      MESSAGE(FATAL_ERROR "Could not find libraw")
+   ENDIF (libraw_FIND_REQUIRED)
+ENDIF (libraw_FOUND)

third-party/DPVO/Pangolin/cmake/FindLz4.cmake

@@ -0,0 +1,26 @@
+
+find_path(Lz4_INCLUDE_DIRS
+    NAMES lz4frame.h
+    PATHS 
+        /opt/local/include
+        /usr/local/include
+        /usr/include
+    )
+
+find_library(Lz4_LIBRARIES
+    NAMES lz4
+    PATHS 
+        /usr/local/lib
+        /opt/local/lib
+        /user/local/lib
+        /usr/lib
+    )
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Lz4 REQUIRED_VARS Lz4_LIBRARIES Lz4_INCLUDE_DIRS)
+
+mark_as_advanced(
+    Lz4_INCLUDE_DIRS
+    Lz4_LIBRARIES
+    Lz4_FOUND
+)

third-party/DPVO/Pangolin/cmake/FindMediaFoundation.cmake

@@ -0,0 +1,20 @@
+# - Find MediaFoundation
+# Find the Windows SDK MediaFoundation libraries
+#
+# MediaFoundation_LIBRARIES   - List of libraries when using MediaFoundation
+# MediaFoundation_FOUND       - True if MediaFoundation found
+
+IF (MSVC)
+  SET( MediaFoundation_LIBRARIES mf.lib mfplat.lib mfreadwrite.lib mfuuid.lib strmiids.lib )
+  SET( MediaFoundation_FOUND true )
+ENDIF (MSVC)
+
+IF (MediaFoundation_FOUND)
+  IF (NOT MediaFoundation_FIND_QUIETLY)
+    MESSAGE(STATUS "Found MediaFoundation: ${MediaFoundation_LIBRARIES}")
+  ENDIF (NOT MediaFoundation_FIND_QUIETLY)
+ELSE (MediaFoundation_FOUND)
+  IF (MediaFoundation_FIND_REQUIRED)
+    MESSAGE(FATAL_ERROR "Could not find MediaFoundation")
+  ENDIF (MediaFoundation_FIND_REQUIRED)
+ENDIF (MediaFoundation_FOUND)

third-party/DPVO/Pangolin/cmake/FindOculus.cmake

@@ -0,0 +1,63 @@
+# - Try to find Oculus Rift SDK
+#
+#  Oculus_FOUND - system has libuvc
+#  Oculus_INCLUDE_DIRS - the libuvc include directories
+#  Oculus_LIBRARIES - link these to use libuvc
+
+FIND_PATH(
+  Oculus_INCLUDE_DIRS
+  NAMES OVR.h
+  PATHS
+    ${CMAKE_SOURCE_DIR}/../LibOVR/Include
+    ${CMAKE_SOURCE_DIR}/../OculusSDK/LibOVR/Include
+    /usr/include/LibOVR/Include
+    /usr/local/include/LibOVR/Include
+    /opt/local/include/LibOVR/Include
+    /usr/include/
+    /usr/local/include
+    /opt/local/include
+)
+
+FIND_LIBRARY(
+  Oculus_LIBRARIES
+  NAMES ovr
+  PATHS
+    ${CMAKE_SOURCE_DIR}/../LibOVR/Lib/MacOS/Release
+    ${CMAKE_SOURCE_DIR}/../OculusSDK/LibOVR/Lib/Linux/Release/x86_64
+    /usr/include/LibOVR/Lib
+    /usr/local/include/LibOVR/Lib
+    /opt/local/include/LibOVR/Lib
+    /usr/lib
+    /usr/local/lib
+    /opt/local/lib
+)
+
+IF(Oculus_INCLUDE_DIRS AND Oculus_LIBRARIES)
+    IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+        find_library(CARBON_LIBRARIES NAMES Carbon)
+        find_library(IOKIT_LIBRARIES NAMES IOKit)
+        list(APPEND Oculus_LIBRARIES ${CARBON_LIBRARIES})
+        list(APPEND Oculus_LIBRARIES ${IOKIT_LIBRARIES})
+        SET(Oculus_FOUND TRUE)
+    ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+        FIND_PACKAGE(Xrandr QUIET)
+        IF( Xrandr_FOUND )
+            list(APPEND Oculus_LIBRARIES ${Xrandr_LIBRARIES} -ludev -lXrandr -lXinerama )
+            SET(Oculus_FOUND TRUE)
+        ENDIF()
+    ENDIF()
+ENDIF(Oculus_INCLUDE_DIRS AND Oculus_LIBRARIES)
+
+
+
+IF(Oculus_FOUND)
+   IF(NOT Oculus_FIND_QUIETLY)
+      MESSAGE(STATUS "Found Oculus: ${Oculus_LIBRARIES}")
+      MESSAGE(STATUS "Found Oculus: ${Oculus_INCLUDE_DIRS}")
+   ENDIF(NOT Oculus_FIND_QUIETLY)
+ELSE(Oculus_FOUND)
+message(STATUS "Oculus NOT found")
+   IF(Oculus_FIND_REQUIRED)
+      MESSAGE(FATAL_ERROR "Could not find Oculus")
+   ENDIF(Oculus_FIND_REQUIRED)
+ENDIF(Oculus_FOUND)

third-party/DPVO/Pangolin/cmake/FindOpenEXR.cmake

@@ -0,0 +1,33 @@
+# Try to find the OpenEXR v2 lib and include files
+#
+# OpenEXR_INCLUDE_DIR
+# OpenEXR_LIBRARIES
+# OpenEXR_FOUND
+
+FIND_PATH( OpenEXR_INCLUDE_DIR ImfHeader.h
+  /usr/include
+  /usr/local/include
+  PATH_SUFFIXES OpenEXR
+)
+
+FIND_LIBRARY( OpenEXR_LIBRARY IlmImf
+  /usr/lib64
+  /usr/lib
+  /usr/local/lib
+)
+
+IF(OpenEXR_INCLUDE_DIR AND OpenEXR_LIBRARY)
+  SET( OpenEXR_FOUND TRUE )
+  SET( OpenEXR_LIBRARIES ${OpenEXR_LIBRARY} )
+ENDIF()
+
+IF(OpenEXR_FOUND)
+   IF(NOT OpenEXR_FIND_QUIETLY)
+      MESSAGE(STATUS "Found OpenEXR: ${OpenEXR_LIBRARY}")
+   ENDIF(NOT OpenEXR_FIND_QUIETLY)
+ELSE(OpenEXR_FOUND)
+   IF(OpenEXR_FIND_REQUIRED)
+      MESSAGE(FATAL_ERROR "Could not find libOpenEXR")
+   ENDIF(OpenEXR_FIND_REQUIRED)
+ENDIF(OpenEXR_FOUND)
+

third-party/DPVO/Pangolin/cmake/FindOpenNI.cmake

@@ -0,0 +1,58 @@
+###############################################################################
+# Find OpenNI
+#
+#     find_package(OpenNI)
+#
+# Variables defined by this module:
+#
+#  OPENNI_FOUND                True if OpenNI was found
+#  OPENNI_INCLUDE_DIRS         The location(s) of OpenNI headers
+#  OPENNI_LIBRARIES            Libraries needed to use OpenNI
+#  OPENNI_DEFINITIONS          Compiler flags for OpenNI
+
+find_package(PkgConfig QUIET)
+pkg_check_modules(PC_OPENNI QUIET libopenni)
+
+set(OPENNI_DEFINITIONS ${PC_OPENNI_CFLAGS_OTHER})
+
+set(OPENNI_SUFFIX)
+if(WIN32 AND CMAKE_SIZEOF_VOID_P EQUAL 8)
+    set(OPENNI_SUFFIX 64)
+endif()
+
+# Add a hint so that it can find it without the pkg-config
+find_path(OPENNI_INCLUDE_DIR XnStatus.h
+    HINTS ${PC_OPENNI_INCLUDEDIR}
+    ${PC_OPENNI_INCLUDE_DIRS}
+    /usr/include/openni
+    /usr/include/ni
+    /opt/local/include/ni
+    "${OPENNI_ROOT}"
+    "$ENV{OPENNI_ROOT}"
+    PATHS "$ENV{OPEN_NI_INSTALL_PATH${OPENNI_SUFFIX}}/Include"
+    PATH_SUFFIXES openni include Include)
+
+# Add a hint so that it can find it without the pkg-config
+find_library(OPENNI_LIBRARY
+    NAMES OpenNI${OPENNI_SUFFIX}
+    HINTS ${PC_OPENNI_LIBDIR}
+    ${PC_OPENNI_LIBRARY_DIRS}
+    /usr/lib
+    "${OPENNI_ROOT}"
+    "$ENV{OPENNI_ROOT}"
+    PATHS "$ENV{OPEN_NI_LIB${OPENNI_SUFFIX}}"
+    PATH_SUFFIXES lib Lib Lib64)
+
+if(OPENNI_INCLUDE_DIR AND OPENNI_LIBRARY)
+    set(OPENNI_INCLUDE_DIRS ${OPENNI_INCLUDE_DIR})
+    mark_as_advanced(OPENNI_INCLUDE_DIRS)
+
+    set(OPENNI_LIBRARIES ${OPENNI_LIBRARY})
+    mark_as_advanced(OPENNI_LIBRARIES)
+endif()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(OpenNI
+    FOUND_VAR OPENNI_FOUND
+    REQUIRED_VARS OPENNI_LIBRARIES OPENNI_INCLUDE_DIRS
+    )

third-party/DPVO/Pangolin/cmake/FindOpenNI2.cmake

@@ -0,0 +1,59 @@
+###############################################################################
+# Find OpenNI2
+#
+# This sets the following variables:
+# OPENNI2_FOUND - True if OPENNI was found.
+# OPENNI2_INCLUDE_DIRS - Directories containing the OPENNI include files.
+# OPENNI2_LIBRARIES - Libraries needed to use OPENNI.
+
+find_package(PkgConfig)
+if(${CMAKE_VERSION} VERSION_LESS 2.8.2)
+  pkg_check_modules(PC_OPENNI openni2-dev)
+else()
+  pkg_check_modules(PC_OPENNI QUIET openni2-dev)
+endif()
+
+set(OPENNI2_DEFINITIONS ${PC_OPENNI_CFLAGS_OTHER})
+
+#add a hint so that it can find it without the pkg-config
+find_path(OPENNI2_INCLUDE_DIR OpenNI.h
+          HINTS
+            ${PC_OPENNI_INCLUDEDIR}
+            ${PC_OPENNI_INCLUDE_DIRS}
+          PATHS
+            "${PROGRAM_FILES}/OpenNI2/Include"
+            "${CMAKE_SOURCE_DIR}/../OpenNI2/Include"
+            /usr/include
+            /user/include
+          PATH_SUFFIXES openni2 ni2
+)
+
+if(${CMAKE_CL_64})
+    set(OPENNI_PATH_SUFFIXES lib64 lib)
+else()
+    set(OPENNI_PATH_SUFFIXES lib)
+endif()
+
+#add a hint so that it can find it without the pkg-config
+find_library(OPENNI2_LIBRARY
+             NAMES OpenNI2
+             HINTS
+               ${PC_OPENNI_LIBDIR}
+               ${PC_OPENNI_LIBRARY_DIRS}
+             PATHS
+               "${PROGRAM_FILES}/OpenNI2/Redist"
+               "${PROGRAM_FILES}/OpenNI2"
+               "${CMAKE_SOURCE_DIR}/../OpenNI2/Bin/x64-Release"
+               /usr/lib
+               /user/lib
+             PATH_SUFFIXES ${OPENNI_PATH_SUFFIXES}
+)
+
+set(OPENNI2_INCLUDE_DIRS ${OPENNI2_INCLUDE_DIR})
+set(OPENNI2_LIBRARIES ${OPENNI2_LIBRARY})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(OpenNI2 DEFAULT_MSG
+    OPENNI2_LIBRARY OPENNI2_INCLUDE_DIR)
+
+mark_as_advanced(OPENNI2_LIBRARY OPENNI2_INCLUDE_DIR)

third-party/DPVO/Pangolin/cmake/FindPleora.cmake

@@ -0,0 +1,143 @@
+# - Try to find Pleora SDK
+#
+#  Pleora_FOUND - system has pleora eUSB SDK
+#  Pleora_INCLUDE_DIRS - the pleora eUSB SDK include directories
+#  Pleora_LIBRARIES - link these to use pleora eUSB SDK
+#  Pleora_BASE_DIR - set env varivales to this to use pleora eUSB SDK
+
+set( INCLUDE_SEARCH_PATHS
+        "/opt/pleora/ebus_sdk/Ubuntu-12.04-x86_64/include"
+	"/opt/pleora/ebus_sdk/Ubuntu-14.04-x86_64/include"
+	"$ENV{ProgramFiles}/Pleora Technologies Inc/eBUS SDK/Includes"
+)
+
+set( LIBRARIES_SEARCH_PATHS
+	"/opt/pleora/ebus_sdk/Ubuntu-12.04-x86_64/lib"
+	"/opt/pleora/ebus_sdk/Ubuntu-14.04-x86_64/lib"
+	"$ENV{ProgramFiles}/Pleora Technologies Inc/eBUS SDK/Libraries"
+)
+
+set( GENAPI_SEARCH_PATHS
+   "/opt/pleora/ebus_sdk/Ubuntu-12.04-x86_64/lib/genicam/bin/Linux64_x64"
+   "/opt/pleora/ebus_sdk/Ubuntu-12.04-x86_64/lib/genicam/bin/Linux32_ARM"
+   "/opt/pleora/ebus_sdk/Ubuntu-14.04-x86_64/lib/genicam/bin/Linux64_x64"
+   "/opt/pleora/ebus_sdk/Ubuntu-14.04-x86_64/lib/genicam/bin/Linux32_ARM"
+   "$ENV{ProgramW6432}/GenICam_v2_4/library/CPP/lib/Win64_x64"
+)
+
+IF (${CMAKE_CL_64})
+   set (LIB_NAME_SUFFIX "64")
+ELSE()
+   set (LIB_NAME_SUFFIX "")
+ENDIF()
+
+# Find header files
+FIND_PATH(
+  PVBASE_INCLUDE_DIR PvBase.h
+  HINTS ${PC_PLEORA_DIR}/include
+  PATHS ${INCLUDE_SEARCH_PATHS}
+)
+FIND_PATH(
+  PVDEVICE_INCLUDE_DIR PvDevice.h
+  HINTS ${PC_PLEORA_DIR}/include
+  PATHS ${INCLUDE_SEARCH_PATHS}
+)
+FIND_PATH(
+  PVBUFFER_INCLUDE_DIR PvBuffer.h
+  HINTS ${PC_PLEORA_DIR}/include
+  PATHS ${INCLUDE_SEARCH_PATHS}
+)
+FIND_PATH(
+  PVGENICAM_INCLUDE_DIR PvGenICamLib.h
+  HINTS ${PC_PLEORA_DIR}/include
+  PATHS ${INCLUDE_SEARCH_PATHS}
+)
+FIND_PATH(
+  PVSTREAM_INCLUDE_DIR PvStream.h
+  HINTS ${PC_PLEORA_DIR}/include
+  PATHS ${INCLUDE_SEARCH_PATHS}
+)
+FIND_PATH(
+  PVTRANSMITTER_INCLUDE_DIR PvTransmitterLib.h
+  HINTS ${PC_PLEORA_DIR}/include
+  PATHS ${INCLUDE_SEARCH_PATHS}
+)
+FIND_PATH(
+  PVVIRTUALDEVICE_INCLUDE_DIR PvVirtualDeviceLib.h
+  HINTS ${PC_PLEORA_DIR}/include
+  PATHS ${INCLUDE_SEARCH_PATHS}
+)
+FIND_PATH(
+  PVSAMPLEUTILS_INCLUDE_DIR PvSampleUtils.h
+  HINTS ${PC_PLEORA_DIR}/include
+  PATHS ${INCLUDE_SEARCH_PATHS}
+)
+
+# Find Library files
+FIND_LIBRARY(
+  PVBASE_LIBRARY
+  NAMES "PvBase${LIB_NAME_SUFFIX}"
+  HINTS ${PC_PLEORA_DIR}/lib
+  PATH ${LIBRARIES_SEARCH_PATHS}
+)
+FIND_LIBRARY(
+  PVDEVICE_LIBRARY
+  NAMES "PvDevice${LIB_NAME_SUFFIX}"
+  HINTS ${PC_PLEORA_DIR}/lib
+  PATH ${LIBRARIES_SEARCH_PATHS}
+)
+
+FIND_LIBRARY(
+  PVBUFFER_LIBRARY
+  NAMES "PvBuffer${LIB_NAME_SUFFIX}"
+  HINTS ${PC_PLEORA_DIR}/lib
+  PATH ${LIBRARIES_SEARCH_PATHS}
+)
+FIND_LIBRARY(
+  PVGENICAM_LIBRARY
+  NAMES "PvGenICam${LIB_NAME_SUFFIX}"
+  HINTS ${PC_PLEORA_DIR}/lib
+  PATH ${LIBRARIES_SEARCH_PATHS}
+)
+FIND_LIBRARY(
+  PVSTREAM_LIBRARY
+  NAMES "PvStream${LIB_NAME_SUFFIX}"
+  HINTS ${PC_PLEORA_DIR}/lib
+  PATH ${LIBRARIES_SEARCH_PATHS}
+)
+FIND_LIBRARY(
+  PVTRANSMITTER_LIBRARY
+  NAMES "PvTransmitter${LIB_NAME_SUFFIX}"
+  HINTS ${PC_PLEORA_DIR}/lib
+  PATH ${LIBRARIES_SEARCH_PATHS}
+)
+FIND_LIBRARY(
+  PVVIRTUALDEVICE_LIBRARY
+  NAMES "PvVirtualDevice${LIB_NAME_SUFFIX}"
+  HINTS ${PC_PLEORA_DIR}/lib
+  PATH ${LIBRARIES_SEARCH_PATHS}
+)
+FIND_LIBRARY(
+  GENAPI_LIBRARY
+  NAMES GenApi_gcc40_v2_4 GenApi_gcc43_v2_4 GenApi_MD_VC80_v2_4
+  HINTS ${PC_GENAPI_LIBRARY_DIR}
+  PATH ${GENAPI_SEARCH_PATHS}
+)
+
+IF(PVBASE_INCLUDE_DIR AND PVDEVICE_INCLUDE_DIR AND PVBUFFER_INCLUDE_DIR AND PVGENICAM_INCLUDE_DIR AND PVSTREAM_INCLUDE_DIR AND PVTRANSMITTER_INCLUDE_DIR AND PVVIRTUALDEVICE_INCLUDE_DIR AND PVSAMPLEUTILS_INCLUDE_DIR AND PVBASE_LIBRARY AND PVDEVICE_LIBRARY AND PVBUFFER_LIBRARY AND PVGENICAM_LIBRARY AND PVSTREAM_LIBRARY AND PVTRANSMITTER_LIBRARY AND PVVIRTUALDEVICE_LIBRARY AND GENAPI_LIBRARY)
+   SET(Pleora_FOUND TRUE)
+   string(REGEX REPLACE "include$" "" Pleora_BASE_DIR ${PVBASE_INCLUDE_DIR})
+   SET(Pleora_LIBRARIES ${PVBASE_LIBRARY} ${PVDEVICE_LIBRARY} ${PVBUFFER_LIBRARY} ${PVGENICAM_LIBRARY} ${PVSTREAM_LIBRARY} ${PVTRANSMITTER_LIBRARY} ${PVVIRTUALDEVICE_LIBRARY} ${GENAPI_LIBRARY})
+   SET(Pleora_INCLUDE_DIRS ${PVBASE_INCLUDE_DIR} ${PVDEVICE_INCLUDE_DIR} ${PVBUFFER_INCLUDE_DIR} ${PVGENICAM_INCLUDE_DIR} ${PVSTREAM_INCLUDE_DIR} ${PVTRANSMITTER_INCLUDE_DIR} ${PVVIRTUALDEVICE_INCLUDE_DIR} ${PVSAMPLEUTILS_INCLUDE_DIR})
+ENDIF()
+
+
+IF (Pleora_FOUND)
+   IF (NOT Pleora_FIND_QUIETLY)
+      message(STATUS "Found Pleora: ${Pleora_LIBRARIES}")
+   ENDIF (NOT Pleora_FIND_QUIETLY)
+ELSE (Pleora_FOUND)
+   IF (Pleora_FIND_REQUIRED)
+      message(FATAL_ERROR "Could not find Pleora")
+   ENDIF (Pleora_FIND_REQUIRED)
+ENDIF (Pleora_FOUND)

third-party/DPVO/Pangolin/cmake/FindRealSense.cmake

@@ -0,0 +1,33 @@
+# -*- mode: cmake; -*-
+###############################################################################
+# Find realsense  https://github.com/IntelRealSense/librealsense
+#
+# This sets the following variables:
+# REALSENSE_FOUND - True if RealSense was found.
+# REALSENSE_INCLUDE_DIRS - Directories containing the RealSense include files.
+# REALSENSE_LIBRARIES - Libraries needed to use RealSense.
+# REALSENSE_DEFINITIONS - Compiler flags for RealSense.
+#
+# File forked from augmented_dev, project of alantrrs
+# (https://github.com/alantrrs/augmented_dev).
+
+find_package(PkgConfig)
+if(${CMAKE_VERSION} VERSION_LESS 2.8.2)
+endif()
+
+#add a hint so that it can find it without the pkg-config
+find_path(REALSENSE_INCLUDE_DIR librealsense/rs.h
+    HINTS /usr/include/  /usr/local/include)
+#add a hint so that it can find it without the pkg-config
+find_library(REALSENSE_LIBRARY
+    NAMES realsense
+    HINTS /usr/lib /usr/local/lib )
+
+  set(REALSENSE_INCLUDE_DIRS ${REALSENSE_INCLUDE_DIR})
+  set(REALSENSE_LIBRARIES ${REALSENSE_LIBRARY})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(RealSense DEFAULT_MSG
+  REALSENSE_LIBRARY REALSENSE_INCLUDE_DIR)
+
+mark_as_advanced(REALSENSE_LIBRARY REALSENSE_INCLUDE_DIR)

third-party/DPVO/Pangolin/cmake/FindRealSense2.cmake

@@ -0,0 +1,33 @@
+# -*- mode: cmake; -*-
+###############################################################################
+# Find realsense2  https://github.com/IntelRealSense/librealsense
+#
+# This sets the following variables:
+# REALSENSE2_FOUND - True if REALSENSE2 was found.
+# REALSENSE2_INCLUDE_DIRS - Directories containing the REALSENSE2 include files.
+# REALSENSE2_LIBRARIES - Libraries needed to use REALSENSE2.
+# REALSENSE2_DEFINITIONS - Compiler flags for REALSENSE2.
+#
+# File forked from augmented_dev, project of alantrrs
+# (https://github.com/alantrrs/augmented_dev).
+
+find_package(PkgConfig)
+if(${CMAKE_VERSION} VERSION_LESS 2.8.2)
+endif()
+
+#add a hint so that it can find it without the pkg-config
+find_path(REALSENSE2_INCLUDE_DIR librealsense2/rs.h
+    HINTS /usr/include/  /usr/local/include)
+#add a hint so that it can find it without the pkg-config
+find_library(REALSENSE2_LIBRARY
+    NAMES realsense2
+    HINTS /usr/lib /usr/local/lib )
+
+  set(REALSENSE2_INCLUDE_DIRS ${REALSENSE2_INCLUDE_DIR})
+  set(REALSENSE2_LIBRARIES ${REALSENSE2_LIBRARY})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(RealSense2 DEFAULT_MSG
+  REALSENSE2_LIBRARY REALSENSE2_INCLUDE_DIR)
+
+mark_as_advanced(REALSENSE2_LIBRARY REALSENSE2_INCLUDE_DIR)

third-party/DPVO/Pangolin/cmake/FindTeliCam.cmake

@@ -0,0 +1,58 @@
+###############################################################################
+# Find Toshiba TeliCam
+#
+# This sets the following variables:
+# TeliCam_FOUND - True if TeliCam was found.
+# TeliCam_INCLUDE_DIRS - Directories containing the TeliCam include files.
+# TeliCam_LIBRARIES - Libraries needed to use TeliCam.
+
+find_path(
+    TeliCam_INCLUDE_DIR TeliCamApi.h
+    PATHS
+        "${PROGRAM_FILES}/Toshiba Teli/TeliCamSDK/TeliCamApi/Include"
+        "${CMAKE_SOURCE_DIR}/../TeliCamSDK/TeliCamApi/Include"
+        /usr/include
+        /user/include
+	/opt/TeliCamSDK/include
+    PATH_SUFFIXES TeliCam
+)
+
+if(${CMAKE_CL_64})
+    set(TELI_PATH_SUFFIXES x64)
+else()
+    set(TELI_PATH_SUFFIXES x86)
+endif()
+
+find_library(
+    TeliCamApi_LIBRARY
+    NAMES TeliCamApi TeliCamApi64 TeliCamApi_64
+    PATHS
+        "${PROGRAM_FILES}/Toshiba Teli/TeliCamSDK/TeliCamApi/lib"
+        "${CMAKE_SOURCE_DIR}/../TeliCamSDK/TeliCamApi/lib"
+        /usr/lib
+        /user/lib
+	/opt/TeliCamSDK/lib
+    PATH_SUFFIXES ${TELI_PATH_SUFFIXES}
+)
+
+find_library(
+    TeliCamUtl_LIBRARY
+    NAMES TeliCamUtl TeliCamUtl64 TeliCamUtl_64
+    PATHS
+        "${PROGRAM_FILES}/Toshiba Teli/TeliCamSDK/TeliCamApi/lib"
+        "${CMAKE_SOURCE_DIR}/../TeliCamSDK/TeliCamApi/lib"
+        /usr/lib
+        /user/lib
+	/opt/TeliCamSDK/lib
+    PATH_SUFFIXES ${TELI_PATH_SUFFIXES}
+)
+
+set(TeliCam_INCLUDE_DIRS ${TeliCam_INCLUDE_DIR})
+set(TeliCam_LIBRARY "${TeliCamApi_LIBRARY}" "${TeliCamUtl_LIBRARY}")
+set(TeliCam_LIBRARIES ${TeliCam_LIBRARY})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args( TeliCam
+  FOUND_VAR TeliCam_FOUND
+  REQUIRED_VARS TeliCamApi_LIBRARY TeliCamUtl_LIBRARY TeliCam_INCLUDE_DIR
+)

third-party/DPVO/Pangolin/cmake/FindTooN.cmake

@@ -0,0 +1,28 @@
+# - Try to find libTooN
+#
+#  TooN_FOUND - system has libTooN
+#  TooN_INCLUDE_DIR - the libTooN include directories
+
+FIND_PATH(
+  TooN_INCLUDE_DIR
+  NAMES TooN/TooN.h
+  PATHS
+    ${CMAKE_SOURCE_DIR}
+    ${CMAKE_SOURCE_DIR}/..
+    /usr/include
+    /usr/local/include
+)
+
+IF(TooN_INCLUDE_DIR)
+  SET(TooN_FOUND TRUE)
+ENDIF()
+
+IF(TooN_FOUND)
+   IF(NOT TooN_FIND_QUIETLY)
+      MESSAGE(STATUS "Found TooN: ${TooN_INCLUDE_DIR}")
+   ENDIF()
+ELSE()
+   IF(TooN_FIND_REQUIRED)
+      MESSAGE(FATAL_ERROR "Could not find TooN")
+   ENDIF()
+ENDIF()

third-party/DPVO/Pangolin/cmake/FindXrandr.cmake

@@ -0,0 +1,32 @@
+# - Try to find Xrandr
+#
+#  Xrandr_FOUND - system has libXrandr
+#  Xrandr_INCLUDE_DIRS - the libXrandr include directories
+#  Xrandr_LIBRARIES - link these to use libXrandr
+
+FIND_PATH(
+  Xrandr_INCLUDE_DIRS
+  NAMES X11/extensions/Xrandr.h
+  PATH_SUFFIXES X11/extensions
+  DOC "The Xrandr include directory"
+)
+
+FIND_LIBRARY(
+  Xrandr_LIBRARIES
+  NAMES Xrandr
+  DOC "The Xrandr library"
+)
+
+IF (Xrandr_INCLUDE_DIRS AND Xrandr_LIBRARIES)
+   SET(Xrandr_FOUND TRUE)
+ENDIF (Xrandr_INCLUDE_DIRS AND Xrandr_LIBRARIES)
+
+IF (Xrandr_FOUND)
+   IF (NOT Xrandr_FIND_QUIETLY)
+      MESSAGE(STATUS "Found Xrandr: ${Xrandr_LIBRARIES}")
+   ENDIF (NOT Xrandr_FIND_QUIETLY)
+ELSE (Xrandr_FOUND)
+   IF (Xrandr_FIND_REQUIRED)
+      MESSAGE(FATAL_ERROR "Could not find Xrandr")
+   ENDIF (Xrandr_FIND_REQUIRED)
+ENDIF (Xrandr_FOUND)

third-party/DPVO/Pangolin/cmake/Findlibusb1.cmake

@@ -0,0 +1,43 @@
+# - Try to find libusb1
+#
+#  libusb1_FOUND - system has libusb1
+#  libusb1_INCLUDE_DIRS - the libusb1 include directories
+#  libusb1_LIBRARIES - link these to use libusb1
+
+FIND_PATH(
+  libusb1_INCLUDE_DIRS
+  NAMES libusb-1.0/libusb.h
+  PATHS
+    c:/dev/sysroot32/usr/include
+    ${CMAKE_SOURCE_DIR}/../libusb1/include
+    /usr/include/
+    /usr/local/include
+    /opt/local/include
+)
+
+FIND_LIBRARY(
+  libusb1_LIBRARIES
+  NAMES usb-1.0
+  PATHS
+    c:/dev/sysroot32/usr/lib
+    ${CMAKE_SOURCE_DIR}/../libusb1/lib
+    /usr/lib
+    /usr/lib64
+    /usr/local/lib
+    /opt/local/lib
+)
+
+IF(libusb1_INCLUDE_DIRS AND libusb1_LIBRARIES)
+  SET(libusb1_FOUND TRUE)
+ENDIF(libusb1_INCLUDE_DIRS AND libusb1_LIBRARIES)
+
+IF(libusb1_FOUND)
+   IF(NOT libusb1_FIND_QUIETLY)
+      MESSAGE(STATUS "Found libusb1: ${libusb1_LIBRARIES}")
+   ENDIF(NOT libusb1_FIND_QUIETLY)
+ELSE(libusb1_FOUND)
+message(STATUS "libusb1 NOT found")
+   IF(libusb1_FIND_REQUIRED)
+      MESSAGE(FATAL_ERROR "Could not find libusb1")
+   ENDIF(libusb1_FIND_REQUIRED)
+ENDIF(libusb1_FOUND)

third-party/DPVO/Pangolin/cmake/Findpthread.cmake

@@ -0,0 +1,42 @@
+# - Try to find pthread
+#
+#  pthread_FOUND - system has pthread
+#  pthread_INCLUDE_DIRS - the pthread include directories
+#  pthread_LIBRARIES - link these to use pthread
+
+FIND_PATH(
+  pthread_INCLUDE_DIRS
+  NAMES pthread.h
+  PATHS
+    c:/dev/sysroot32/usr/include
+    ${CMAKE_SOURCE_DIR}/../pthread/include
+    /usr/include/
+    /usr/local/include
+    /opt/local/include
+)
+
+FIND_LIBRARY(
+  pthread_LIBRARIES
+  NAMES pthreadVSE2 pthread
+  PATHS
+    c:/dev/sysroot32/usr/lib
+    ${CMAKE_SOURCE_DIR}/../pthread/lib
+    /usr/lib
+    /usr/local/lib
+    /opt/local/lib
+)
+
+IF(pthread_INCLUDE_DIRS AND pthread_LIBRARIES)
+  SET(pthread_FOUND TRUE)
+ENDIF(pthread_INCLUDE_DIRS AND pthread_LIBRARIES)
+
+IF(pthread_FOUND)
+   IF(NOT pthread_FIND_QUIETLY)
+      MESSAGE(STATUS "Found pthread: ${pthread_LIBRARIES}")
+   ENDIF(NOT pthread_FIND_QUIETLY)
+ELSE(pthread_FOUND)
+message(STATUS "pthread NOT found")
+   IF(pthread_FIND_REQUIRED)
+      MESSAGE(FATAL_ERROR "Could not find pthread")
+   ENDIF(pthread_FIND_REQUIRED)
+ENDIF(pthread_FOUND)

third-party/DPVO/Pangolin/cmake/Finduvc.cmake

@@ -0,0 +1,39 @@
+# - Try to find uvc
+#
+#  uvc_FOUND - system has libuvc
+#  uvc_INCLUDE_DIRS - the libuvc include directories
+#  uvc_LIBRARIES - link these to use libuvc
+
+FIND_PATH(
+  uvc_INCLUDE_DIRS
+  NAMES libuvc/libuvc.h
+  PATHS 
+    ${CMAKE_SOURCE_DIR}/..
+    /usr/include/
+    /usr/local/include
+    /opt/local/include
+)
+
+FIND_LIBRARY(
+  uvc_LIBRARIES
+  NAMES uvc
+  PATHS
+    ${CMAKE_SOURCE_DIR}/../uvc/build
+    /usr/lib
+    /usr/local/lib
+    /opt/local/lib
+) 
+
+IF (uvc_INCLUDE_DIRS AND uvc_LIBRARIES)
+   SET(uvc_FOUND TRUE)
+ENDIF (uvc_INCLUDE_DIRS AND uvc_LIBRARIES)
+
+IF (uvc_FOUND)
+   IF (NOT uvc_FIND_QUIETLY)
+      MESSAGE(STATUS "Found uvc: ${uvc_LIBRARIES}")
+   ENDIF (NOT uvc_FIND_QUIETLY)
+ELSE (uvc_FOUND)
+   IF (uvc_FIND_REQUIRED)
+      MESSAGE(FATAL_ERROR "Could not find uvc")
+   ENDIF (uvc_FIND_REQUIRED)
+ENDIF (uvc_FOUND)

third-party/DPVO/Pangolin/cmake/Findzstd.cmake

@@ -0,0 +1,35 @@
+###############################################################################
+# Find Toshiba TeliCam
+#
+# This sets the following variables:
+# TeliCam_FOUND - True if TeliCam was found.
+# TeliCam_INCLUDE_DIRS - Directories containing the TeliCam include files.
+# TeliCam_LIBRARIES - Libraries needed to use TeliCam.
+
+find_path(
+    zstd_INCLUDE_DIR zstd.h
+    PATHS
+        /opt/local/include
+        /usr/local/include
+        /usr/include
+    PATH_SUFFIXES TeliCam
+)
+
+find_library(
+    zstd_LIBRARY
+    NAMES zstd
+    PATHS
+        /opt/local/lib
+        /user/local/lib
+        /usr/lib
+)
+
+# Plural forms
+set(zstd_INCLUDE_DIRS ${zstd_INCLUDE_DIR})
+set(zstd_LIBRARIES ${zstd_LIBRARY})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args( zstd
+  FOUND_VAR zstd_FOUND
+  REQUIRED_VARS zstd_INCLUDE_DIR zstd_LIBRARY
+)

third-party/DPVO/Pangolin/cmake/MakePythonWheel.cmake

@@ -0,0 +1,104 @@
+# Useful references:
+#  https://thomastrapp.com/blog/building-a-pypi-package-for-a-modern-cpp-project/ for reference
+#  https://www.benjack.io/2017/06/12/python-cpp-tests.html also interesting
+#  https://www.python.org/dev/peps/pep-0427/ the official package format description
+
+set(_MAKE_PYTHON_WHEEL_LIST_DIR "${CMAKE_CURRENT_LIST_DIR}")
+
+function( MakeWheel python_module)
+    cmake_parse_arguments(MAKEWHEEL "PRINT_HELP" "MODULE;VERSION;SUMMARY;DESCRIPTION;HOMEPAGE;AUTHOR;EMAIL;LICENCE" "REQUIRES" ${ARGN} )
+    set(version ${MAKEWHEEL_VERSION})
+
+    execute_process(
+        COMMAND ${Python_EXECUTABLE} -c "
+from setuptools.dist import Distribution
+from setuptools import Extension
+
+def wheel_name(**kwargs):
+    # create a fake distribution from arguments
+    dist = Distribution(attrs=kwargs)
+    # finalize bdist_wheel command
+    bdist_wheel_cmd = dist.get_command_obj('bdist_wheel')
+    bdist_wheel_cmd.ensure_finalized()
+    # assemble wheel file name
+    distname = bdist_wheel_cmd.wheel_dist_name
+    tag = '-'.join(bdist_wheel_cmd.get_tag())
+    return f'{distname};{tag}'
+
+print(wheel_name(name='${python_module}', version='${version}', ext_modules=[Extension('dummy', ['summy.c'])]))
+"
+        OUTPUT_VARIABLE wheel_filename
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        ERROR_QUIET
+    )
+    if(NOT wheel_filename)
+        message(STATUS "Python module `setuptools` required for correct wheel filename generation. Please install if needed.")
+        set(wheel_filename "unknown;unknown")
+    endif()
+
+    list(GET wheel_filename 0 distname)
+    list(GET wheel_filename 1 platformtag)
+    set(complete_tag "${distname}-${platformtag}")
+
+    set(wheel_filename "${CMAKE_BINARY_DIR}/${complete_tag}.whl")
+    set(wheel_distinfo "${CMAKE_BINARY_DIR}/${python_module}-${version}.dist-info")
+    set(wheel_data "${CMAKE_BINARY_DIR}/${python_module}-${version}.data")
+    set(wheel_generator_string "pango_wheelgen_${version}")
+
+    if( MAKEWHEEL_REQUIRES )
+        set(MAKEWHEEL_REQUIRES "Requires-Dist: ${MAKEWHEEL_REQUIRES}")
+        string(REPLACE ";" "\nRequires-Dist: " MAKEWHEEL_REQUIRES "${MAKEWHEEL_REQUIRES}")
+    endif()
+
+    ##########################################
+    ## Create dist info folder
+    file(GLOB wheel_info_files "${_MAKE_PYTHON_WHEEL_LIST_DIR}/wheel-dist-info/*" )
+    file(WRITE "${wheel_distinfo}/RECORD" "")
+    foreach(template_path ${wheel_info_files})
+        get_filename_component(template_name "${template_path}" NAME)
+        configure_file( ${template_path} "${wheel_distinfo}/${template_name}" )
+        file(SHA256 "${template_path}" file_sha)
+        file (SIZE "${template_path}" file_size)
+        file(APPEND "${wheel_distinfo}/RECORD" "${python_module}-${version}.dist-info/${template_name},sha256=${file_sha},${file_size}\n")
+    endforeach()
+
+    # TODO: Add line in RECORD for .so module itself (needs to be build time)
+
+    ##########################################
+    ## Place module into data folder
+    set_target_properties( ${python_module} PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${wheel_data}/purelib")
+
+    ##########################################
+    ## Rule for creating file wheel zip
+    add_custom_command(
+        OUTPUT ${wheel_filename}
+        DEPENDS ${python_module}
+        COMMAND ${CMAKE_COMMAND} -E tar cf ${wheel_filename} --format=zip -- ${wheel_distinfo} ${wheel_data}
+        COMMENT "Creating Wheel ${wheel_filename}"
+        VERBATIM
+    )
+
+    ##########################################
+    ## Create a friendlier target name we can refer to
+    add_custom_target("${python_module}_wheel" DEPENDS "${wheel_filename}")
+
+    add_custom_target(
+        "${python_module}_pip_install"
+        DEPENDS "${python_module}_wheel"
+        COMMAND ${Python_EXECUTABLE} -mpip install "${wheel_filename}" --force-reinstall
+        COMMENT "Installing for selected Python '${Python_EXECUTABLE}'"
+    )
+
+    add_custom_target(
+        "${python_module}_pip_uninstall"
+        COMMAND ${Python_EXECUTABLE} -mpip uninstall -y ${python_module}
+    )
+
+    ##########################################
+    ## Help message since this is tricky for people
+    if(MAKEWHEEL_PRINT_HELP)
+        message(STATUS "Selected Python: '${Python_EXECUTABLE}'. cmake --build . -t ${python_module}_pip_install to use ${python_module} module.")
+    endif()
+endfunction()
+
+

third-party/DPVO/Pangolin/cmake/PangolinConfig.cmake.in

@@ -0,0 +1,18 @@
+# Compute paths
+get_filename_component( PROJECT_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH )
+
+# Library dependencies (contains definitions for IMPORTED targets)
+if( NOT @PROJECT_NAME@_BINARY_DIR )
+  include( "${PROJECT_CMAKE_DIR}/@[email protected]" )
+endif()
+
+SET( Pangolin_CMAKEMODULES @CMAKE_CURRENT_SOURCE_DIR@/cmake )
+SET( Pangolin_LIBRARIES    @component_list@ )
+SET( Pangolin_LIBRARY      "${Pangolin_LIBRARIES}" )
+
+include(CMakeFindDependencyMacro)
+find_dependency(Eigen3)
+
+if (UNIX)
+  find_dependency(Threads)
+endif()

third-party/DPVO/Pangolin/cmake/PangolinConfigVersion.cmake.in

@@ -0,0 +1,17 @@
+set(PACKAGE_VERSION "@PANGOLIN_VERSION@")
+
+# Check build type is valid
+if( "System:${CMAKE_SYSTEM_NAME},Win64:${CMAKE_CL_64},Android:${ANDROID},iOS:${IOS}" STREQUAL
+    "System:@CMAKE_SYSTEM_NAME@,Win64:@CMAKE_CL_64@,Android:@ANDROID@,iOS:@IOS@" )
+    # Check whether the requested PACKAGE_FIND_VERSION is compatible
+    if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}")
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    else()
+      set(PACKAGE_VERSION_COMPATIBLE TRUE)
+      if ("${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}")
+        set(PACKAGE_VERSION_EXACT TRUE)
+      endif()
+    endif()
+else()
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+endif()

third-party/DPVO/Pangolin/cmake/PangolinFactory.cmake

@@ -0,0 +1,56 @@
+# Provide factory names as list of arguments to use for later
+macro( PangolinRegisterFactory interface_name)
+    list(APPEND PANGO_FACTORY_INTERFACES "${interface_name}")
+    list(REMOVE_DUPLICATES PANGO_FACTORY_INTERFACES)
+    foreach(arg ${ARGN})
+        list(APPEND PANGO_FACTORY_${interface_name} "${arg}")
+    endforeach()
+endmacro()
+
+# Actually Create the method call file
+macro(create_factory_registry_file_now filename namespace interface_name)
+    list(APPEND factory_names ${ARGN})
+
+    file(WRITE ${filename} "// CMake generated file. Do Not Edit.\n\n#pragma once\n\nnamespace ${namespace} {\n\n")
+
+    file(APPEND ${filename} "  // Forward declarations\n")
+    foreach(factory_name ${factory_names})
+#        file(APPEND ${filename} "  bool Load${factory_name}Success;\n")
+        file(APPEND ${filename} "  bool Register${factory_name}Factory();\n")
+    endforeach()
+
+    file(APPEND ${filename} "\n\n")
+
+    file(APPEND ${filename} "  inline bool RegisterFactories${interface_name}() {\n")
+    file(APPEND ${filename} "    bool success = true;\n")
+
+    foreach(factory_name ${factory_names})
+#        file(APPEND ${filename} "    success &= Load${factory_name}Success;\n")
+        file(APPEND ${filename} "    success &= Register${factory_name}Factory();\n")
+    endforeach()
+    file(APPEND ${filename} "    return success;\n")
+    file(APPEND ${filename} "  }\n")
+
+    file(APPEND ${filename} "\n\n} // ${namespace}\n")
+endmacro()
+
+# Sets up target for creating the file.
+macro(create_factory_registry_file directory interface_name)
+    set(filename "${directory}/RegisterFactories${interface_name}.h")
+    add_custom_command(
+        OUTPUT ${filename}
+        DEPENDS ${PROJECT_SOURCE_DIR}/cmake/PangolinFactory.cmake
+        COMMAND
+            ${CMAKE_COMMAND} -DFILENAME=${filename}
+                             -DNAMESPACE=pangolin
+                             -DINTERFACE_NAME=${interface_name}
+                             "\"-DFACTORY_NAMES=${PANGO_FACTORY_${interface_name}}\""
+                             -P ${PROJECT_SOURCE_DIR}/cmake/PangolinFactory.cmake
+        COMMENT "Creating ${filename} factory registry header"
+    )
+endmacro()
+
+if(CMAKE_SCRIPT_MODE_FILE AND NOT CMAKE_PARENT_LIST_FILE)
+    # Running in script mode as part of build-time procedure to actually to the thing
+    create_factory_registry_file_now(${FILENAME} ${NAMESPACE} ${INTERFACE_NAME} ${FACTORY_NAMES} )
+endif()

third-party/DPVO/Pangolin/cmake/SetPlatformVars.cmake

@@ -0,0 +1,56 @@
+## Compiler configuration
+IF(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_GNUCC)
+  SET(_GCC_ 1)
+ENDIF()
+
+IF(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
+  SET(_CLANG_ 1)
+ENDIF()
+
+IF(MSVC)
+    SET(_MSVC_ 1)
+ENDIF()
+
+## Platform configuration
+
+IF(WIN32 OR WIN64)
+    SET(_WIN_ 1)
+ENDIF()
+
+IF(UNIX)
+    SET(_UNIX_ 1)
+ENDIF()
+
+IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+    SET(_OSX_ 1)
+ENDIF()
+
+IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+    SET(_LINUX_ 1)
+ENDIF()
+
+IF(ANDROID)
+    SET(_ANDROID_ 1)
+ENDIF()
+
+IF(IOS)
+    SET(_APPLE_IOS_ 1)
+ENDIF()
+
+
+
+## Default search paths
+
+IF(_WIN_)
+    IF(${CMAKE_CL_64})
+        LIST(APPEND CMAKE_INCLUDE_PATH "c:/dev/sysroot64/usr/include")
+        LIST(APPEND CMAKE_LIBRARY_PATH "c:/dev/sysroot64/usr/lib")
+        LIST(APPEND CMAKE_LIBRARY_PATH "c:/dev/sysroot64/usr/bin")
+        set(PROGRAM_FILES "$ENV{PROGRAMW6432}" )
+    ELSE()
+        LIST(APPEND CMAKE_INCLUDE_PATH "c:/dev/sysroot32/usr/include")
+        LIST(APPEND CMAKE_LIBRARY_PATH "c:/dev/sysroot32/usr/lib")
+        LIST(APPEND CMAKE_LIBRARY_PATH "c:/dev/sysroot32/usr/bin")
+        set(PROGRAM_FILES "$ENV{PROGRAMFILES}" )
+    ENDIF()
+ENDIF()

third-party/DPVO/Pangolin/cmake/cmake_uninstall.cmake.in

@@ -0,0 +1,21 @@
+if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
+  message(FATAL_ERROR "Cannot find install manifest: @CMAKE_BINARY_DIR@/install_manifest.txt")
+endif()
+
+file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files)
+string(REGEX REPLACE "\n" ";" files "${files}")
+foreach(file ${files})
+  message(STATUS "Uninstalling $ENV{DESTDIR}${file}")
+  if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR 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()
+  else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
+    message(STATUS "File $ENV{DESTDIR}${file} does not exist.")
+  endif()
+endforeach()

third-party/DPVO/Pangolin/cmake/wheel-dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: @python_module@
+Version: @MAKEWHEEL_VERSION@
+Summary: @MAKEWHEEL_SUMMARY@
+Home-page: @MAKEWHEEL_HOMEPAGE@
+Author: @MAKEWHEEL_AUTHOR@
+Author-email: @MAKEWHEEL_EMAIL@
+License: @MAKEWHEEL_LICENCE@
+Description-Content-Type: text/markdown
+@MAKEWHEEL_REQUIRES@
+
+@MAKEWHEEL_DESCRIPTION@

third-party/DPVO/Pangolin/cmake/wheel-dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: @wheel_generator_string@
+Root-Is-Purelib: false
+Tag: @complete_tag@
+

third-party/DPVO/Pangolin/cmake/wheel-dist-info/top_level.txt

@@ -0,0 +1 @@
+@python_module@

third-party/DPVO/evaluate_icl_nuim.py

@@ -0,0 +1,141 @@
+import glob
+import os
+from multiprocessing import Process, Queue
+from pathlib import Path
+
+import cv2
+import evo.main_ape as main_ape
+import numpy as np
+import torch
+from evo.core import sync
+from evo.core.metrics import PoseRelation
+from evo.core.trajectory import PoseTrajectory3D
+from evo.tools import file_interface
+
+from dpvo.config import cfg
+from dpvo.dpvo import DPVO
+from dpvo.plot_utils import plot_trajectory
+from dpvo.stream import image_stream
+from dpvo.utils import Timer
+
+SKIP = 0
+
+def show_image(image, t=0):
+    image = image.permute(1, 2, 0).cpu().numpy()
+    cv2.imshow('image', image / 255.0)
+    cv2.waitKey(t)
+
+@torch.no_grad()
+def run(cfg, network, imagedir, calib, stride=1, viz=False, show_img=False):
+
+    slam = None
+
+    queue = Queue(maxsize=8)
+    reader = Process(target=image_stream, args=(queue, imagedir, calib, stride, 0))
+    reader.start()
+
+    while 1:
+        (t, image, intrinsics) = queue.get()
+        if t < 0: break
+
+        image = torch.from_numpy(image).permute(2,0,1).cuda()
+        intrinsics = torch.from_numpy(intrinsics).cuda()
+
+        if show_img:
+            show_image(image, 1)
+
+        if slam is None:
+            slam = DPVO(cfg, network, ht=image.shape[1], wd=image.shape[2], viz=viz)
+
+        with Timer("SLAM", enabled=False):
+            slam(t, image, intrinsics)
+
+    reader.join()
+
+    return slam.terminate()
+
+
+if __name__ == '__main__':
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--network', type=str, default='dpvo.pth')
+    parser.add_argument('--config', default="config/default.yaml")
+    parser.add_argument('--stride', type=int, default=2)
+    parser.add_argument('--viz', action="store_true")
+    parser.add_argument('--show_img', action="store_true")
+    parser.add_argument('--trials', type=int, default=1)
+    parser.add_argument('--iclnuim_dir', default="datasets/ICL_NUIM", type=Path)
+    parser.add_argument('--backend_thresh', type=float, default=64.0)
+    parser.add_argument('--plot', action="store_true")
+    parser.add_argument('--opts', nargs='+', default=[])
+    parser.add_argument('--save_trajectory', action="store_true")
+    args = parser.parse_args()
+
+    cfg.merge_from_file(args.config)
+    cfg.BACKEND_THRESH = args.backend_thresh
+    cfg.merge_from_list(args.opts)
+
+    print("\nRunning with config...")
+    print(cfg, "\n")
+
+    torch.manual_seed(1234)
+
+    scenes = [
+        "living_room_traj0_loop",
+        "living_room_traj1_loop",
+        "living_room_traj2_loop",
+        "living_room_traj3_loop",
+        "office_room_traj0_loop",
+        "office_room_traj1_loop",
+        "office_room_traj2_loop",
+        "office_room_traj3_loop",
+    ]
+
+    results = {}
+    for scene in scenes:
+        imagedir = args.iclnuim_dir / scene
+        if scene.startswith("living"):
+            groundtruth = args.iclnuim_dir / f"TrajectoryGT" / f"livingRoom{scene[-6]}.gt.freiburg"
+        elif scene.startswith("office"):
+            groundtruth = args.iclnuim_dir / f"TrajectoryGT" / f"traj{scene[-6]}.gt.freiburg"
+        traj_ref = file_interface.read_tum_trajectory_file(groundtruth)
+
+        scene_results = []
+        for i in range(args.trials):
+            traj_est, timestamps = run(cfg, args.network, imagedir, "calib/icl_nuim.txt", args.stride, args.viz, args.show_img)
+
+            images_list = sorted(glob.glob(os.path.join(imagedir, "*.png")))[::args.stride]
+            tstamps = np.arange(1, len(images_list)+1, args.stride, dtype=np.float64)
+
+            traj_est = PoseTrajectory3D(
+                positions_xyz=traj_est[:,:3],
+                orientations_quat_wxyz=traj_est[:, [6, 3, 4, 5]],
+                timestamps=tstamps)
+
+            traj_ref, traj_est = sync.associate_trajectories(traj_ref, traj_est)
+
+            result = main_ape.ape(traj_ref, traj_est, est_name='traj', 
+                pose_relation=PoseRelation.translation_part, align=True, correct_scale=True)
+            ate_score = result.stats["rmse"]
+
+            if args.plot:
+                scene_name = scene.rstrip("_loop").title()
+                Path("trajectory_plots").mkdir(exist_ok=True)
+                plot_trajectory(traj_est, traj_ref, f"ICL_NUIM {scene_name} Trial #{i+1} (ATE: {ate_score:.03f})",
+                                f"trajectory_plots/ICL_NUIM_{scene_name}_Trial{i+1:02d}.pdf", align=True, correct_scale=True)
+
+            if args.save_trajectory:
+                Path("saved_trajectories").mkdir(exist_ok=True)
+                file_interface.write_tum_trajectory_file(f"saved_trajectories/ICL_NUIM_{scene_name}_Trial{i+1:02d}.txt", traj_est)
+
+            scene_results.append(ate_score)
+
+        results[scene] = np.median(scene_results)
+        print(scene, sorted(scene_results))
+
+    xs = []
+    for scene in results:
+        print(scene, results[scene])
+        xs.append(results[scene])
+
+    print("AVG: ", np.mean(xs))

third-party/DPVO/evaluate_kitti.py

@@ -0,0 +1,168 @@
+from itertools import count
+from multiprocessing import Process, Queue
+from pathlib import Path
+
+import cv2
+import evo.main_ape as main_ape
+import numpy as np
+import torch
+from evo.core import sync
+from evo.core.metrics import PoseRelation
+from evo.core.trajectory import PoseTrajectory3D
+from evo.tools import file_interface, plot
+
+from dpvo.config import cfg
+from dpvo.dpvo import DPVO
+from dpvo.plot_utils import plot_trajectory
+from dpvo.utils import Timer
+
+SKIP = 0
+
+def show_image(image, t=0):
+    image = image.permute(1, 2, 0).cpu().numpy()
+    cv2.imshow('image', image / 255.0)
+    cv2.waitKey(t)
+
+# From https://github.com/utiasSTARS/pykitti/blob/d3e1bb81676e831886726cc5ed79ce1f049aef2c/pykitti/utils.py#L68
+def read_calib_file(filepath):
+    """Read in a calibration file and parse into a dictionary."""
+    data = {}
+
+    with open(filepath, 'r') as f:
+        for line in f.readlines():
+            key, value = line.split(':', 1)
+            # The only non-float values in these files are dates, which
+            # we don't care about anyway
+            try:
+                data[key] = np.array([float(x) for x in value.split()])
+            except ValueError:
+                pass
+
+    return data
+
+def kitti_image_stream(queue, kittidir, sequence, stride, skip=0):
+    """ image generator """
+    images_dir = kittidir / "dataset" / "sequences" / sequence
+    image_list = sorted((images_dir / "image_2").glob("*.png"))[skip::stride]
+
+    calib = read_calib_file(images_dir / "calib.txt")
+    intrinsics = calib['P0'][[0, 5, 2, 6]]
+
+    for t, imfile in enumerate(image_list):
+        image_left = cv2.imread(str(imfile))
+        H, W, _ = image_left.shape
+        H, W = (H - H%4, W - W%4)
+        image_left = image_left[..., :H, :W, :]
+
+        queue.put((t, image_left, intrinsics))
+
+    queue.put((-1, image_left, intrinsics))
+
+@torch.no_grad()
+def run(cfg, network, kittidir, sequence, stride=1, viz=False, show_img=False):
+
+    slam = None
+
+    queue = Queue(maxsize=8)
+    reader = Process(target=kitti_image_stream, args=(queue, kittidir, sequence, stride, 0))
+    reader.start()
+
+    for step in count(start=1):
+        (t, image, intrinsics) = queue.get()
+        if t < 0: break
+
+        image = torch.as_tensor(image, device='cuda').permute(2,0,1)
+        intrinsics = torch.as_tensor(intrinsics, dtype=torch.float, device='cuda')
+
+        if show_img:
+            show_image(image, 1)
+
+        if slam is None:
+            slam = DPVO(cfg, network, ht=image.shape[-2], wd=image.shape[-1], viz=viz)
+
+        intrinsics = intrinsics.cuda()
+
+        with Timer("SLAM", enabled=False):
+            slam(t, image, intrinsics)
+
+    reader.join()
+
+    return slam.terminate()
+
+
+if __name__ == '__main__':
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--network', type=str, default='dpvo.pth')
+    parser.add_argument('--config', default="config/default.yaml")
+    parser.add_argument('--stride', type=int, default=2)
+    parser.add_argument('--viz', action="store_true")
+    parser.add_argument('--show_img', action="store_true")
+    parser.add_argument('--trials', type=int, default=1)
+    parser.add_argument('--kittidir', type=Path, default="datasets/KITTI")
+    parser.add_argument('--backend_thresh', type=float, default=32.0)
+    parser.add_argument('--plot', action="store_true")
+    parser.add_argument('--opts', nargs='+', default=[])
+    parser.add_argument('--save_trajectory', action="store_true")
+    args = parser.parse_args()
+
+    cfg.merge_from_file(args.config)
+    cfg.BACKEND_THRESH = args.backend_thresh
+    cfg.merge_from_list(args.opts)
+
+    print("\nRunning with config...")
+    print(cfg, "\n")
+
+    torch.manual_seed(1234)
+
+    kitti_scenes = [f"{i:02d}" for i in range(11)]
+
+    results = {}
+    for scene in kitti_scenes:
+        groundtruth = args.kittidir / "dataset" / "poses" / f"{scene}.txt"
+        poses_ref = file_interface.read_kitti_poses_file(groundtruth)
+        print(f"Evaluating KITTI {scene} with {poses_ref.num_poses // args.stride} poses")
+
+        scene_results = []
+        for trial_num in range(args.trials):
+            traj_est, timestamps = run(cfg, args.network, args.kittidir, scene, args.stride, args.viz, args.show_img)
+
+            traj_est = PoseTrajectory3D(
+                positions_xyz=traj_est[:,:3],
+                orientations_quat_wxyz=traj_est[:, [6, 3, 4, 5]],
+                timestamps=timestamps * args.stride)
+
+            traj_ref = PoseTrajectory3D(
+                positions_xyz=poses_ref.positions_xyz,
+                orientations_quat_wxyz=poses_ref.orientations_quat_wxyz,
+                timestamps=np.arange(poses_ref.num_poses, dtype=np.float64))
+
+            traj_ref, traj_est = sync.associate_trajectories(traj_ref, traj_est)
+
+            result = main_ape.ape(traj_ref, traj_est, est_name='traj', 
+                pose_relation=PoseRelation.translation_part, align=True, correct_scale=True)
+            ate_score = result.stats["rmse"]
+
+            if args.plot:
+                plot_trajectory(traj_est, traj_ref, f"kitti sequence {scene} Trial #{trial_num+1}", f"trajectory_plots/kitti_seq{scene}_trial{trial_num+1:02d}.pdf", align=True, correct_scale=True)
+
+            if args.save_trajectory:
+                Path("saved_trajectories").mkdir(exist_ok=True)
+                file_interface.write_tum_trajectory_file(f"saved_trajectories/KITTI_{scene}.txt", traj_est)
+                # file_interface.write_kitti_poses_file(f"saved_trajectories/{scene}.txt", traj_est) # standard kitti format
+
+            scene_results.append(ate_score)
+
+        results[scene] = np.median(scene_results)
+        print(scene, sorted(scene_results))
+
+    xs = []
+    for scene in results:
+        print(scene, results[scene])
+        xs.append(results[scene])
+
+    print("AVG: ", np.mean(xs))
+
+    
+
+    

third-party/DPVO/evaluate_tartan.py

@@ -0,0 +1,198 @@
+import datetime
+import glob
+import os
+import os.path as osp
+from pathlib import Path
+
+import cv2
+import evo.main_ape as main_ape
+import numpy as np
+import torch
+from evo.core.metrics import PoseRelation
+from evo.core.trajectory import PoseTrajectory3D
+from evo.tools import file_interface
+
+from dpvo.config import cfg
+from dpvo.data_readers.tartan import test_split as val_split
+from dpvo.dpvo import DPVO
+from dpvo.plot_utils import plot_trajectory
+from dpvo.utils import Timer
+
+test_split = \
+    ["MH%03d"%i for i in range(8)] + \
+    ["ME%03d"%i for i in range(8)]
+
+STRIDE = 1
+fx, fy, cx, cy = [320, 320, 320, 240]
+
+
+def show_image(image, t=0):
+    image = image.permute(1, 2, 0).cpu().numpy()
+    cv2.imshow('image', image / 255.0)
+    cv2.waitKey(t)
+
+def video_iterator(imagedir, ext=".png", preload=True):
+    imfiles = glob.glob(osp.join(imagedir, "*{}".format(ext)))
+
+    data_list = []
+    for imfile in sorted(imfiles)[::STRIDE]:
+        image = torch.from_numpy(cv2.imread(imfile)).permute(2,0,1)
+        intrinsics = torch.as_tensor([fx, fy, cx, cy])
+        data_list.append((image, intrinsics))
+
+    for (image, intrinsics) in data_list:
+        yield image.cuda(), intrinsics.cuda()
+
+@torch.no_grad()
+def run(imagedir, cfg, network, viz=False, show_img=False):
+    slam = DPVO(cfg, network, ht=480, wd=640, viz=viz)
+
+    for t, (image, intrinsics) in enumerate(video_iterator(imagedir)):
+        if show_img:
+            show_image(image, 1)
+        
+        with Timer("SLAM", enabled=False):
+            slam(t, image, intrinsics)
+
+    return slam.terminate()
+
+
+def ate(traj_ref, traj_est):
+    assert isinstance(traj_ref, PoseTrajectory3D)
+    assert isinstance(traj_est, PoseTrajectory3D)
+    
+    result = main_ape.ape(traj_ref, traj_est, est_name='traj', 
+        pose_relation=PoseRelation.translation_part, align=True, correct_scale=True)
+
+    return result.stats["rmse"]
+
+
+@torch.no_grad()
+def evaluate(config, net, split="validation", trials=1, plot=False, save=False):
+
+    if config is None:
+        config = cfg
+        config.merge_from_file("config/default.yaml")
+
+    if not os.path.isdir("TartanAirResults"):
+        os.mkdir("TartanAirResults")
+
+    scenes = test_split if split=="test" else val_split
+
+    results = {}
+    all_results = []
+    for i, scene in enumerate(scenes):
+
+        results[scene] = []
+        for j in range(trials):
+
+            # estimated trajectory
+            if split == 'test':
+                scene_path = os.path.join("datasets/mono", scene)
+                traj_ref = osp.join("datasets/mono", "mono_gt", scene + ".txt")
+            
+            elif split == 'validation':
+                scene_path = os.path.join("datasets/TartanAir", scene, "image_left")
+                traj_ref = osp.join("datasets/TartanAir", scene, "pose_left.txt")
+
+            # run the slam system
+            traj_est, tstamps = run(scene_path, config, net, viz=False, show_img=False)
+
+            PERM = [1, 2, 0, 4, 5, 3, 6] # ned -> xyz
+            traj_ref = np.loadtxt(traj_ref, delimiter=" ")[::STRIDE, PERM]
+
+            traj_est = PoseTrajectory3D(
+                positions_xyz=traj_est[:,:3],
+                orientations_quat_wxyz=traj_est[:, [6, 3, 4, 5]],
+                timestamps=tstamps)
+
+            traj_ref = PoseTrajectory3D(
+                positions_xyz=traj_ref[:,:3],
+                orientations_quat_wxyz=traj_ref[:,3:],
+                timestamps=tstamps)
+
+            # do evaluation
+            ate_score = ate(traj_ref, traj_est)
+            all_results.append(ate_score)
+            results[scene].append(ate_score)
+
+            if plot:
+                scene_name = '_'.join(scene.split('/')[1:]).title() if split == 'validation' else scene
+                Path("trajectory_plots").mkdir(exist_ok=True)
+                plot_trajectory(traj_est, traj_ref, f"TartanAir {scene_name.replace('_', ' ')} Trial #{j+1} (ATE: {ate_score:.03f})",
+                                f"trajectory_plots/TartanAir_{scene_name}_Trial{j+1:02d}.pdf", align=True, correct_scale=True)
+
+            if save:
+                Path("saved_trajectories").mkdir(exist_ok=True)
+                file_interface.write_tum_trajectory_file(f"saved_trajectories/TartanAir_{scene_name}_Trial{j+1:02d}.txt", traj_est)
+
+        print(scene, sorted(results[scene]))
+
+    results_dict = dict([("Tartan/{}".format(k), np.median(v)) for (k, v) in results.items()])
+
+    # write output to file with timestamp
+    with open(osp.join("TartanAirResults", datetime.datetime.now().strftime('%m-%d-%I%p.txt')), "w") as f:
+        f.write(','.join([str(x) for x in all_results]))
+
+    xs = []
+    for scene in results:
+        x = np.median(results[scene])
+        xs.append(x)
+
+    ates = list(all_results)
+    results_dict["AUC"] = np.maximum(1 - np.array(ates), 0).mean()
+    results_dict["AVG"] = np.mean(xs)
+
+    return results_dict
+
+
+if __name__ == '__main__':
+
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--viz', action="store_true")
+    parser.add_argument('--show_img', action="store_true")
+    parser.add_argument('--id', type=int, default=-1)
+    parser.add_argument('--weights', default="dpvo.pth")
+    parser.add_argument('--config', default="config/default.yaml")
+    parser.add_argument('--split', default="validation")
+    parser.add_argument('--trials', type=int, default=1)
+    parser.add_argument('--backend_thresh', type=float, default=18.0)
+    parser.add_argument('--plot', action="store_true")
+    parser.add_argument('--opts', nargs='+', default=[])
+    parser.add_argument('--save_trajectory', action="store_true")
+    args = parser.parse_args()
+
+    cfg.merge_from_file(args.config)
+    cfg.BACKEND_THRESH = args.backend_thresh
+    cfg.merge_from_list(args.opts)
+
+    print("Running with config...")
+    print(cfg)
+
+    torch.manual_seed(1234)
+
+    if args.id >= 0:
+        scene_path = os.path.join("datasets/mono", test_split[args.id])
+        traj_est, tstamps = run(scene_path, cfg, args.weights, viz=args.viz, show_img=args.show_img)
+
+        traj_ref = osp.join("datasets/mono", "mono_gt", test_split[args.id] + ".txt")
+        traj_ref = np.loadtxt(traj_ref, delimiter=" ")[::STRIDE,[1, 2, 0, 4, 5, 3, 6]]
+
+        traj_est = PoseTrajectory3D(
+            positions_xyz=traj_est[:,:3],
+            orientations_quat_wxyz=traj_est[:, [6, 3, 4, 5]],
+            timestamps=tstamps)
+
+        traj_ref = PoseTrajectory3D(
+            positions_xyz=traj_ref[:,:3],
+            orientations_quat_wxyz=traj_ref[:,3:],
+            timestamps=tstamps)
+
+        # do evaluation
+        print(ate(traj_ref, traj_est))
+
+    else:
+        results = evaluate(cfg, args.weights, split=args.split, trials=args.trials, plot=args.plot, save=args.save_trajectory)
+        for k in results:
+            print(k, results[k])

third-party/DPVO/evaluate_tum.py

@@ -0,0 +1,166 @@
+import sys
+from multiprocessing import Process, Queue
+from pathlib import Path
+
+import cv2
+import evo.main_ape as main_ape
+import numpy as np
+import torch
+from evo.core import sync
+from evo.core.metrics import PoseRelation
+from evo.core.trajectory import PoseTrajectory3D
+from evo.tools import file_interface, plot
+
+from dpvo.config import cfg
+from dpvo.dpvo import DPVO
+from dpvo.plot_utils import plot_trajectory
+from dpvo.utils import Timer
+
+SKIP = 0
+
+def show_image(image, t=0):
+    image = image.permute(1, 2, 0).cpu().numpy()
+    cv2.imshow('image', image / 255.0)
+    cv2.waitKey(t)
+
+def tum_image_stream(queue, scene_dir, sequence, stride, skip=0):
+    """ image generator """
+    images_dir = scene_dir / "rgb"
+
+    fx, fy, cx, cy = 517.3, 516.5, 318.6, 255.3
+
+    K_l = np.array([fx, 0.0, cx, 0.0, fy, cy, 0.0, 0.0, 1.0]).reshape(3,3)
+    d_l = np.array([0.2624, -0.9531, -0.0054, 0.0026, 1.1633])
+
+    image_list = sorted(images_dir.glob("*.png"))[skip::stride]
+
+    for imfile in image_list:
+        image = cv2.imread(str(imfile))
+        image = cv2.undistort(image, K_l, d_l)
+        image = image.transpose(2,0,1)
+
+        intrinsics = np.asarray([fx, fy, cx, cy])
+
+        # crop image to remove distortion boundary
+        intrinsics[2] -= 16
+        intrinsics[3] -= 8
+        # intrinsics = intrinsics[None]
+        image = image[:, 8:-8, 16:-16]
+
+        queue.put((float(imfile.stem), image, intrinsics))
+
+    queue.put((-1, image, intrinsics))
+
+@torch.no_grad()
+def run(cfg, network, scene_dir, sequence, stride=1, viz=False, show_img=False):
+
+    slam = None
+
+    queue = Queue(maxsize=8)
+    reader = Process(target=tum_image_stream, args=(queue, scene_dir, sequence, stride, 0))
+    reader.start()
+
+    for step in range(sys.maxsize):
+        (t, images, intrinsics) = queue.get()
+        if t < 0: break
+
+        images = torch.as_tensor(images, device='cuda')
+        intrinsics = torch.as_tensor(intrinsics, dtype=torch.float, device='cuda')
+
+        if show_img:
+            show_image(images[0], 1)
+
+        if slam is None:
+            slam = DPVO(cfg, network, ht=images.shape[-2], wd=images.shape[-1], viz=viz)
+
+        intrinsics = intrinsics.cuda()
+
+        with Timer("SLAM", enabled=False):
+            slam(t, images, intrinsics)
+
+    reader.join()
+
+    poses, tstamps = slam.terminate()
+    np.save(f"poses_{sequence}.npy", poses)
+    np.save(f"tstamps_{sequence}.npy", tstamps)
+    return poses, tstamps
+
+
+if __name__ == '__main__':
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--network', type=str, default='dpvo.pth')
+    parser.add_argument('--config', default="config/default.yaml")
+    parser.add_argument('--stride', type=int, default=1)
+    parser.add_argument('--viz', action="store_true")
+    parser.add_argument('--show_img', action="store_true")
+    parser.add_argument('--trials', type=int, default=1)
+    parser.add_argument('--tumdir', type=Path, default="datasets/TUM_RGBD")
+    parser.add_argument('--backend_thresh', type=float, default=64.0)
+    parser.add_argument('--plot', action="store_true")
+    parser.add_argument('--opts', nargs='+', default=[])
+    parser.add_argument('--save_trajectory', action="store_true")
+    args = parser.parse_args()
+
+    cfg.merge_from_file(args.config)
+    cfg.BACKEND_THRESH = args.backend_thresh
+    cfg.merge_from_list(args.opts)
+
+    print("\nRunning with config...")
+    print(cfg, "\n")
+
+    torch.manual_seed(1234)
+
+    tum_scenes = [
+        "rgbd_dataset_freiburg1_360",
+        "rgbd_dataset_freiburg1_desk",
+        "rgbd_dataset_freiburg1_desk2",
+        "rgbd_dataset_freiburg1_floor",
+        "rgbd_dataset_freiburg1_plant",
+        "rgbd_dataset_freiburg1_room",
+        "rgbd_dataset_freiburg1_rpy",
+        "rgbd_dataset_freiburg1_teddy",
+        "rgbd_dataset_freiburg1_xyz",
+    ]
+
+    results = {}
+    for scene in tum_scenes:
+        scene_dir = args.tumdir / f"{scene}"
+        groundtruth = scene_dir / "groundtruth.txt"
+        traj_ref = file_interface.read_tum_trajectory_file(groundtruth)
+
+        scene_results = []
+        for trial_num in range(args.trials):
+            traj_est, timestamps = run(cfg, args.network, scene_dir, scene, args.stride, args.viz, args.show_img)
+
+            traj_est = PoseTrajectory3D(
+                positions_xyz=traj_est[:,:3],
+                orientations_quat_wxyz=traj_est[:, [6, 3, 4, 5]],
+                timestamps=timestamps)
+
+            traj_ref, traj_est = sync.associate_trajectories(traj_ref, traj_est)
+
+            result = main_ape.ape(traj_ref, traj_est, est_name='traj', 
+                pose_relation=PoseRelation.translation_part, align=True, correct_scale=True)
+            ate_score = result.stats["rmse"]
+
+            if args.plot:
+                Path("trajectory_plots").mkdir(exist_ok=True)
+                plot_trajectory(traj_est, traj_ref, f"TUM-RGBD Frieburg1 {scene} Trial #{trial_num+1} (ATE: {ate_score:.03f})",
+                                f"trajectory_plots/TUM_RGBD_Frieburg1_{scene}_Trial{trial_num+1:02d}.pdf", align=True, correct_scale=True)
+
+            if args.save_trajectory:
+                Path("saved_trajectories").mkdir(exist_ok=True)
+                file_interface.write_tum_trajectory_file(f"saved_trajectories/TUM_RGBD_{scene}_Trial{trial_num+1:02d}.txt", traj_est)
+
+            scene_results.append(ate_score)
+
+        results[scene] = np.median(scene_results)
+        print(scene, sorted(scene_results))
+
+    xs = []
+    for scene in results:
+        print(scene, results[scene])
+        xs.append(results[scene])
+
+    print("AVG: ", np.mean(xs))

third-party/DPVO/logs/dpv_slam/euroc.txt

@@ -0,0 +1,25 @@
+### 5 runs per sequence --config=config/default.yaml ###
+
+MH_01_easy [0.012369993404248198, 0.012605391722468495, 0.012880865003171075, 0.013870202586474345, 0.015238448109961965]
+MH_02_easy [0.015547036608013052, 0.01576843130352243, 0.01601663966134436, 0.016302952602569, 0.01670363372507298]
+MH_03_medium [0.020871479141894543, 0.021469582631134868, 0.02160758143072866, 0.02196740437599391, 0.02278113883295323]
+MH_04_difficult [0.040664535309172786, 0.04162586499882439, 0.04310547275697648, 0.04451119822589982, 0.046356686029707134]
+MH_05_difficult [0.037656163316638736, 0.03860294422716045, 0.041342768355602584, 0.04240596757249529, 0.0450045092964287]
+V1_01_easy [0.03369426072301222, 0.03445928419283812, 0.034480781952964605, 0.0347687765479994, 0.03524749933025106]
+V1_02_medium [0.00741783707643993, 0.007707277937967464, 0.007751873360894739, 0.007814074772843944, 0.009236743416610602]
+V1_03_difficult [0.014143957522312662, 0.014222044330405931, 0.014729707182850377, 0.014853863138152805, 0.015501494809798597]
+V2_01_easy [0.017462731363148607, 0.01791424547422222, 0.019883485802871918, 0.021633241199184514, 0.02459907428562063]
+V2_02_medium [0.010443904238218088, 0.010998962261023593, 0.011178976602120408, 0.011204588660494272, 0.011527799108530709]
+V2_03_difficult [0.022497747243670558, 0.03182763031837707, 0.039804866818326026, 0.08241931795091231, 0.8277136956530557]
+MH_01_easy 0.012880865003171075
+MH_02_easy 0.01601663966134436
+MH_03_medium 0.02160758143072866
+MH_04_difficult 0.04310547275697648
+MH_05_difficult 0.041342768355602584
+V1_01_easy 0.034480781952964605
+V1_02_medium 0.007751873360894739
+V1_03_difficult 0.014729707182850377
+V2_01_easy 0.019883485802871918
+V2_02_medium 0.011178976602120408
+V2_03_difficult 0.039804866818326026
+AVG:  0.023889365357077384

third-party/DPVO/logs/dpv_slam/tartan.txt

@@ -0,0 +1,36 @@
+### 5 runs per sequence --config=config/default.yaml ###
+
+MH000 [0.14078493895760144, 0.17425330924389873, 0.2320722141122508, 0.2464911752765773, 0.332965830800725]
+MH001 [0.0368027905631422, 0.03906908490354523, 0.04648540151525352, 0.055202890908097844, 0.061483889066032284]
+MH002 [0.038333060645925544, 0.039385368705321375, 0.041219574892105974, 0.048395313794197786, 0.049742504371468405]
+MH003 [0.02122562136315083, 0.026893176031205866, 0.03691873538165471, 0.03778902389617407, 0.04469663284842249]
+MH004 [0.3630298853998415, 0.39955431072319764, 0.5410462821621671, 0.859569970253318, 1.4035158337312221]
+MH005 [0.12916987702576252, 0.14188108980017686, 0.14757231207904156, 0.175268372631902, 0.25084099469430765]
+MH006 [0.06534950409335614, 0.07122954467189514, 0.07359923915017312, 0.10705251161679226, 0.1104938092017843]
+MH007 [0.09093388637838953, 0.0911377893323715, 0.1375659305614897, 0.20127730088082196, 0.22937435213297236]
+ME000 [0.09770577342399908, 0.10111328588074299, 0.10122426648605258, 0.13326941997010486, 0.3596593467196429]
+ME001 [0.03678302876664992, 0.05243283634539895, 0.07277431649480902, 0.07874005662497299, 0.09700248773025555]
+ME002 [0.08642819827884278, 0.10682086281684673, 0.11018113151360784, 0.13703016187640601, 0.25829541979716375]
+ME003 [0.25953484728996135, 0.39566815992075466, 0.693571727024989, 0.7694634138266926, 0.9734666967227169]
+ME004 [0.17980634759342365, 0.21393477220939291, 0.27152949857430864, 0.32094905141127794, 0.49660873127748983]
+ME005 [0.10466414796433271, 0.1317423810614023, 0.14307514592420253, 0.14953003258901795, 0.1829027082452621]
+ME006 [0.1956941668844341, 0.24035120184647824, 0.2602811743842383, 0.2626992655935781, 0.399886761660616]
+ME007 [0.10557488244783707, 0.11610016242229444, 0.12783280059328814, 0.12839651067767963, 0.14429752820146194]
+Tartan/MH000 0.2320722141122508
+Tartan/MH001 0.04648540151525352
+Tartan/MH002 0.041219574892105974
+Tartan/MH003 0.03691873538165471
+Tartan/MH004 0.5410462821621671
+Tartan/MH005 0.14757231207904156
+Tartan/MH006 0.07359923915017312
+Tartan/MH007 0.1375659305614897
+Tartan/ME000 0.10122426648605258
+Tartan/ME001 0.07277431649480902
+Tartan/ME002 0.11018113151360784
+Tartan/ME003 0.693571727024989
+Tartan/ME004 0.27152949857430864
+Tartan/ME005 0.14307514592420253
+Tartan/ME006 0.2602811743842383
+Tartan/ME007 0.12783280059328814
+AUC 0.7995852473857609
+AVG 0.18980935942810204

third-party/DPVO/logs/dpv_slam/tum_rgbd.txt

@@ -0,0 +1,21 @@
+### 5 runs per sequence --config=config/default.yaml ###
+
+rgbd_dataset_freiburg1_360 [0.09556885957694398, 0.10780547052109406, 0.11260000433917534, 0.12501811927398945, 0.14859558048623225]
+rgbd_dataset_freiburg1_desk [0.015166853116610817, 0.01672589412063112, 0.017877838211945028, 0.01797624544803138, 0.020725784310901343]
+rgbd_dataset_freiburg1_desk2 [0.02556278769148601, 0.027594135280035473, 0.028709430646346887, 0.0334743010498361, 0.035687491338283035]
+rgbd_dataset_freiburg1_floor [0.04835237069554044, 0.05001706164828772, 0.05711831840242974, 0.14516966466222234, 0.15118477870691477]
+rgbd_dataset_freiburg1_plant [0.019407809430967204, 0.02020191551091588, 0.020591438602137437, 0.02124531837476253, 0.0234699091863837]
+rgbd_dataset_freiburg1_room [0.27089421441219025, 0.2949559930005123, 0.3259800041913198, 0.3584344038994978, 0.41824841489311787]
+rgbd_dataset_freiburg1_rpy [0.0210928913583283, 0.024675875522205747, 0.029367751433447793, 0.03199853668001898, 0.040162566024802525]
+rgbd_dataset_freiburg1_teddy [0.060343618248123336, 0.06784547021972276, 0.08400003098586675, 0.12070500728552086, 0.1334676994672985]
+rgbd_dataset_freiburg1_xyz [0.010378787037841359, 0.010385630409875024, 0.010386022116149172, 0.010450868359308982, 0.012469434001895987]
+rgbd_dataset_freiburg1_360 0.11260000433917534
+rgbd_dataset_freiburg1_desk 0.017877838211945028
+rgbd_dataset_freiburg1_desk2 0.028709430646346887
+rgbd_dataset_freiburg1_floor 0.05711831840242974
+rgbd_dataset_freiburg1_plant 0.020591438602137437
+rgbd_dataset_freiburg1_room 0.3259800041913198
+rgbd_dataset_freiburg1_rpy 0.029367751433447793
+rgbd_dataset_freiburg1_teddy 0.08400003098586675
+rgbd_dataset_freiburg1_xyz 0.010386022116149172
+AVG:  0.07629231543653532

third-party/DPVO/logs/euroc.txt

@@ -0,0 +1,27 @@
+### 5 runs per sequence --config=config/default.yaml ###
+
+MH_01_easy [0.06314536790811147, 0.06699902721516254, 0.08683937293607617, 0.09933849813033907, 0.10537122768404757]
+MH_02_easy [0.0447169925646229, 0.05285213743988453, 0.055298624828687054, 0.07187218580304361, 0.07859830854488298]
+MH_03_medium [0.1457357241752508, 0.15225227342622094, 0.1588016200456077, 0.16214021665883874, 0.17697334507384457]
+MH_04_difficult [0.13056959233860085, 0.1347044262169782, 0.1374168163128574, 0.16565343615410935, 0.18764459073795706]
+MH_05_difficult [0.09729210548199585, 0.10630841008551295, 0.11357875715833793, 0.1303943587387471, 0.19755247615276056]
+V1_01_easy [0.04309583310397929, 0.04453076570255095, 0.04999439471801219, 0.05172988782951013, 0.052966349405529266]
+V1_02_medium [0.12553027331956326, 0.1309151444482779, 0.13988433603681644, 0.1514409495713732, 0.15499837381235274]
+V1_03_difficult [0.08241488941986161, 0.08379125113047524, 0.08614115180383249, 0.09091289641612288, 0.10112603302717377]
+V2_01_easy [0.049950843021396706, 0.0527218831462199, 0.05689049974664685, 0.06153877016328922, 0.07042993974430499]
+V2_02_medium [0.03843408761702444, 0.04418367384901882, 0.04942073125020657, 0.05305070877727971, 0.07407632629338251]
+V2_03_difficult [0.1511344255962771, 0.16489871921353894, 0.21067533098893604, 0.21285922415109648, 0.2257008090618537]
+
+MH_01_easy 0.08683937293607617
+MH_02_easy 0.055298624828687054
+MH_03_medium 0.1588016200456077
+MH_04_difficult 0.1374168163128574
+MH_05_difficult 0.11357875715833793
+V1_01_easy 0.04999439471801219
+V1_02_medium 0.13988433603681644
+V1_03_difficult 0.08614115180383249
+V2_01_easy 0.05689049974664685
+V2_02_medium 0.04942073125020657
+V2_03_difficult 0.21067533098893604
+
+AVG:  0.10408560325691062

third-party/DPVO/logs/euroc_fast.txt

@@ -0,0 +1,27 @@
+### 5 runs per sequence --config=config/fast.yaml ###
+
+MH_01_easy [0.07114604150165917, 0.08290962492882813, 0.1014933052121179, 0.10735335606879509, 0.18301678354833867]
+MH_02_easy [0.02264057890051186, 0.040348658842906344, 0.06591933136520801, 0.07345417366259756, 0.08139938786229357]
+MH_03_medium [0.13016847686932506, 0.16714280161187547, 0.17681234899205833, 0.2055236851692995, 0.23297395657220393]
+MH_04_difficult [0.12858862192233328, 0.14633870778076316, 0.18103814374993568, 0.18774320531854857, 0.20857620966381415]
+MH_05_difficult [0.09640786628683881, 0.11462786755308231, 0.12330409165123575, 0.137254961392892, 0.16133314282455288]
+V1_01_easy [0.049126710178242466, 0.05025065039148512, 0.053426504229927695, 0.055094550531262006, 0.05815553958462344]
+V1_02_medium [0.14664527623599097, 0.15020686120397345, 0.1577425323361298, 0.16032804323394892, 0.17913268442784727]
+V1_03_difficult [0.0801491502026727, 0.0888522931662034, 0.09517781591457553, 0.10195932604579287, 0.11867762742907356]
+V2_01_easy [0.05455553542728026, 0.0891189786906816, 0.0952487304621841, 0.1043575758374652, 0.12740444184577643]
+V2_02_medium [0.051929053000443405, 0.052399867493328, 0.0627062703360614, 0.06271649076717616, 0.07269315818193876]
+V2_03_difficult [0.2220917002464664, 0.2294504128801054, 0.30956898932165855, 0.37317544713557826, 0.9085849532936994]
+
+MH_01_easy 0.1014933052121179
+MH_02_easy 0.06591933136520801
+MH_03_medium 0.17681234899205833
+MH_04_difficult 0.18103814374993568
+MH_05_difficult 0.12330409165123575
+V1_01_easy 0.053426504229927695
+V1_02_medium 0.1577425323361298
+V1_03_difficult 0.09517781591457553
+V2_01_easy 0.0952487304621841
+V2_02_medium 0.0627062703360614
+V2_03_difficult 0.30956898932165855
+
+AVG:  0.12931255123373572

third-party/DPVO/logs/icl_nuim.txt

@@ -0,0 +1,21 @@
+### 5 runs per sequence --config=config/default.yaml ###
+
+living_room_traj0_loop [0.005498305436953887, 0.005769656790000982, 0.0058869781477180055, 0.005931800616935496, 0.006646859549548963]
+living_room_traj1_loop [0.005385150903003443, 0.08553724944653898, 0.08700891753914203, 0.08729466281710502, 0.08763460013868249]
+living_room_traj2_loop [0.018812871309275895, 0.019211457933104786, 0.019359962350138107, 0.019758084927718876, 0.021876516721087345]
+living_room_traj3_loop [0.005746028471938545, 0.0058040802564935726, 0.0059715562629597384, 0.005975146917124347, 0.0061160841632913205]
+office_room_traj0_loop [0.0058411298494680085, 0.006038133420971141, 0.0060612174662210165, 0.00609935627326321, 0.006603454239939697]
+office_room_traj1_loop [0.007152512423961235, 0.007436432377339334, 0.007836419207622776, 0.010378794971925629, 0.013696859874629534]
+office_room_traj2_loop [0.014721988425653445, 0.016681916344083076, 0.0167830764457033, 0.024267375338664205, 0.02522285403705428]
+office_room_traj3_loop [0.48789422362261475, 0.48791849973262535, 0.4964864422613096, 0.5324202163736682, 0.5462029659025921]
+
+living_room_traj0_loop 0.0058869781477180055
+living_room_traj1_loop 0.08700891753914203
+living_room_traj2_loop 0.019359962350138107
+living_room_traj3_loop 0.0059715562629597384
+office_room_traj0_loop 0.0060612174662210165
+office_room_traj1_loop 0.007836419207622776
+office_room_traj2_loop 0.0167830764457033
+office_room_traj3_loop 0.4964864422613096
+
+AVG:  0.08067432121010182

third-party/DPVO/logs/tartan.txt

@@ -0,0 +1,37 @@
+### 5 runs per sequence --config=config/default.yaml ###
+
+MH000 [0.14334602109716257, 0.17326944198634417, 0.21190129931839286, 0.2469543133154878, 0.2817358116456705]
+MH001 [0.03115740932037767, 0.03588517247338095, 0.0440864687238323, 0.05475357131885065, 0.05863276910264077]
+MH002 [0.03768134250730164, 0.04322997703461984, 0.043565700923534435, 0.0454688419090695, 0.06086877971444702]
+MH003 [0.02645348956221145, 0.04567704445657277, 0.07722210255214312, 0.07998915791630597, 0.09330225998396668]
+MH004 [0.38178719278300133, 0.47049937312725054, 0.576996761412533, 0.8196664469335276, 1.4796195373419132]
+MH005 [0.13027045706139298, 0.13277834200788574, 0.17013412784519652, 0.171243073003556, 0.24112687242125458]
+MH006 [0.09010833917187357, 0.0976559159526096, 0.10863019162622754, 0.12245139404225007, 0.13647010877302648]
+MH007 [0.11124488973312219, 0.1116922817228792, 0.14544537729172818, 0.14751699268194798, 0.17891644798066583]
+ME000 [0.05922489836569579, 0.09525643394714992, 0.15723473985824776, 0.1620058317263364, 0.17037398669996276]
+ME001 [0.07573144195168588, 0.08407845004731436, 0.10580187540595357, 0.11842358457556312, 0.24315552417747882]
+ME002 [0.08392216496929536, 0.10654102318328146, 0.10705239811899728, 0.15980735853387604, 0.21305814853664024]
+ME003 [0.28759270438139983, 0.5259024124818149, 0.6637537642033361, 0.724924810452685, 0.9839217080988636]
+ME004 [0.17986836198603914, 0.2902208989458954, 0.3153304372853317, 0.3670610972759821, 0.5060843274702364]
+ME005 [0.10348533597391497, 0.13551563136072803, 0.14293155684549463, 0.15461924981065864, 0.20197759102282564]
+ME006 [0.21976719392977548, 0.25470045475140085, 0.29661793719394286, 0.35232606971335345, 0.5101625015109987]
+ME007 [0.10637165069265611, 0.11674148135447272, 0.12817115921970332, 0.1283841672483978, 0.14369304245425063]
+
+MH000 0.21190129931839286
+MH001 0.0440864687238323
+MH002 0.043565700923534435
+MH003 0.07722210255214312
+MH004 0.576996761412533
+MH005 0.17013412784519652
+MH006 0.10863019162622754
+MH007 0.14544537729172818
+ME000 0.15723473985824776
+ME001 0.10580187540595357
+ME002 0.10705239811899728
+ME003 0.6637537642033361
+ME004 0.3153304372853317
+ME005 0.14293155684549463
+ME006 0.29661793719394286
+ME007 0.12817115921970332
+
+AVG:  0.2059297436140372

third-party/DPVO/logs/tum_rgbd.txt

@@ -0,0 +1,23 @@
+### 5 runs per sequence --config=config/default.yaml ###
+
+360 [0.12119497209318734, 0.12525963043834612, 0.17130646499947016, 0.1761476262456535, 0.1933653209480926]
+desk [0.026105813969107154, 0.027741116512244042, 0.028646468040911453, 0.03106411248321044, 0.04449848373946498]
+desk2 [0.04719722007832377, 0.05084402998366679, 0.05361728961186766, 0.05936560415948633, 0.06170508077547479]
+floor [0.03643179014821134, 0.04257712576246384, 0.04487157748878229, 0.09703714699490908, 0.7032446123102681]
+plant [0.027293687153410677, 0.02927140044346179, 0.031003197232962944, 0.040222496600114725, 0.040353251876044015]
+room [0.3330306075675357, 0.3636511057229298, 0.388318238595983, 0.4126822932562722, 0.41414796374950436]
+rpy [0.032101266243377086, 0.040920815199384016, 0.04549406392008708, 0.04841053825386331, 0.04875319338687637]
+teddy [0.058712198614181886, 0.060135428840557226, 0.06295767243094463, 0.07249460158460448, 0.08928548478649274]
+xyz [0.011829540280544332, 0.011947087935136453, 0.012119309929724311, 0.01225775696219288, 0.012665393732917779]
+
+360 0.17130646499947016
+desk 0.028646468040911453
+desk2 0.05361728961186766
+floor 0.04487157748878229
+plant 0.031003197232962944
+room 0.388318238595983
+rpy 0.04549406392008708
+teddy 0.06295767243094463
+xyz 0.012119309929724311
+
+AVG:  0.09314825358341484