1e553fb4cd9e020fcd57e1db93bb22f5e2d7c5f9eb8bc2727833ad6dba5ec47e

third-party/DPVO/Pangolin/components/pango_python/pybind11/tools/pybind11NewTools.cmake

@@ -0,0 +1,267 @@
+# tools/pybind11NewTools.cmake -- Build system for the pybind11 modules
+#
+# Copyright (c) 2020 Wenzel Jakob <[email protected]> and Henry Schreiner
+#
+# All rights reserved. Use of this source code is governed by a
+# BSD-style license that can be found in the LICENSE file.
+
+get_property(
+  is_config
+  TARGET pybind11::headers
+  PROPERTY IMPORTED)
+
+if(pybind11_FIND_QUIETLY)
+  set(_pybind11_quiet QUIET)
+else()
+  set(_pybind11_quiet "")
+endif()
+
+if(CMAKE_VERSION VERSION_LESS 3.12)
+  message(FATAL_ERROR "You cannot use the new FindPython module with CMake < 3.12")
+endif()
+
+if(NOT Python_FOUND
+   AND NOT Python3_FOUND
+   AND NOT Python2_FOUND)
+  if(NOT DEFINED Python_FIND_IMPLEMENTATIONS)
+    set(Python_FIND_IMPLEMENTATIONS CPython PyPy)
+  endif()
+
+  # GitHub Actions like activation
+  if(NOT DEFINED Python_ROOT_DIR AND DEFINED ENV{pythonLocation})
+    set(Python_ROOT_DIR "$ENV{pythonLocation}")
+  endif()
+
+  find_package(Python REQUIRED COMPONENTS Interpreter Development ${_pybind11_quiet})
+
+  # If we are in submodule mode, export the Python targets to global targets.
+  # If this behavior is not desired, FindPython _before_ pybind11.
+  if(NOT is_config)
+    set_property(TARGET Python::Python PROPERTY IMPORTED_GLOBAL TRUE)
+    set_property(TARGET Python::Interpreter PROPERTY IMPORTED_GLOBAL TRUE)
+    if(TARGET Python::Module)
+      set_property(TARGET Python::Module PROPERTY IMPORTED_GLOBAL TRUE)
+    endif()
+  endif()
+endif()
+
+if(Python_FOUND)
+  set(_Python
+      Python
+      CACHE INTERNAL "" FORCE)
+elseif(Python3_FOUND AND NOT Python2_FOUND)
+  set(_Python
+      Python3
+      CACHE INTERNAL "" FORCE)
+elseif(Python2_FOUND AND NOT Python3_FOUND)
+  set(_Python
+      Python2
+      CACHE INTERNAL "" FORCE)
+else()
+  message(AUTHOR_WARNING "Python2 and Python3 both present, pybind11 in "
+                         "PYBIND11_NOPYTHON mode (manually activate to silence warning)")
+  set(_pybind11_nopython ON)
+  return()
+endif()
+
+if(PYBIND11_MASTER_PROJECT)
+  if(${_Python}_INTERPRETER_ID MATCHES "PyPy")
+    message(STATUS "PyPy ${${_Python}_PyPy_VERSION} (Py ${${_Python}_VERSION})")
+  else()
+    message(STATUS "${_Python} ${${_Python}_VERSION}")
+  endif()
+endif()
+
+# If a user finds Python, they may forget to include the Interpreter component
+# and the following two steps require it. It is highly recommended by CMake
+# when finding development libraries anyway, so we will require it.
+if(NOT DEFINED ${_Python}_EXECUTABLE)
+  message(
+    FATAL_ERROR
+      "${_Python} was found without the Interpreter component. Pybind11 requires this component.")
+
+endif()
+
+if(NOT DEFINED PYTHON_IS_DEBUG)
+  # Debug check - see https://stackoverflow.com/questions/646518/python-how-to-detect-debug-Interpreter
+  execute_process(
+    COMMAND "${${_Python}_EXECUTABLE}" "-c"
+            "import sys; sys.exit(hasattr(sys, 'gettotalrefcount'))"
+    RESULT_VARIABLE _PYTHON_IS_DEBUG)
+  set(PYTHON_IS_DEBUG
+      "${_PYTHON_IS_DEBUG}"
+      CACHE INTERNAL "Python debug status")
+endif()
+
+# Get the suffix - SO is deprecated, should use EXT_SUFFIX, but this is
+# required for PyPy3 (as of 7.3.1)
+if(NOT DEFINED PYTHON_MODULE_EXTENSION)
+  execute_process(
+    COMMAND
+      "${${_Python}_EXECUTABLE}" "-c"
+      "from distutils import sysconfig as s;print(s.get_config_var('EXT_SUFFIX') or s.get_config_var('SO'))"
+    OUTPUT_VARIABLE _PYTHON_MODULE_EXTENSION
+    ERROR_VARIABLE _PYTHON_MODULE_EXTENSION_ERR
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+  if(_PYTHON_MODULE_EXTENSION STREQUAL "")
+    message(
+      FATAL_ERROR "pybind11 could not query the module file extension, likely the 'distutils'"
+                  "package is not installed. Full error message:\n${_PYTHON_MODULE_EXTENSION_ERR}")
+  endif()
+
+  # This needs to be available for the pybind11_extension function
+  set(PYTHON_MODULE_EXTENSION
+      "${_PYTHON_MODULE_EXTENSION}"
+      CACHE INTERNAL "")
+endif()
+
+# Python debug libraries expose slightly different objects before 3.8
+# https://docs.python.org/3.6/c-api/intro.html#debugging-builds
+# https://stackoverflow.com/questions/39161202/how-to-work-around-missing-pymodule-create2-in-amd64-win-python35-d-lib
+if(PYTHON_IS_DEBUG)
+  set_property(
+    TARGET pybind11::pybind11
+    APPEND
+    PROPERTY INTERFACE_COMPILE_DEFINITIONS Py_DEBUG)
+endif()
+
+# Check on every access - since Python2 and Python3 could have been used - do nothing in that case.
+
+if(DEFINED ${_Python}_INCLUDE_DIRS)
+  # Only add Python for build - must be added during the import for config
+  # since it has to be re-discovered.
+  #
+  # This needs to be a target to be included after the local pybind11
+  # directory, just in case there there is an installed pybind11 sitting
+  # next to Python's includes. It also ensures Python is a SYSTEM library.
+  add_library(pybind11::python_headers INTERFACE IMPORTED)
+  set_property(
+    TARGET pybind11::python_headers PROPERTY INTERFACE_INCLUDE_DIRECTORIES
+                                             "$<BUILD_INTERFACE:${${_Python}_INCLUDE_DIRS}>")
+  set_property(
+    TARGET pybind11::pybind11
+    APPEND
+    PROPERTY INTERFACE_LINK_LIBRARIES pybind11::python_headers)
+  set(pybind11_INCLUDE_DIRS
+      "${pybind11_INCLUDE_DIR}" "${${_Python}_INCLUDE_DIRS}"
+      CACHE INTERNAL "Directories where pybind11 and possibly Python headers are located")
+endif()
+
+if(DEFINED ${_Python}_VERSION AND ${_Python}_VERSION VERSION_LESS 3)
+  set_property(
+    TARGET pybind11::pybind11
+    APPEND
+    PROPERTY INTERFACE_LINK_LIBRARIES pybind11::python2_no_register)
+endif()
+
+# In CMake 3.18+, you can find these separately, so include an if
+if(TARGET ${_Python}::Python)
+  set_property(
+    TARGET pybind11::embed
+    APPEND
+    PROPERTY INTERFACE_LINK_LIBRARIES ${_Python}::Python)
+endif()
+
+# CMake 3.15+ has this
+if(TARGET ${_Python}::Module)
+  set_property(
+    TARGET pybind11::module
+    APPEND
+    PROPERTY INTERFACE_LINK_LIBRARIES ${_Python}::Module)
+else()
+  set_property(
+    TARGET pybind11::module
+    APPEND
+    PROPERTY INTERFACE_LINK_LIBRARIES pybind11::python_link_helper)
+endif()
+
+# WITHOUT_SOABI and WITH_SOABI will disable the custom extension handling used by pybind11.
+# WITH_SOABI is passed on to python_add_library.
+function(pybind11_add_module target_name)
+  cmake_parse_arguments(PARSE_ARGV 1 ARG
+                        "STATIC;SHARED;MODULE;THIN_LTO;OPT_SIZE;NO_EXTRAS;WITHOUT_SOABI" "" "")
+
+  if(ARG_STATIC)
+    set(lib_type STATIC)
+  elseif(ARG_SHARED)
+    set(lib_type SHARED)
+  else()
+    set(lib_type MODULE)
+  endif()
+
+  if("${_Python}" STREQUAL "Python")
+    python_add_library(${target_name} ${lib_type} ${ARG_UNPARSED_ARGUMENTS})
+  elseif("${_Python}" STREQUAL "Python3")
+    python3_add_library(${target_name} ${lib_type} ${ARG_UNPARSED_ARGUMENTS})
+  elseif("${_Python}" STREQUAL "Python2")
+    python2_add_library(${target_name} ${lib_type} ${ARG_UNPARSED_ARGUMENTS})
+  else()
+    message(FATAL_ERROR "Cannot detect FindPython version: ${_Python}")
+  endif()
+
+  target_link_libraries(${target_name} PRIVATE pybind11::headers)
+
+  if(lib_type STREQUAL "MODULE")
+    target_link_libraries(${target_name} PRIVATE pybind11::module)
+  else()
+    target_link_libraries(${target_name} PRIVATE pybind11::embed)
+  endif()
+
+  if(MSVC)
+    target_link_libraries(${target_name} PRIVATE pybind11::windows_extras)
+  endif()
+
+  if(DEFINED ${_Python}_VERSION AND ${_Python}_VERSION VERSION_LESS 3)
+    target_link_libraries(${target_name} PRIVATE pybind11::python2_no_register)
+  endif()
+
+  # -fvisibility=hidden is required to allow multiple modules compiled against
+  # different pybind versions to work properly, and for some features (e.g.
+  # py::module_local).  We force it on everything inside the `pybind11`
+  # namespace; also turning it on for a pybind module compilation here avoids
+  # potential warnings or issues from having mixed hidden/non-hidden types.
+  if(NOT DEFINED CMAKE_CXX_VISIBILITY_PRESET)
+    set_target_properties(${target_name} PROPERTIES CXX_VISIBILITY_PRESET "hidden")
+  endif()
+
+  if(NOT DEFINED CMAKE_CUDA_VISIBILITY_PRESET)
+    set_target_properties(${target_name} PROPERTIES CUDA_VISIBILITY_PRESET "hidden")
+  endif()
+
+  # If we don't pass a WITH_SOABI or WITHOUT_SOABI, use our own default handling of extensions
+  if(NOT ARG_WITHOUT_SOABI AND NOT "WITH_SOABI" IN_LIST ARG_UNPARSED_ARGUMENTS)
+    pybind11_extension(${target_name})
+  endif()
+
+  if(ARG_NO_EXTRAS)
+    return()
+  endif()
+
+  if(NOT DEFINED CMAKE_INTERPROCEDURAL_OPTIMIZATION)
+    if(ARG_THIN_LTO)
+      target_link_libraries(${target_name} PRIVATE pybind11::thin_lto)
+    else()
+      target_link_libraries(${target_name} PRIVATE pybind11::lto)
+    endif()
+  endif()
+
+  if(NOT MSVC AND NOT ${CMAKE_BUILD_TYPE} MATCHES Debug|RelWithDebInfo)
+    # Strip unnecessary sections of the binary on Linux/macOS
+    pybind11_strip(${target_name})
+  endif()
+
+  if(MSVC)
+    target_link_libraries(${target_name} PRIVATE pybind11::windows_extras)
+  endif()
+
+  if(ARG_OPT_SIZE)
+    target_link_libraries(${target_name} PRIVATE pybind11::opt_size)
+  endif()
+endfunction()
+
+function(pybind11_extension name)
+  # The extension is precomputed
+  set_target_properties(${name} PROPERTIES PREFIX "" SUFFIX "${PYTHON_MODULE_EXTENSION}")
+
+endfunction()

third-party/DPVO/Pangolin/components/pango_python/pybind11/tools/pybind11Tools.cmake

@@ -0,0 +1,220 @@
+# tools/pybind11Tools.cmake -- Build system for the pybind11 modules
+#
+# Copyright (c) 2020 Wenzel Jakob <[email protected]>
+#
+# All rights reserved. Use of this source code is governed by a
+# BSD-style license that can be found in the LICENSE file.
+
+# Built-in in CMake 3.5+
+include(CMakeParseArguments)
+
+if(pybind11_FIND_QUIETLY)
+  set(_pybind11_quiet QUIET)
+else()
+  set(_pybind11_quiet "")
+endif()
+
+# If this is the first run, PYTHON_VERSION can stand in for PYBIND11_PYTHON_VERSION
+if(NOT DEFINED PYBIND11_PYTHON_VERSION AND DEFINED PYTHON_VERSION)
+  message(WARNING "Set PYBIND11_PYTHON_VERSION to search for a specific version, not "
+                  "PYTHON_VERSION (which is an output). Assuming that is what you "
+                  "meant to do and continuing anyway.")
+  set(PYBIND11_PYTHON_VERSION
+      "${PYTHON_VERSION}"
+      CACHE STRING "Python version to use for compiling modules")
+  unset(PYTHON_VERSION)
+  unset(PYTHON_VERSION CACHE)
+elseif(DEFINED PYBIND11_PYTHON_VERSION)
+  # If this is set as a normal variable, promote it
+  set(PYBIND11_PYTHON_VERSION
+      "${PYBIND11_PYTHON_VERSION}"
+      CACHE STRING "Python version to use for compiling modules")
+else()
+  # Make an empty cache variable.
+  set(PYBIND11_PYTHON_VERSION
+      ""
+      CACHE STRING "Python version to use for compiling modules")
+endif()
+
+# A user can set versions manually too
+set(Python_ADDITIONAL_VERSIONS
+    "3.10;3.9;3.8;3.7;3.6;3.5;3.4"
+    CACHE INTERNAL "")
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}")
+find_package(PythonLibsNew ${PYBIND11_PYTHON_VERSION} MODULE REQUIRED ${_pybind11_quiet})
+list(REMOVE_AT CMAKE_MODULE_PATH -1)
+
+# Cache variables so pybind11_add_module can be used in parent projects
+set(PYTHON_INCLUDE_DIRS
+    ${PYTHON_INCLUDE_DIRS}
+    CACHE INTERNAL "")
+set(PYTHON_LIBRARIES
+    ${PYTHON_LIBRARIES}
+    CACHE INTERNAL "")
+set(PYTHON_MODULE_PREFIX
+    ${PYTHON_MODULE_PREFIX}
+    CACHE INTERNAL "")
+set(PYTHON_MODULE_EXTENSION
+    ${PYTHON_MODULE_EXTENSION}
+    CACHE INTERNAL "")
+set(PYTHON_VERSION_MAJOR
+    ${PYTHON_VERSION_MAJOR}
+    CACHE INTERNAL "")
+set(PYTHON_VERSION_MINOR
+    ${PYTHON_VERSION_MINOR}
+    CACHE INTERNAL "")
+set(PYTHON_VERSION
+    ${PYTHON_VERSION}
+    CACHE INTERNAL "")
+set(PYTHON_IS_DEBUG
+    "${PYTHON_IS_DEBUG}"
+    CACHE INTERNAL "")
+
+if(PYBIND11_MASTER_PROJECT)
+  if(PYTHON_MODULE_EXTENSION MATCHES "pypy")
+    if(NOT DEFINED PYPY_VERSION)
+      execute_process(
+        COMMAND ${PYTHON_EXECUTABLE} -c
+                [=[import sys; sys.stdout.write(".".join(map(str, sys.pypy_version_info[:3])))]=]
+        OUTPUT_VARIABLE pypy_version)
+      set(PYPY_VERSION
+          ${pypy_version}
+          CACHE INTERNAL "")
+    endif()
+    message(STATUS "PYPY ${PYPY_VERSION} (Py ${PYTHON_VERSION})")
+  else()
+    message(STATUS "PYTHON ${PYTHON_VERSION}")
+  endif()
+endif()
+
+# Only add Python for build - must be added during the import for config since
+# it has to be re-discovered.
+#
+# This needs to be an target to it is included after the local pybind11
+# directory, just in case there are multiple versions of pybind11, we want the
+# one we expect.
+add_library(pybind11::python_headers INTERFACE IMPORTED)
+set_property(TARGET pybind11::python_headers PROPERTY INTERFACE_INCLUDE_DIRECTORIES
+                                                      "$<BUILD_INTERFACE:${PYTHON_INCLUDE_DIRS}>")
+set_property(
+  TARGET pybind11::pybind11
+  APPEND
+  PROPERTY INTERFACE_LINK_LIBRARIES pybind11::python_headers)
+
+set(pybind11_INCLUDE_DIRS
+    "${pybind11_INCLUDE_DIR}" "${PYTHON_INCLUDE_DIRS}"
+    CACHE INTERNAL "Directories where pybind11 and possibly Python headers are located")
+
+# Python debug libraries expose slightly different objects before 3.8
+# https://docs.python.org/3.6/c-api/intro.html#debugging-builds
+# https://stackoverflow.com/questions/39161202/how-to-work-around-missing-pymodule-create2-in-amd64-win-python35-d-lib
+if(PYTHON_IS_DEBUG)
+  set_property(
+    TARGET pybind11::pybind11
+    APPEND
+    PROPERTY INTERFACE_COMPILE_DEFINITIONS Py_DEBUG)
+endif()
+
+set_property(
+  TARGET pybind11::module
+  APPEND
+  PROPERTY
+    INTERFACE_LINK_LIBRARIES pybind11::python_link_helper
+    "$<$<OR:$<PLATFORM_ID:Windows>,$<PLATFORM_ID:Cygwin>>:$<BUILD_INTERFACE:${PYTHON_LIBRARIES}>>")
+
+if(PYTHON_VERSION VERSION_LESS 3)
+  set_property(
+    TARGET pybind11::pybind11
+    APPEND
+    PROPERTY INTERFACE_LINK_LIBRARIES pybind11::python2_no_register)
+endif()
+
+set_property(
+  TARGET pybind11::embed
+  APPEND
+  PROPERTY INTERFACE_LINK_LIBRARIES pybind11::pybind11 $<BUILD_INTERFACE:${PYTHON_LIBRARIES}>)
+
+function(pybind11_extension name)
+  # The prefix and extension are provided by FindPythonLibsNew.cmake
+  set_target_properties(${name} PROPERTIES PREFIX "${PYTHON_MODULE_PREFIX}"
+                                           SUFFIX "${PYTHON_MODULE_EXTENSION}")
+endfunction()
+
+# Build a Python extension module:
+# pybind11_add_module(<name> [MODULE | SHARED] [EXCLUDE_FROM_ALL]
+#                     [NO_EXTRAS] [THIN_LTO] [OPT_SIZE] source1 [source2 ...])
+#
+function(pybind11_add_module target_name)
+  set(options "MODULE;SHARED;EXCLUDE_FROM_ALL;NO_EXTRAS;SYSTEM;THIN_LTO;OPT_SIZE")
+  cmake_parse_arguments(ARG "${options}" "" "" ${ARGN})
+
+  if(ARG_MODULE AND ARG_SHARED)
+    message(FATAL_ERROR "Can't be both MODULE and SHARED")
+  elseif(ARG_SHARED)
+    set(lib_type SHARED)
+  else()
+    set(lib_type MODULE)
+  endif()
+
+  if(ARG_EXCLUDE_FROM_ALL)
+    set(exclude_from_all EXCLUDE_FROM_ALL)
+  else()
+    set(exclude_from_all "")
+  endif()
+
+  add_library(${target_name} ${lib_type} ${exclude_from_all} ${ARG_UNPARSED_ARGUMENTS})
+
+  target_link_libraries(${target_name} PRIVATE pybind11::module)
+
+  if(ARG_SYSTEM)
+    message(
+      STATUS
+        "Warning: this does not have an effect - use NO_SYSTEM_FROM_IMPORTED if using imported targets"
+    )
+  endif()
+
+  pybind11_extension(${target_name})
+
+  # -fvisibility=hidden is required to allow multiple modules compiled against
+  # different pybind versions to work properly, and for some features (e.g.
+  # py::module_local).  We force it on everything inside the `pybind11`
+  # namespace; also turning it on for a pybind module compilation here avoids
+  # potential warnings or issues from having mixed hidden/non-hidden types.
+  if(NOT DEFINED CMAKE_CXX_VISIBILITY_PRESET)
+    set_target_properties(${target_name} PROPERTIES CXX_VISIBILITY_PRESET "hidden")
+  endif()
+
+  if(NOT DEFINED CMAKE_CUDA_VISIBILITY_PRESET)
+    set_target_properties(${target_name} PROPERTIES CUDA_VISIBILITY_PRESET "hidden")
+  endif()
+
+  if(ARG_NO_EXTRAS)
+    return()
+  endif()
+
+  if(NOT DEFINED CMAKE_INTERPROCEDURAL_OPTIMIZATION)
+    if(ARG_THIN_LTO)
+      target_link_libraries(${target_name} PRIVATE pybind11::thin_lto)
+    else()
+      target_link_libraries(${target_name} PRIVATE pybind11::lto)
+    endif()
+  endif()
+
+  if(NOT MSVC AND NOT ${CMAKE_BUILD_TYPE} MATCHES Debug|RelWithDebInfo)
+    pybind11_strip(${target_name})
+  endif()
+
+  if(MSVC)
+    target_link_libraries(${target_name} PRIVATE pybind11::windows_extras)
+  endif()
+
+  if(ARG_OPT_SIZE)
+    target_link_libraries(${target_name} PRIVATE pybind11::opt_size)
+  endif()
+endfunction()
+
+# Provide general way to call common Python commands in "common" file.
+set(_Python
+    PYTHON
+    CACHE INTERNAL "" FORCE)

third-party/DPVO/Pangolin/components/pango_python/pybind11/tools/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

third-party/DPVO/Pangolin/components/pango_python/pybind11/tools/setup_global.py.in

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Setup script for pybind11-global (in the sdist or in tools/setup_global.py in the repository)
+# This package is targeted for easy use from CMake.
+
+import contextlib
+import glob
+import os
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+
+# Setuptools has to be before distutils
+from setuptools import setup
+
+from distutils.command.install_headers import install_headers
+
+class InstallHeadersNested(install_headers):
+    def run(self):
+        headers = self.distribution.headers or []
+        for header in headers:
+            # Remove pybind11/include/
+            short_header = header.split("/", 2)[-1]
+
+            dst = os.path.join(self.install_dir, os.path.dirname(short_header))
+            self.mkpath(dst)
+            (out, _) = self.copy_file(header, dst)
+            self.outfiles.append(out)
+
+
+main_headers = glob.glob("pybind11/include/pybind11/*.h")
+detail_headers = glob.glob("pybind11/include/pybind11/detail/*.h")
+stl_headers = glob.glob("pybind11/include/pybind11/stl/*.h")
+cmake_files = glob.glob("pybind11/share/cmake/pybind11/*.cmake")
+headers = main_headers + detail_headers + stl_headers
+
+cmdclass = {"install_headers": InstallHeadersNested}
+$extra_cmd
+
+# This will _not_ affect installing from wheels,
+# only building wheels or installing from SDist.
+# Primarily intended on Windows, where this is sometimes
+# customized (for example, conda-forge uses Library/)
+base = os.environ.get("PYBIND11_GLOBAL_PREFIX", "")
+
+# Must have a separator
+if base and not base.endswith("/"):
+    base += "/"
+
+setup(
+    name="pybind11_global",
+    version="$version",
+    packages=[],
+    headers=headers,
+    data_files=[
+        (base + "share/cmake/pybind11", cmake_files),
+        (base + "include/pybind11", main_headers),
+        (base + "include/pybind11/detail", detail_headers),
+        (base + "include/pybind11/stl", stl_headers),
+    ],
+    cmdclass=cmdclass,
+)

third-party/DPVO/Pangolin/components/pango_python/pybind11/tools/setup_main.py.in

@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# Setup script (in the sdist or in tools/setup_main.py in the repository)
+
+from setuptools import setup
+
+cmdclass = {}
+$extra_cmd
+
+setup(
+    name="pybind11",
+    version="$version",
+    download_url='https://github.com/pybind/pybind11/tarball/v$version',
+    packages=[
+        "pybind11",
+        "pybind11.include.pybind11",
+        "pybind11.include.pybind11.detail",
+        "pybind11.include.pybind11.stl",
+        "pybind11.share.cmake.pybind11",
+    ],
+    package_data={
+        "pybind11": ["py.typed", "*.pyi"],
+        "pybind11.include.pybind11": ["*.h"],
+        "pybind11.include.pybind11.detail": ["*.h"],
+        "pybind11.include.pybind11.stl": ["*.h"],
+        "pybind11.share.cmake.pybind11": ["*.cmake"],
+    },
+    extras_require={
+        "global": ["pybind11_global==$version"]
+        },
+    entry_points={
+        "console_scripts": [
+             "pybind11-config = pybind11.__main__:main",
+        ],
+        "pipx.run": [
+             "pybind11 = pybind11.__main__:main",
+        ]
+    },
+    cmdclass=cmdclass
+)

third-party/DPVO/Pangolin/components/pango_python/src/pyinterpreter.cpp

@@ -0,0 +1,217 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * 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.
+ */
+#include <pangolin/python/pyinterpreter.h>
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/var/varextra.h>
+#include <pangolin/factory/factory_registry.h>
+
+#include <pybind11/embed.h>
+namespace py = pybind11;
+
+#include "pypangolin/pypangoio.h"
+
+namespace pangolin
+{
+
+void  PyInterpreter::NewVarCallback(const pangolin::VarState::Event& e)
+{
+    if(e.action == VarState::Event::Action::Added) {
+        const std::string name = e.var->Meta().full_name;
+        const size_t dot = name.find_first_of('.');
+        if(dot != std::string::npos) {
+            const std::string base_prefix = name.substr(0,dot);
+            if( base_prefixes.find(base_prefix) == base_prefixes.end() ) {
+                base_prefixes.insert(base_prefix);
+                std::string cmd =
+                    base_prefix + std::string(" = pypangolin.Var('") +
+                    base_prefix + std::string("')\n");
+                PyRun_SimpleString(cmd.c_str());
+            }
+        }
+    }
+}
+
+PyInterpreter::PyInterpreter()
+{
+    using namespace py_pangolin;
+    auto pypangolin = py::module_::import("pypangolin");
+    
+    auto sys = py::module_::import("sys");
+    if(sys) {
+        // TODO: What is the lifetime of PyPangoIO?
+        PyPangoIO* wrap_stdout = new PyPangoIO(line_queue, ConsoleLineTypeStdout);
+        PyPangoIO* wrap_stderr = new PyPangoIO(line_queue, ConsoleLineTypeStderr);
+        sys.add_object("stdout", py::cast(wrap_stdout), true);
+        sys.add_object("stderr", py::cast(wrap_stderr), true);
+     } else {
+         pango_print_error("Couldn't import module sys.\n");
+     }
+
+     // Attempt to setup readline completion
+    py::exec(
+         "import pypangolin\n"
+         "try:\n"
+         "   import readline\n"
+         "except ImportError:\n"
+         "   import pyreadline as readline\n"
+         "\n"
+         "import rlcompleter\n"
+         "pypangolin.completer = rlcompleter.Completer()\n"
+     );
+     CheckPrintClearError();
+
+     // Get reference to rlcompleter.Completer() for tab-completion
+     pycompleter = pypangolin.attr("completer");
+     pycomplete  = pycompleter.attr("complete");
+
+     // Register for notifications on var additions
+     var_added_connection = VarState::I().RegisterForVarEvents(
+         std::bind(&PyInterpreter::NewVarCallback,this,std::placeholders::_1),
+         true
+     );
+
+     CheckPrintClearError();
+
+     // TODO: For some reason the completion will crash when the command contains '.'
+     // unless we have executed anything that returns a value...
+     // We probably have a PyRef issue, maybe?
+     py::eval<py::eval_single_statement>("import sys");
+     py::eval<py::eval_single_statement>("sys.version");
+}
+
+PyInterpreter::~PyInterpreter()
+{
+}
+
+std::string PyInterpreter::ToString(const py::object& py)
+{
+    auto pystr = py::repr(py);
+    return std::string(PyUnicode_AsUTF8(pystr.ptr()));
+}
+
+void PyInterpreter::CheckPrintClearError()
+{
+    if(PyErr_Occurred()) {
+        PyErr_Print();
+        PyErr_Clear();
+    }
+}
+
+py::object PyInterpreter::EvalExec(const std::string& cmd)
+{
+    py::object ret = py::none();
+
+    if(!cmd.empty()) {
+        try {
+            ret = py::eval(cmd);
+        }  catch (const pybind11::error_already_set& e) {
+            line_queue.push(
+                InterpreterLine(e.what(), ConsoleLineTypeStderr)
+            );
+        }
+        CheckPrintClearError();
+    }
+
+    return ret;
+}
+
+std::vector<std::string> PyInterpreter::Complete(const std::string& cmd, int max_options)
+{
+    // TODO: When there is exactly 1 completion and it is smaller than our current string, we must invoke again with the prefix removed.
+
+    std::vector<std::string> ret;
+    PyErr_Clear();
+
+    if(pycomplete) {
+        for(int i=0; i < max_options; ++i) {
+            auto args = PyTuple_Pack( 2, PyUnicode_FromString(cmd.c_str()), PyLong_FromSize_t(i) );
+            auto result = PyObject_CallObject(pycomplete.ptr(), args);
+
+            if (result && PyUnicode_Check(result)) {
+                std::string res_str(PyUnicode_AsUTF8(result));
+                ret.push_back( res_str );
+                Py_DecRef(args);
+                Py_DecRef(result);
+            }else{
+                Py_DecRef(args);
+                Py_DecRef(result);
+                break;
+            }
+        }
+    }
+
+    return ret;
+}
+
+void PyInterpreter::PushCommand(const std::string& cmd)
+{
+    if(!cmd.empty()) {
+        try {
+            py::eval<py::eval_single_statement>(cmd);
+        }  catch (const pybind11::error_already_set& e) {
+            line_queue.push(
+                InterpreterLine(e.what(), ConsoleLineTypeStderr)
+            );
+        }
+    }
+}
+
+bool PyInterpreter::PullLine(InterpreterLine& line)
+{
+    if(line_queue.size()) {
+        line = line_queue.front();
+        line_queue.pop();
+        return true;
+    }else{
+        return false;
+    }
+}
+
+PANGOLIN_REGISTER_FACTORY_WITH_STATIC_INITIALIZER(PyInterpreter)
+{
+    struct PyInterpreterFactory final : public TypedFactoryInterface<InterpreterInterface> {
+        std::map<std::string,Precedence> Schemes() const override
+        {
+            return {{"python",10}};
+        }
+        const char* Description() const override
+        {
+            return "Python line interpreter.";
+        }
+        ParamSet Params() const override
+        {
+            return {{}};
+        }
+        std::unique_ptr<InterpreterInterface> Open(const Uri& /*uri*/) override {
+            return std::unique_ptr<InterpreterInterface>(new PyInterpreter());
+        }
+    };
+
+    return FactoryRegistry::I()->RegisterFactory<InterpreterInterface>(std::make_shared<PyInterpreterFactory>());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/attach.cpp

@@ -0,0 +1,48 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "attach.hpp"
+#include <pangolin/gl/glinclude.h>
+#include <pangolin/display/attach.h>
+
+namespace py_pangolin {
+  void bind_attach(pybind11::module &m){
+    pybind11::enum_<pangolin::Unit>(m, "Unit")
+      .value("Fraction", pangolin::Unit::Fraction)
+      .value("Pixel", pangolin::Unit::Pixel)
+      .value("ReversePixel", pangolin::Unit::ReversePixel)
+      .export_values();
+
+    pybind11::class_<pangolin::Attach>(m, "Attach")
+      .def(pybind11::init<>())
+      .def(pybind11::init<pangolin::Unit, GLfloat>())
+      .def(pybind11::init<GLfloat>())
+      .def_static("Pix", &pangolin::Attach::Pix)
+      .def_static("ReversePix", &pangolin::Attach::ReversePix)
+      .def_static("Frac", &pangolin::Attach::Frac);
+  }
+}

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/attach.hpp

@@ -0,0 +1,37 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py_pangolin {
+  
+  void bind_attach(pybind11::module &m);
+
+}  // py_pangolin
+

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/colour.cpp

@@ -0,0 +1,48 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "colour.hpp"
+#include <pangolin/gl/colour.h>
+
+namespace py_pangolin {
+
+  void bind_colour(pybind11::module& m){
+    pybind11::class_<pangolin::Colour> (m, "Colour")
+      .def(pybind11::init<>())
+      .def(pybind11::init<const float, const float, const float, const float>(), pybind11::arg("red"), pybind11::arg("green"), pybind11::arg("blue"), pybind11::arg("alpha")=1.0f)
+      //      .def(pybind11::init<float[4]>())
+      .def("Get", &pangolin::Colour::Get)
+      .def_static("White", &pangolin::Colour::White)
+      .def_static("Black", &pangolin::Colour::Black)
+      .def_static("Red", &pangolin::Colour::Red)
+      .def_static("Green", &pangolin::Colour::Green)
+      .def_static("Blue", &pangolin::Colour::Blue)
+      .def_static("Hsv", &pangolin::Colour::Hsv)
+      .def("WithAlpha", &pangolin::Colour::WithAlpha);
+  }
+
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/colour.hpp

@@ -0,0 +1,37 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py_pangolin {
+
+  void bind_colour(pybind11::module& m);
+
+}  // py_pangolin
+

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/datalog.cpp

@@ -0,0 +1,86 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "datalog.hpp"
+
+#include <pybind11/stl.h>
+#include <pangolin/plot/datalog.h>
+
+namespace py_pangolin {
+
+  void bind_datalog(pybind11::module& m){
+    pybind11::class_<pangolin::DimensionStats >(m, "DimensionStats")
+      .def(pybind11::init<>())
+      .def("Reset", &pangolin::DimensionStats::Reset)
+      .def("Add", &pangolin::DimensionStats::Add)
+      .def_readwrite("isMonotonic", &pangolin::DimensionStats::isMonotonic)
+      .def_readwrite("sum", &pangolin::DimensionStats::sum)
+      .def_readwrite("sum_sq", &pangolin::DimensionStats::sum_sq)
+      .def_readwrite("min", &pangolin::DimensionStats::min)
+      .def_readwrite("max", &pangolin::DimensionStats::max);
+
+    pybind11::class_<pangolin::DataLogBlock>(m, "DataLogBlock")
+      .def(pybind11::init<size_t,size_t,size_t>())
+      .def("Samples", &pangolin::DataLogBlock::Samples)
+      .def("MaxSamples", &pangolin::DataLogBlock::MaxSamples)
+      .def("SampleSpaceLeft", &pangolin::DataLogBlock::SampleSpaceLeft)
+      .def("IsFull", &pangolin::DataLogBlock::IsFull)
+      .def("AddSamples", &pangolin::DataLogBlock::AddSamples)
+      .def("ClearLinked", &pangolin::DataLogBlock::ClearLinked)
+      .def("NextBlock", &pangolin::DataLogBlock::NextBlock)
+      .def("StartId", &pangolin::DataLogBlock::StartId)
+      .def("DimData", &pangolin::DataLogBlock::DimData)
+      .def("Dimensions", &pangolin::DataLogBlock::Dimensions)
+      .def("Sample", &pangolin::DataLogBlock::Sample)
+      .def("StartId", &pangolin::DataLogBlock::StartId);    
+
+    pybind11::class_<pangolin::DataLog>(m, "DataLog")
+      .def(pybind11::init<unsigned int>(), pybind11::arg("block_samples_alloc")=10000)
+      .def("SetLabels", &pangolin::DataLog::SetLabels)
+      .def("Labels", &pangolin::DataLog::Labels)
+      .def("Log", (void (pangolin::DataLog::*)(size_t, const float*, unsigned int))&pangolin::DataLog::Log, pybind11::arg("dimension"), pybind11::arg("vals"), pybind11::arg("samples")=1)
+      .def("Log", (void (pangolin::DataLog::*)(float))&pangolin::DataLog::Log)
+      .def("Log", (void (pangolin::DataLog::*)(float, float))&pangolin::DataLog::Log)
+      .def("Log", (void (pangolin::DataLog::*)(float, float, float))&pangolin::DataLog::Log)
+      .def("Log", (void (pangolin::DataLog::*)(float, float, float, float))&pangolin::DataLog::Log)
+      .def("Log", (void (pangolin::DataLog::*)(float, float, float, float, float))&pangolin::DataLog::Log)
+      .def("Log", (void (pangolin::DataLog::*)(float, float, float, float, float, float))&pangolin::DataLog::Log)
+      .def("Log", (void (pangolin::DataLog::*)(float, float, float, float, float, float, float))&pangolin::DataLog::Log)
+      .def("Log", (void (pangolin::DataLog::*)(float, float, float, float, float, float, float, float))&pangolin::DataLog::Log)
+      .def("Log", (void (pangolin::DataLog::*)(float, float, float, float, float, float, float, float, float))&pangolin::DataLog::Log)
+      .def("Log", (void (pangolin::DataLog::*)(float, float, float, float, float, float, float, float, float, float))&pangolin::DataLog::Log)
+      .def("Log", (void (pangolin::DataLog::*)(const std::vector<float>&))&pangolin::DataLog::Log)
+      .def("Clear", &pangolin::DataLog::Clear)
+      .def("Save", &pangolin::DataLog::Save)
+      .def("FirstBlock", &pangolin::DataLog::FirstBlock)
+      .def("LastBlock", &pangolin::DataLog::LastBlock)
+      .def("Samples", &pangolin::DataLog::Samples)
+      .def("Sample", &pangolin::DataLog::Sample)
+      .def("Stats", &pangolin::DataLog::Stats);
+  }
+
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/datalog.hpp

@@ -0,0 +1,37 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py_pangolin {
+
+  void bind_datalog(pybind11::module& m);
+
+}  // py_pangolin
+

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/display.cpp

@@ -0,0 +1,81 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "display.hpp"
+#include <pangolin/display/display.h>
+#include <pangolin/display/view.h>
+#include <pybind11/functional.h>
+
+namespace py_pangolin {
+  
+  void bind_display(pybind11::module &m) {
+    m.def("CreateWindowAndBind",
+          &pangolin::CreateWindowAndBind,
+          pybind11::return_value_policy::reference,
+          pybind11::arg("window_title"),
+          pybind11::arg("w") = 640,
+          pybind11::arg("h") = 480,
+          pybind11::arg("params") = pangolin::Params());
+	
+    m.def("DestroyWindow",
+          &pangolin::DestroyWindow,
+          pybind11::arg("window_title"));
+
+    m.def("CreateDisplay",
+          &pangolin::CreateDisplay,
+          pybind11::return_value_policy::reference);
+
+    m.def("ShouldQuit",
+          &pangolin::ShouldQuit);
+
+    m.def("FinishFrame",
+          &pangolin::FinishFrame);
+
+    m.def("ShowFullscreen",
+          &pangolin::ShowFullscreen);
+
+    m.def("ShowConsole",
+          &pangolin::ShowConsole);
+
+    m.def("RegisterKeyPressCallback",
+          [](int v, const std::function<void()>& f){
+            pangolin::RegisterKeyPressCallback(v, f);
+          }
+    );
+    
+    m.def("DisplayBase",
+          &pangolin::DisplayBase,
+          pybind11::return_value_policy::reference);
+
+    m.def("Display",
+          &pangolin::Display,
+          pybind11::return_value_policy::reference,
+          pybind11::arg("name"));
+
+  }
+
+}  // Py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/display.hpp

@@ -0,0 +1,36 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py_pangolin {
+  
+  void bind_display(pybind11::module &m);
+
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/gl.cpp

@@ -0,0 +1,119 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "gl.hpp"
+#include <pangolin/gl/gl.h>
+#include <pybind11/numpy.h>
+
+namespace py_pangolin {
+
+  bool is_packed(const pybind11::buffer_info & info) {
+    int next_expected_stride = info.itemsize;
+    for (int i = info.ndim-1; i >= 0; --i) {
+      if (!(info.strides[i] == next_expected_stride)) {
+        return false;
+      }
+      next_expected_stride *= info.shape[i];
+    }
+    return true;
+  }
+
+  void bind_gl(pybind11::module &m) {
+
+    pybind11::class_<pangolin::GlTexture>(m, "GlTexture")
+      .def(pybind11::init<>())
+      .def(pybind11::init<GLint, GLint, GLint, bool, int, GLenum, GLenum>(), pybind11::arg("width"), pybind11::arg("height"), pybind11::arg("internal_format") = GL_RGBA8, pybind11::arg("sampling_linear") = true, pybind11::arg("border") = 0, pybind11::arg("glformat") = GL_RGBA, pybind11::arg("gltype") = GL_UNSIGNED_BYTE)
+      .def("Reinitialise", &pangolin::GlTexture::Reinitialise)
+      .def("Bind", &pangolin::GlTexture::Bind)
+      .def("Unbind", &pangolin::GlTexture::Unbind)
+      .def("Upload", [](pangolin::GlTexture & texture, pybind11::buffer b, GLenum data_format, GLenum type){
+        pybind11::buffer_info info = b.request();
+        texture.Upload(info.ptr, data_format, type);
+      })
+      .def("Download", [](pangolin::GlTexture & texture, pybind11::buffer b, GLenum data_layout, GLenum data_type) {
+        pybind11::buffer_info info = b.request();
+        if (!is_packed(info)) {
+          throw std::runtime_error("cannot Download into non-packed buffer");
+        }
+        texture.Download(info.ptr, data_layout, data_type);
+      })
+      .def("Save", &pangolin::GlTexture::Save, pybind11::arg("filename"), pybind11::arg("top_line_first")=true)
+      .def("RenderToViewport", (void (pangolin::GlTexture::*)() const)&pangolin::GlTexture::RenderToViewport)
+      .def("RenderToViewportFlipY", &pangolin::GlTexture::RenderToViewportFlipY)
+      .def("SetNearestNeighbour", &pangolin::GlTexture::SetNearestNeighbour)
+      .def_readonly("width", &pangolin::GlTexture::width)
+      .def_readonly("height", &pangolin::GlTexture::height)
+      .def_readonly("id", &pangolin::GlTexture::tid);
+
+    pybind11::class_<pangolin::GlRenderBuffer>(m, "GlRenderBuffer")
+      .def(pybind11::init<GLint, GLint, GLint>(), pybind11::arg("width")=0, pybind11::arg("height")=0, pybind11::arg("internal_format") = GL_DEPTH_COMPONENT24)
+      .def("Reinitialise", &pangolin::GlRenderBuffer::Reinitialise);
+
+    pybind11::class_<pangolin::GlFramebuffer>(m, "GlFramebuffer")
+      .def(pybind11::init<>())
+      .def(pybind11::init<pangolin::GlTexture &, pangolin::GlRenderBuffer &>())
+      .def("Reinitialise", &pangolin::GlFramebuffer::Reinitialise)
+      .def("AttachColour", &pangolin::GlFramebuffer::AttachColour)
+      .def("AttachDepth", &pangolin::GlFramebuffer::AttachDepth)
+      .def("Bind", &pangolin::GlFramebuffer::Bind)
+      .def("Unbind", &pangolin::GlFramebuffer::Unbind);
+
+    pybind11::enum_<pangolin::GlBufferType>(m, "GlBufferType")
+      .value("GlUndefined", pangolin::GlBufferType::GlUndefined)
+      .value("GlArrayBuffer", pangolin::GlBufferType::GlArrayBuffer)
+      .value("GlElementArrayBuffer", pangolin::GlBufferType::GlElementArrayBuffer)
+#ifndef HAVE_GLES
+      .value("GlPixelPackBuffer", pangolin::GlBufferType::GlPixelPackBuffer)
+      .value("GlPixelUnpackBuffer", pangolin::GlBufferType::GlPixelUnpackBuffer)
+      .value("GlShaderStorageBuffer", pangolin::GlBufferType::GlShaderStorageBuffer)
+#endif
+      .export_values();
+
+    pybind11::class_<pangolin::GlBufferData>(m, "GlBufferData")
+      .def(pybind11::init<>())
+      .def("Reinitialise", [](pangolin::GlBufferData & gl_buffer, pangolin::GlBufferType buffer_type, GLuint size_bytes, GLenum gl_use) {
+        gl_buffer.Reinitialise(buffer_type, size_bytes, gl_use);
+      })
+      .def("Bind", &pangolin::GlBufferData::Bind)
+      .def("Unbind", &pangolin::GlBufferData::Unbind)
+      .def("Upload", [](pangolin::GlBufferData & gl_buffer, pybind11::buffer b, GLsizeiptr size_bytes, GLintptr offset) {
+        pybind11::buffer_info info = b.request();
+        gl_buffer.Upload(info.ptr, size_bytes, offset);
+      }, pybind11::arg("data"), pybind11::arg("size_bytes"), pybind11::arg("offset")=0)
+      .def_readwrite("size_bytes", &pangolin::GlBufferData::size_bytes);
+
+    pybind11::class_<pangolin::GlBuffer, pangolin::GlBufferData>(m, "GlBuffer")
+      .def(pybind11::init<>())
+      .def(pybind11::init<pangolin::GlBufferType, GLuint, GLenum, GLuint, GLenum>(), pybind11::arg("buffer_type"), pybind11::arg("num_elements"), pybind11::arg("datatype"), pybind11::arg("count_per_element"), pybind11::arg("gluse")=GL_DYNAMIC_DRAW)
+      .def("Resize", &pangolin::GlBuffer::Resize, pybind11::arg("num_elements"))
+      .def_readwrite("num_elements", &pangolin::GlBuffer::num_elements)
+      .def_readwrite("count_per_element", &pangolin::GlBuffer::count_per_element);
+
+  }
+
+
+} // namespace py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/gl.hpp

@@ -0,0 +1,36 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py_pangolin {
+
+    void bind_gl(pybind11::module &m);
+
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/gl_draw.cpp

@@ -0,0 +1,112 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "gl_draw.hpp"
+#include <pangolin/gl/gldraw.h>
+#include <pybind11/eigen.h>
+#include <pybind11/stl.h>
+
+namespace py_pangolin {
+
+  void bind_gl_draw(pybind11::module &m){
+
+    m.def("glDrawAxis",
+          (void (*)(float))&pangolin::glDrawAxis);
+
+    m.def("glDrawColouredCube",
+          &pangolin::glDrawColouredCube,
+          pybind11::arg("axis_min") = -0.5f,
+          pybind11::arg("axis_max") = +0.5f);
+
+    m.def("glDraw_x0",
+          &pangolin::glDraw_x0);
+    m.def("glDraw_y0",
+          &pangolin::glDraw_y0);
+    m.def("glDraw_z0",
+          &pangolin::glDraw_z0);
+
+    m.def("glDrawFrustum", (void (*)(GLfloat, GLfloat, GLfloat, GLfloat, int, int, GLfloat)) &pangolin::glDrawFrustum);
+    m.def("glDrawFrustum", (void (*)(const Eigen::Matrix3f &, int, int, GLfloat)) &pangolin::glDrawFrustum<float>);
+    m.def("glDrawFrustum", (void (*)(const Eigen::Matrix3d &, int, int, GLfloat)) &pangolin::glDrawFrustum<double>);
+    m.def("glDrawFrustum", (void (*)(const Eigen::Matrix3f &, int, int, const Eigen::Matrix4f &, float)) &pangolin::glDrawFrustum<float>);
+    m.def("glDrawFrustum", (void (*)(const Eigen::Matrix3d &, int, int, const Eigen::Matrix4d &, double)) &pangolin::glDrawFrustum<double>);
+
+    m.def("glDrawTexture", (void (*)(GLenum, GLint)) &pangolin::glDrawTexture);
+    m.def("glDrawTextureFlipY", (void (*)(GLenum, GLint)) &pangolin::glDrawTextureFlipY);
+
+    m.def("glDrawAxis", (void (*)(float)) &pangolin::glDrawAxis);
+    m.def("glDrawAxis", (void (*)(const Eigen::Matrix4f &, float)) &pangolin::glDrawAxis<Eigen::Matrix4f, float>);
+    m.def("glDrawAxis", (void (*)(const Eigen::Matrix4d &, float)) &pangolin::glDrawAxis<Eigen::Matrix4d, float>);
+
+    m.def("glSetFrameOfReference", (void (*)(const Eigen::Matrix4f &)) &pangolin::glSetFrameOfReference);
+    m.def("glSetFrameOfReference", (void (*)(const Eigen::Matrix4d &)) &pangolin::glSetFrameOfReference);
+
+    m.def("glUnsetFrameOfReference", &pangolin::glUnsetFrameOfReference);
+
+    m.def("glDrawVertices", &pangolin::glDrawPoints<float, 2, std::allocator<Eigen::Vector2f> >);
+    m.def("glDrawVertices", &pangolin::glDrawPoints<float, 3, std::allocator<Eigen::Vector3f> >);
+    m.def("glDrawVertices", &pangolin::glDrawPoints<double, 2, std::allocator<Eigen::Vector2d> >);
+    m.def("glDrawVertices", &pangolin::glDrawPoints<double, 3, std::allocator<Eigen::Vector3d> >);
+
+    m.def("glDrawPoints", &pangolin::glDrawPoints<float, 2, std::allocator<Eigen::Vector2f> >);
+    m.def("glDrawPoints", &pangolin::glDrawPoints<float, 3, std::allocator<Eigen::Vector3f> >);
+    m.def("glDrawPoints", &pangolin::glDrawPoints<double, 2, std::allocator<Eigen::Vector2d> >);
+    m.def("glDrawPoints", &pangolin::glDrawPoints<double, 3, std::allocator<Eigen::Vector3d> >);
+
+    m.def("glDrawLines", &pangolin::glDrawLines<float, 2, std::allocator<Eigen::Vector2f> >);
+    m.def("glDrawLines", &pangolin::glDrawLines<float, 3, std::allocator<Eigen::Vector3f> >);
+    m.def("glDrawLines", &pangolin::glDrawLines<double, 2, std::allocator<Eigen::Vector2d> >);
+    m.def("glDrawLines", &pangolin::glDrawLines<double, 3, std::allocator<Eigen::Vector3d> >);
+
+    m.def("glDrawLineStrip", &pangolin::glDrawLineStrip<float, 2, std::allocator<Eigen::Vector2f> >);
+    m.def("glDrawLineStrip", &pangolin::glDrawLineStrip<float, 3, std::allocator<Eigen::Vector3f> >);
+    m.def("glDrawLineStrip", &pangolin::glDrawLineStrip<double, 2, std::allocator<Eigen::Vector2d> >);
+    m.def("glDrawLineStrip", &pangolin::glDrawLineStrip<double, 3, std::allocator<Eigen::Vector3d> >);
+
+    m.def("glDrawLineLoop", &pangolin::glDrawLineLoop<float, 2, std::allocator<Eigen::Vector2f> >);
+    m.def("glDrawLineLoop", &pangolin::glDrawLineLoop<float, 3, std::allocator<Eigen::Vector3f> >);
+    m.def("glDrawLineLoop", &pangolin::glDrawLineLoop<double, 2, std::allocator<Eigen::Vector2d> >);
+    m.def("glDrawLineLoop", &pangolin::glDrawLineLoop<double, 3, std::allocator<Eigen::Vector3d> >);
+
+    m.def("glDrawAlignedBox", (void (*)(const Eigen::AlignedBox2f &, GLenum)) &pangolin::glDrawAlignedBox<float>, pybind11::arg("box"), pybind11::arg("mode") = GL_TRIANGLE_FAN);
+ 
+    m.def("glDrawCirclePerimeter", (void (*)(float, float, float)) &pangolin::glDrawCirclePerimeter);
+    m.def("glDrawCirclePerimeter", (void (*)(const Eigen::Vector2d &, double)) &pangolin::glDrawCirclePerimeter);
+
+    m.def("glDrawRectPerimeter", &pangolin::glDrawRectPerimeter);
+
+    m.def("glDrawCross",  (void (*)(GLfloat, GLfloat, GLfloat)) &pangolin::glDrawCross);
+    m.def("glDrawCross",  (void (*)(GLfloat, GLfloat, GLfloat, GLfloat)) &pangolin::glDrawCross);
+    m.def("glDrawCross",  (void (*)(const Eigen::Vector2d &, double)) &pangolin::glDrawCross);
+    m.def("glDrawCross",  (void (*)(const Eigen::Vector3d &, double)) &pangolin::glDrawCross);
+
+    m.def("glDrawCircle", (void (*)(float, float, float)) &pangolin::glDrawCircle);
+    m.def("glDrawCircle", (void (*)(const Eigen::Vector2d &, double)) &pangolin::glDrawCircle);
+  }
+
+
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/gl_draw.hpp

@@ -0,0 +1,37 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py_pangolin {
+  
+  void bind_gl_draw(pybind11::module &m);
+
+}  // py_pangolin
+

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/glsl.cpp

@@ -0,0 +1,72 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "glsl.hpp"
+#include <pangolin/gl/glsl.h>
+#include <pybind11/eigen.h>
+#include <pybind11/stl.h>
+
+namespace py_pangolin {
+
+  void bind_glsl(pybind11::module &m) {
+
+    pybind11::enum_<pangolin::GlSlShaderType>(m, "GlSlShaderType")
+      .value("GlSlAnnotatedShader", pangolin::GlSlShaderType::GlSlAnnotatedShader)
+      .value("GlSlFragmentShader", pangolin::GlSlShaderType::GlSlFragmentShader)
+      .value("GlSlVertexShader", pangolin::GlSlShaderType::GlSlVertexShader)
+      .value("GlSlGeometryShader", pangolin::GlSlShaderType::GlSlGeometryShader)
+      .value("GlSlComputeShader", pangolin::GlSlShaderType::GlSlComputeShader)
+      .export_values();
+
+    pybind11::class_<pangolin::GlSlProgram>(m, "GlSlProgram")
+      .def(pybind11::init<>())
+      .def("AddShader", &pangolin::GlSlProgram::AddShader, pybind11::arg("shader_type"), pybind11::arg("filename"), pybind11::arg("program_defines")=std::map<std::string,std::string>(), pybind11::arg("search_path")=std::vector<std::string>())
+      .def("AddShaderFromFile", &pangolin::GlSlProgram::AddShaderFromFile)
+      .def("Link", &pangolin::GlSlProgram::Link)
+      .def("GetAttributeHandle", &pangolin::GlSlProgram::GetAttributeHandle)
+      .def("GetUniformHandle", &pangolin::GlSlProgram::GetUniformHandle)
+      .def("SetUniform", (void (pangolin::GlSlProgram::*)(const std::string &, int))&pangolin::GlSlProgram::SetUniform)
+      .def("SetUniform", (void (pangolin::GlSlProgram::*)(const std::string &, int, int))&pangolin::GlSlProgram::SetUniform)
+      .def("SetUniform", (void (pangolin::GlSlProgram::*)(const std::string &, int, int, int))&pangolin::GlSlProgram::SetUniform)
+      .def("SetUniform", (void (pangolin::GlSlProgram::*)(const std::string &, int, int, int, int))&pangolin::GlSlProgram::SetUniform)
+      .def("SetUniform", (void (pangolin::GlSlProgram::*)(const std::string &, float))&pangolin::GlSlProgram::SetUniform)
+      .def("SetUniform", (void (pangolin::GlSlProgram::*)(const std::string &, float, float))&pangolin::GlSlProgram::SetUniform)
+      .def("SetUniform", (void (pangolin::GlSlProgram::*)(const std::string &, float, float, float))&pangolin::GlSlProgram::SetUniform)
+      .def("SetUniform", (void (pangolin::GlSlProgram::*)(const std::string &, float, float, float, float))&pangolin::GlSlProgram::SetUniform)
+      .def("SetUniform", (void (pangolin::GlSlProgram::*)(const std::string &, const pangolin::OpenGlMatrix &))&pangolin::GlSlProgram::SetUniform)
+#ifdef HAVE_EIGEN
+      .def("SetUniform", (void (pangolin::GlSlProgram::*)(const std::string &, const Eigen::Matrix3f &))&pangolin::GlSlProgram::SetUniform)
+      .def("SetUniform", (void (pangolin::GlSlProgram::*)(const std::string &, const Eigen::Matrix4f &))&pangolin::GlSlProgram::SetUniform)
+      .def("SetUniform", (void (pangolin::GlSlProgram::*)(const std::string &, const Eigen::Matrix3d &))&pangolin::GlSlProgram::SetUniform)
+      .def("SetUniform", (void (pangolin::GlSlProgram::*)(const std::string &, const Eigen::Matrix4d &))&pangolin::GlSlProgram::SetUniform)
+#endif
+      .def("Bind", &pangolin::GlSlProgram::Bind)
+      .def("Unbind", &pangolin::GlSlProgram::Unbind);
+
+  }
+
+}

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/glsl.hpp

@@ -0,0 +1,36 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py_pangolin {
+
+    void bind_glsl(pybind11::module &m);
+
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/glvbo.cpp

@@ -0,0 +1,48 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "glvbo.hpp"
+#include <pangolin/gl/glvbo.h>
+
+namespace py_pangolin {
+
+  void bind_glvbo(pybind11::module &m){
+
+    m.def("MakeTriangleStripIboForVbo", (pangolin::GlBuffer (*)(int, int))&pangolin::MakeTriangleStripIboForVbo, pybind11::arg("w"), pybind11::arg("h"), pybind11::return_value_policy::move);
+
+    m.def("RenderVbo", (void(*)(pangolin::GlBuffer&, GLenum))&pangolin::RenderVbo, pybind11::arg("vbo"), pybind11::arg("mode")=GL_POINTS);
+    m.def("RenderVbo", (void(*)(pangolin::GlBuffer&, const GLuint, GLenum))&pangolin::RenderVbo, pybind11::arg("vbo"), pybind11::arg("count"), pybind11::arg("mode")=GL_POINTS);
+    m.def("RenderVboCbo", &pangolin::RenderVboCbo, pybind11::arg("vbo"), pybind11::arg("cbo"), pybind11::arg("draw_color")=true, pybind11::arg("mode")=GL_POINTS);
+    m.def("RenderVboIbo", &pangolin::RenderVboIbo, pybind11::arg("vbo"), pybind11::arg("ibo"), pybind11::arg("draw_mesh")=true);
+    m.def("RenderVboIboCbo", &pangolin::RenderVboIboCbo, pybind11::arg("vbo"), pybind11::arg("ibo"), pybind11::arg("cbo"), pybind11::arg("draw_mesh")=true, pybind11::arg("draw_color")=true);
+    m.def("RenderVboIboNbo", &pangolin::RenderVboIboNbo, pybind11::arg("vbo"), pybind11::arg("ibo"), pybind11::arg("nbo"), pybind11::arg("draw_mesh")=true, pybind11::arg("draw_normals")=true);
+    m.def("RenderVboIboCboNbo", &pangolin::RenderVboIboCboNbo, pybind11::arg("vbo"), pybind11::arg("ibo"), pybind11::arg("cbo"), pybind11::arg("nbo"), pybind11::arg("draw_mesh")=true, pybind11::arg("draw_color")=true, pybind11::arg("draw_normals")=true);
+
+  }
+
+
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/glvbo.hpp

@@ -0,0 +1,36 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py_pangolin {
+
+  void bind_glvbo(pybind11::module &m);
+
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/handler.cpp

@@ -0,0 +1,58 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "handler.hpp"
+#include <pangolin/handler/handler.h>
+#include <pangolin/gl/opengl_render_state.h>
+#include <pangolin/plot/plotter.h>
+
+
+namespace py_pangolin {
+  
+  void bind_handler(pybind11::module &m) {
+    
+    pybind11::class_<pangolin::Handler, PyHandler> handler(m, "Handler");
+    handler
+      .def(pybind11::init<>())
+      .def("Keyboard", &pangolin::Handler::Keyboard)
+      .def("Mouse", &pangolin::Handler::Mouse)
+      .def("MouseMotion", &pangolin::Handler::MouseMotion)
+      .def("PassiveMouseMotion", &pangolin::Handler::PassiveMouseMotion)
+      .def("Special", &pangolin::Handler::Special);
+
+    pybind11::class_<pangolin::Handler3D>(m, "Handler3D", handler)
+      .def(pybind11::init<pangolin::OpenGlRenderState&, pangolin::AxisDirection, float, float>(), pybind11::arg("state"), pybind11::arg("enforce_up") = pangolin::AxisNone, pybind11::arg("trans_scale")=0.01f, pybind11::arg("zoom_factor")=PANGO_DFLT_HANDLER3D_ZF)
+      .def("ValidWinDepth", &pangolin::Handler3D::ValidWinDepth)
+      .def("PixelUnproject", &pangolin::Handler3D::PixelUnproject)
+      .def("GetPosNormal", &pangolin::Handler3D::GetPosNormal)
+      .def("Keyboard", &pangolin::Handler3D::Keyboard)
+      .def("Mouse", &pangolin::Handler3D::Mouse)
+      .def("MouseMotion", &pangolin::Handler3D::MouseMotion)
+      .def("Special", &pangolin::Handler3D::Special);
+
+  }
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/handler.hpp

@@ -0,0 +1,62 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+#include <pangolin/handler/handler.h>
+#include <pangolin/display/view.h>
+
+namespace py_pangolin {
+  
+  class PyHandler : public pangolin::Handler {
+  public:
+    using pangolin::Handler::Handler;
+
+    void Keyboard(pangolin::View& v, unsigned char key, int x, int y, bool pressed) override {
+      PYBIND11_OVERLOAD(void, pangolin::Handler, Keyboard, v, key, x, y, pressed);
+    }
+    void Mouse(pangolin::View& v, pangolin::MouseButton button, int x, int y, bool pressed, int button_state) override {
+      PYBIND11_OVERLOAD(void, pangolin::Handler, Mouse, v, button, x, y, pressed, button_state);
+    }
+
+    void MouseMotion(pangolin::View& v, int x, int y, int button_state) override {
+      PYBIND11_OVERLOAD(void, pangolin::Handler, MouseMotion, v, x, y, button_state);
+    }
+    void PassiveMouseMotion(pangolin::View& v, int x, int y, int button_state) override {
+      PYBIND11_OVERLOAD(void, pangolin::Handler, PassiveMouseMotion, v, x, y, button_state);
+    }
+      
+    void Special(pangolin::View& v, pangolin::InputSpecial inType, float x, float y, float p1, float p2, float p3, float p4, int button_state) override{
+      PYBIND11_OVERLOAD(void, pangolin::Handler, Special, v, inType, x, y, p1, p2, p3, p4, button_state);
+    }
+  };
+
+  void bind_handler(pybind11::module &m);
+
+}  // py_pangolin
+

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/image.cpp

@@ -0,0 +1,34 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "image.hpp"
+#include <pangolin/image/image.h>
+
+namespace py_pangolin {
+  
+}  // py_pangolin
+

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/image.hpp

@@ -0,0 +1,67 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+#include <pangolin/image/image.h>
+
+namespace py_pangolin {
+
+  template<typename T>
+  void bind_image(pybind11::module& m, const std::string& pyname){
+    pybind11::class_<pangolin::Image<T> >(m, pyname.c_str())
+      .def(pybind11::init<>())
+      .def(pybind11::init<T*, size_t, size_t, size_t>())
+      .def("SizeBytes", &pangolin::Image<T>::SizeBytes)
+      .def("Area", &pangolin::Image<T>::Area)
+      .def("IsValid", &pangolin::Image<T>::IsValid)
+      .def("IsContiguous", &pangolin::Image<T>::IsContiguous)
+      .def("begin", (unsigned char* (pangolin::Image<T>::*)())&pangolin::Image<T>::begin)
+      .def("end", (unsigned char* (pangolin::Image<T>::*)())&pangolin::Image<T>::end)
+      .def("begin", (const unsigned char* (pangolin::Image<T>::*)() const )&pangolin::Image<T>::begin)
+      .def("end", (const unsigned char* (pangolin::Image<T>::*)() const )&pangolin::Image<T>::end)
+      .def("size", &pangolin::Image<T>::size)
+      .def("Fill", &pangolin::Image<T>::Fill)
+      .def("Replace", &pangolin::Image<T>::Replace)
+      .def("Memset", &pangolin::Image<T>::Memset)
+      .def("CopyFrom", &pangolin::Image<T>::CopyFrom)
+      .def("MinMax", &pangolin::Image<T>::MinMax)
+      // .def("Sum", [](pangolin::Image<T>& v){ return v.Sum();})
+      // .def("Mean", [](pangolin::Image<T>& v){ return v.Mean();})
+      .def("RowPtr", (T* (pangolin::Image<T>::*)(size_t))&pangolin::Image<T>::RowPtr)
+      .def("RowPtr", (const T* (pangolin::Image<T>::*)(size_t) const )&pangolin::Image<T>::RowPtr)
+      .def("InImage", &pangolin::Image<T>::InImage)
+      .def("InBounds", (bool (pangolin::Image<T>::*)(int, int) const)&pangolin::Image<T>::InBounds)
+      .def("InBounds", (bool (pangolin::Image<T>::*)(float, float, float) const)&pangolin::Image<T>::InBounds)
+      // .def("SubImage", (pangolin::Image<T> (pangolin::Image<T>::*)(size_t, size_t, size_t, size_t))&pangolin::Image<T>::SubImage)
+      // .def("Row", &pangolin::Image<T>::Row)
+      // .def("Col", &pangolin::Image<T>::Col)
+      .def("InImage", &pangolin::Image<T>::InImage);
+  }
+
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/image_view.cpp

@@ -0,0 +1,81 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Steven Lovegrove
+ *
+ * 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.
+ */
+
+#include "image_view.hpp"
+#include <pangolin/display/image_view.h>
+#include <pybind11/numpy.h>
+
+namespace py_pangolin {
+
+  void bind_image_view(pybind11::module &m) {
+    using namespace pangolin;
+    pybind11::class_<ImageView, View>(m, "ImageView")
+      .def(pybind11::init<>())
+      .def("SetImage", [](ImageView& view, pybind11::array_t<float>& img, const std::string & format) -> ImageView&{
+        if(img.ndim() == 2) {
+            Image<uint8_t> wrapper((uint8_t*)img.mutable_data(0,0), img.shape(1), img.shape(0), img.strides(0));
+            return view.SetImage(wrapper, GlPixFormat(PixelFormatFromString(format.empty() ? "GRAY32F" : format)) );
+        }else if(img.ndim() == 3 && img.shape()[2] == 3) {
+            Image<uint8_t> wrapper((uint8_t*)img.mutable_data(0,0), img.shape(1), img.shape(0), img.strides(0));
+            return view.SetImage(wrapper, GlPixFormat(PixelFormatFromString(format.empty() ? "RGB96F" : format)) );
+        }else if(img.ndim() == 3 && img.shape()[2] == 4) {
+            Image<uint8_t> wrapper((uint8_t*)img.mutable_data(0,0), img.shape(1), img.shape(0), img.strides(0));
+            return view.SetImage(wrapper, GlPixFormat(PixelFormatFromString(format.empty() ? "RGB128F" : format)) );
+        }else{
+            throw std::runtime_error("Unsupported format for now.");
+        }
+      }, "Set image to display by ImageView", pybind11::arg("img"), pybind11::arg("format") = "")
+      .def("SetImage", [](ImageView& view, pybind11::array_t<uint8_t>& img, const std::string & format) -> ImageView&{
+        if(img.ndim() == 2) {
+            Image<uint8_t> wrapper((uint8_t*)img.mutable_data(0,0), img.shape(1), img.shape(0), img.strides(0));
+            return view.SetImage(wrapper, GlPixFormat(PixelFormatFromString(format.empty() ? "GRAY8" : format)) );
+        }else if(img.ndim() == 3 && img.shape()[2] == 3) {
+            Image<uint8_t> wrapper((uint8_t*)img.mutable_data(0,0), img.shape(1), img.shape(0), img.strides(0));
+            return view.SetImage(wrapper, GlPixFormat(PixelFormatFromString(format.empty() ? "RGB24" : format)) );
+        }else if(img.ndim() == 3 && img.shape()[2] == 4) {
+            Image<uint8_t> wrapper((uint8_t*)img.mutable_data(0,0), img.shape(1), img.shape(0), img.strides(0));
+            return view.SetImage(wrapper, GlPixFormat(PixelFormatFromString(format.empty() ? "RGB32" : format)) );
+        }else{
+            throw std::runtime_error("Unsupported format for now.");
+        }
+      }, "Set image to display by ImageView", pybind11::arg("img"), pybind11::arg("format") = "")
+      .def("SetImage", [](ImageView& view, pybind11::array_t<uint16_t>& img, const std::string & format) -> ImageView&{
+        if(img.ndim() == 2) {
+            Image<uint8_t> wrapper((uint8_t*)img.mutable_data(0,0), img.shape(1), img.shape(0), img.strides(0));
+            return view.SetImage(wrapper, GlPixFormat(PixelFormatFromString(format.empty() ? "GRAY16" : format)) );
+        }else if(img.ndim() == 3 && img.shape()[2] == 3) {
+            Image<uint8_t> wrapper((uint8_t*)img.mutable_data(0,0), img.shape(1), img.shape(0), img.strides(0));
+            return view.SetImage(wrapper, GlPixFormat(PixelFormatFromString(format.empty() ? "RGB48" : format)) );
+        }else if(img.ndim() == 3 && img.shape()[2] == 4) {
+            Image<uint8_t> wrapper((uint8_t*)img.mutable_data(0,0), img.shape(1), img.shape(0), img.strides(0));
+            return view.SetImage(wrapper, GlPixFormat(PixelFormatFromString(format.empty() ? "RGB64" : format)) );
+        }else{
+            throw std::runtime_error("Unsupported format for now.");
+        }
+      }, "Set image to display by ImageView", pybind11::arg("img"), pybind11::arg("format") = "");
+  }
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/image_view.hpp

@@ -0,0 +1,37 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Steven Lovegrove
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+
+namespace py_pangolin{
+
+  void bind_image_view(pybind11::module &m);
+
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/opengl_render_state.cpp

@@ -0,0 +1,116 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "opengl_render_state.hpp"
+#include <pangolin/gl/opengl_render_state.h>
+#include <pybind11/eigen.h>
+#include <pybind11/operators.h>
+#include <pybind11/numpy.h>
+
+namespace py_pangolin {
+
+  void bind_opengl_render_state(pybind11::module &m){
+    pybind11::enum_<pangolin::AxisDirection>(m, "AxisDirection")
+      .value("AxisNone", pangolin::AxisDirection::AxisNone)
+      .value("AxisNegX", pangolin::AxisDirection::AxisNegX)
+      .value("AxisNegY", pangolin::AxisDirection::AxisNegY)
+      .value("AxisNegZ", pangolin::AxisDirection::AxisNegZ)
+      .value("AxisX", pangolin::AxisDirection::AxisX)
+      .value("AxisY", pangolin::AxisDirection::AxisY)
+      .value("AxisZ", pangolin::AxisDirection::AxisZ)
+      .export_values();
+
+    pybind11::enum_<pangolin::OpenGlStack>(m, "OpenGlStack")
+      .value("GlModelViewStack", pangolin::OpenGlStack::GlModelViewStack)
+      .value("GlProjectionStack", pangolin::OpenGlStack::GlProjectionStack)
+      .value("GlTextureStack", pangolin::OpenGlStack::GlTextureStack)
+      .export_values();
+
+    pybind11::class_<pangolin::OpenGlMatrix>(m, "OpenGlMatrix")
+      .def("Translate", &pangolin::OpenGlMatrix::Translate)
+      .def("Scale", &pangolin::OpenGlMatrix::Scale)
+      .def("RotateX", &pangolin::OpenGlMatrix::RotateX)
+      .def("RotateY", &pangolin::OpenGlMatrix::RotateY)
+      .def("RotateZ", &pangolin::OpenGlMatrix::RotateZ)
+      .def(pybind11::init<>())
+      .def(pybind11::init<const Eigen::Matrix<float, 4, 4> >())
+      .def(pybind11::init<const Eigen::Matrix<double, 4, 4> >())
+      .def("Load", &pangolin::OpenGlMatrix::Load)
+      .def("Multiply", &pangolin::OpenGlMatrix::Multiply)
+      .def("SetIdentity", &pangolin::OpenGlMatrix::SetIdentity)
+      .def("Transpose", &pangolin::OpenGlMatrix::Transpose)
+      .def("Inverse", &pangolin::OpenGlMatrix::Inverse)
+      .def("Matrix", [](pangolin::OpenGlMatrix& mat){
+            using T = pangolin::GLprecision;
+            return pybind11::array_t<T>( {4, 4 }, {1*sizeof(T), 4*sizeof(T)}, mat.m );
+      })
+      .def(pybind11::self * pybind11::self);
+
+    pybind11::class_<pangolin::OpenGlMatrixSpec, pangolin::OpenGlMatrix>(m, "OpenGlMatrixSpec")
+      .def(pybind11::init<>());
+
+    m.def("ProjectionMatrixRUB_BottomLeft", &pangolin::ProjectionMatrixRUB_BottomLeft);
+    m.def("ProjectionMatrixRUB_TopLeft", &pangolin::ProjectionMatrixRUB_TopLeft);
+    m.def("ProjectionMatrixRDF_BottomLeft", &pangolin::ProjectionMatrixRDF_BottomLeft);
+    m.def("ProjectionMatrixRDF_TopLeft", &pangolin::ProjectionMatrixRDF_TopLeft);
+    m.def("ProjectionMatrix", &pangolin::ProjectionMatrix);
+    m.def("ProjectionMatrixOrthographic", &pangolin::ProjectionMatrixOrthographic);
+    m.def("ModelViewLookAtRUB", &pangolin::ModelViewLookAtRUB);
+    m.def("ModelViewLookAtRDF", &pangolin::ModelViewLookAtRDF);
+    m.def("ModelViewLookAt", (pangolin::OpenGlMatrix (*)(pangolin::GLprecision, pangolin::GLprecision, pangolin::GLprecision, pangolin::GLprecision, pangolin::GLprecision, pangolin::GLprecision, pangolin::AxisDirection))&pangolin::ModelViewLookAt);
+    m.def("ModelViewLookAt", (pangolin::OpenGlMatrix (*)(pangolin::GLprecision, pangolin::GLprecision, pangolin::GLprecision, pangolin::GLprecision, pangolin::GLprecision, pangolin::GLprecision, pangolin::GLprecision, pangolin::GLprecision, pangolin::GLprecision))&pangolin::ModelViewLookAt);
+    m.def("IdentityMatrix", (pangolin::OpenGlMatrix (*)())&pangolin::IdentityMatrix);
+    m.def("IdentityMatrix", (pangolin::OpenGlMatrixSpec (*)(pangolin::OpenGlStack))&pangolin::IdentityMatrix);
+    m.def("negIdentityMatrix", &pangolin::negIdentityMatrix);
+
+    pybind11::class_<pangolin::OpenGlRenderState>(m, "OpenGlRenderState")
+      .def(pybind11::init<const pangolin::OpenGlMatrix&>())
+      .def(pybind11::init<const pangolin::OpenGlMatrix&, const pangolin::OpenGlMatrix&>())
+      .def(pybind11::init<>())
+      .def("ApplyIdentity", &pangolin::OpenGlRenderState::ApplyIdentity)
+      .def("Apply", &pangolin::OpenGlRenderState::Apply)
+      .def("SetProjectionMatrix", &pangolin::OpenGlRenderState::SetProjectionMatrix)
+      .def("SetModelViewMatrix", &pangolin::OpenGlRenderState::SetModelViewMatrix)
+      .def("GetProjectionMatrix", (pangolin::OpenGlMatrix& (pangolin::OpenGlRenderState::*)())&pangolin::OpenGlRenderState::GetProjectionMatrix)
+      .def("GetProjectionMatrix", (pangolin::OpenGlMatrix (pangolin::OpenGlRenderState::*)() const)&pangolin::OpenGlRenderState::GetProjectionMatrix)
+      .def("GetModelViewMatrix", (pangolin::OpenGlMatrix& (pangolin::OpenGlRenderState::*)())&pangolin::OpenGlRenderState::GetModelViewMatrix)
+      .def("GetModelViewMatrix", (pangolin::OpenGlMatrix (pangolin::OpenGlRenderState::*)() const)&pangolin::OpenGlRenderState::GetModelViewMatrix)
+      .def("GetProjectionModelViewMatrix", &pangolin::OpenGlRenderState::GetProjectionModelViewMatrix)
+      .def("GetProjectiveTextureMatrix", &pangolin::OpenGlRenderState::GetProjectiveTextureMatrix)
+      .def("EnableProjectiveTexturing", &pangolin::OpenGlRenderState::EnableProjectiveTexturing)
+      .def("DisableProjectiveTexturing", &pangolin::OpenGlRenderState::DisableProjectiveTexturing)
+      .def("Follow", &pangolin::OpenGlRenderState::Follow, pybind11::arg("T_wc"), pybind11::arg("follow")=true)
+      .def("Unfollow", &pangolin::OpenGlRenderState::Unfollow)
+      .def("GetProjectionMatrix", (pangolin::OpenGlMatrix& (pangolin::OpenGlRenderState::*)(unsigned int))&pangolin::OpenGlRenderState::GetProjectionMatrix)
+      .def("GetProjectionMatrix", (pangolin::OpenGlMatrix (pangolin::OpenGlRenderState::*)(unsigned int) const)&pangolin::OpenGlRenderState::GetProjectionMatrix)
+      .def("GetViewOffset", (pangolin::OpenGlMatrix& (pangolin::OpenGlRenderState::*)(unsigned int))&pangolin::OpenGlRenderState::GetViewOffset)
+      .def("GetViewOffset", (pangolin::OpenGlMatrix (pangolin::OpenGlRenderState::*)(unsigned int) const)&pangolin::OpenGlRenderState::GetViewOffset)
+      .def("GetModelViewMatrix", (pangolin::OpenGlMatrix (pangolin::OpenGlRenderState::*)(int) const)&pangolin::OpenGlRenderState::GetModelViewMatrix)
+      .def("ApplyNView", &pangolin::OpenGlRenderState::ApplyNView);
+  }
+
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/opengl_render_state.hpp

@@ -0,0 +1,37 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py_pangolin {
+  
+  void bind_opengl_render_state(pybind11::module &m);
+
+}  // py_pangolin
+

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/params.cpp

@@ -0,0 +1,43 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "params.hpp"
+#include <pangolin/utils/params.h>
+
+namespace py_pangolin {
+
+    void bind_params(pybind11::module &m) {
+      pybind11::class_<pangolin::Params>(m, "Params")
+        .def(pybind11::init<>())
+        .def("Contains", &pangolin::Params::Contains)
+        .def("Set", &pangolin::Params::Set<int>)
+        .def("Get", &pangolin::Params::Get<int>)
+        .def("Set", &pangolin::Params::Set<std::string>)
+        .def("Get", &pangolin::Params::Get<std::string>);
+    }
+
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/params.hpp

@@ -0,0 +1,37 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py_pangolin {
+  
+  void bind_params(pybind11::module &m);
+
+}  // py_pangolin
+

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/pixel_format.cpp

@@ -0,0 +1,43 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "pixel_format.hpp"
+#include <pangolin/image/pixel_format.h>
+
+namespace py_pangolin {
+
+  void bind_pixel_format(pybind11::module& m){
+    pybind11::class_<pangolin::PixelFormat>(m, "PixelFormat")
+      .def_readwrite("format", &pangolin::PixelFormat::format)
+      .def_readwrite("channels", &pangolin::PixelFormat::channels)
+      //      .def_readwrite("channel_bits", &pangolin::PixelFormat::channel_bits) //channel_bits[4] 
+      .def_readwrite("bpp", &pangolin::PixelFormat::bpp)
+      .def_readwrite("planar", &pangolin::PixelFormat::planar);
+
+    m.def("PixelFormatFromString", &pangolin::PixelFormatFromString);
+  }
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/pixel_format.hpp

@@ -0,0 +1,37 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py_pangolin {
+
+  void bind_pixel_format(pybind11::module& m);
+
+}  // py_pangolin
+

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/plotter.cpp

@@ -0,0 +1,143 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov, Steven Lovegrove
+ *
+ * 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.
+ */
+
+#include "view.hpp"
+#include "plotter.hpp"
+#include "handler.hpp"
+#include <pangolin/plot/plotter.h>
+
+
+namespace py_pangolin {
+
+  template<typename P>
+  void bind_range(pybind11::module& m, const char* python_name_postfix)
+  {
+      pybind11::class_<pangolin::Range<P>>(m, (std::string("Range") + python_name_postfix).c_str() )
+          .def_readwrite("min", &pangolin::Range<P>::min)
+          .def_readwrite("max", &pangolin::Range<P>::max);
+
+      pybind11::class_<pangolin::XYRange<P>>(m, (std::string("XYRange") + python_name_postfix).c_str() )
+          .def_readwrite("x", &pangolin::XYRange<P>::x)
+          .def_readwrite("y", &pangolin::XYRange<P>::y);
+  }
+
+  void bind_plotter(pybind11::module& m){
+  //   pybind11::class_<pangolin::Handler, PyHandler> handler1(m, "Handler1");
+  //   handler1
+  //     .def(pybind11::init<>())
+  //     .def("Keyboard", &pangolin::Handler::Keyboard)
+  //     .def("Mouse", &pangolin::Handler::Mouse)
+  //     .def("MouseMotion", &pangolin::Handler::MouseMotion)
+  //     .def("PassiveMouseMotion", &pangolin::Handler::PassiveMouseMotion)
+  //     .def("Special", &pangolin::Handler::Special);
+
+    bind_range<float>(m, "f");
+
+    pybind11::enum_<pangolin::DrawingMode>(m, "DrawingMode")
+      .value("DrawingModePoints", pangolin::DrawingMode::DrawingModePoints)
+      .value("DrawingModeDashed", pangolin::DrawingMode::DrawingModeDashed)
+      .value("DrawingModeLine", pangolin::DrawingMode::DrawingModeLine)
+      .value("DrawingModeNone", pangolin::DrawingMode::DrawingModeNone)
+      .export_values();
+
+    pybind11::class_<pangolin::Marker> marker(m, "Marker");
+
+    pybind11::enum_<pangolin::Marker::Direction>(marker, "Direction")
+      .value("Horizontal", pangolin::Marker::Direction::Horizontal)
+      .value("Vertical", pangolin::Marker::Direction::Vertical)
+      .export_values();
+
+    pybind11::enum_<pangolin::Marker::Equality>(marker, "Equality")
+      .value("LessThan", pangolin::Marker::Equality::LessThan)
+      .value("Equal", pangolin::Marker::Equality::Equal)
+      .value("GreaterThan", pangolin::Marker::Equality::GreaterThan)
+      .export_values();
+
+    marker.def(pybind11::init<pangolin::Marker::Direction, float, pangolin::Marker::Equality, pangolin::Colour>(), pybind11::arg("d"), pybind11::arg("value"), pybind11::arg("leg") = pangolin::Marker::Equality::Equal, pybind11::arg("c")=pangolin::Colour())
+      .def(pybind11::init<const pangolin::XYRangef&, const pangolin::Colour&>(), pybind11::arg("range"), pybind11::arg("c")=pangolin::Colour())
+      .def_readwrite("range", &pangolin::Marker::range)
+      .def_readwrite("colour", &pangolin::Marker::colour);    
+
+    pybind11::class_<pangolin::Plotter,pangolin::View>(m, "Plotter")
+      .def(pybind11::init<pangolin::DataLog*, float, float, float, float, float, float, pangolin::Plotter*, pangolin::Plotter*>(),
+           pybind11::arg("default_log"),
+           pybind11::arg("left")=0,
+           pybind11::arg("right")=600,
+           pybind11::arg("bottom")=-1,
+           pybind11::arg("top")=1,
+           pybind11::arg("tickx")=30,
+           pybind11::arg("ticky")=0.5,
+           pybind11::arg("linked_plotter_x")=NULL,
+           pybind11::arg("linked_plotter_y")=NULL)
+      .def(pybind11::init([](pangolin::DataLog* log, float left, float right, float bottom, float top, float tickx, float ticky){return new pangolin::Plotter(log, left, right, bottom, top,tickx, ticky);}),
+           pybind11::arg("default_log"),
+           pybind11::arg("left")=0,
+           pybind11::arg("right")=600,
+           pybind11::arg("bottom")=-1,
+           pybind11::arg("top")=1,
+           pybind11::arg("tickx")=30,
+           pybind11::arg("ticky")=0.5)
+
+      .def("Render", &pangolin::Plotter::Render)
+      .def("GetSelection", &pangolin::Plotter::GetSelection)
+      .def("GetDefaultView", &pangolin::Plotter::GetDefaultView)
+      .def("SetDefaultView", &pangolin::Plotter::SetDefaultView)
+      .def("GetView", &pangolin::Plotter::GetView)
+      .def("SetView", &pangolin::Plotter::SetView)
+      .def("SetViewSmooth", &pangolin::Plotter::SetViewSmooth)
+      .def("ScrollView", &pangolin::Plotter::ScrollView)
+      .def("ScrollViewSmooth", &pangolin::Plotter::ScrollViewSmooth)
+      .def("ScaleView", &pangolin::Plotter::ScaleView)
+      .def("ScaleViewSmooth", &pangolin::Plotter::ScaleViewSmooth)
+      .def("SetTicks", &pangolin::Plotter::SetTicks)
+      .def("Track", &pangolin::Plotter::Track, pybind11::arg("x")="$i", pybind11::arg("y")="")
+      .def("ToggleTracking", &pangolin::Plotter::ToggleTracking)
+      .def("Trigger", &pangolin::Plotter::Trigger, pybind11::arg("x")="$0", pybind11::arg("edge")=-1, pybind11::arg("value")=0.0f)
+      .def("ToggleTrigger", &pangolin::Plotter::ToggleTrigger)
+      .def("SetBackgroundColour", &pangolin::Plotter::SetBackgroundColour)
+      .def("SetAxisColour", &pangolin::Plotter::SetAxisColour)
+      .def("SetTickColour", &pangolin::Plotter::SetTickColour)
+      .def("Keyboard", &pangolin::Plotter::Keyboard)
+      .def("Mouse", &pangolin::Plotter::Mouse)
+      .def("MouseMotion", &pangolin::Plotter::MouseMotion)
+      .def("PassiveMouseMotion", &pangolin::Plotter::PassiveMouseMotion)
+      .def("Special", &pangolin::Plotter::Special)
+      .def("ClearSeries", &pangolin::Plotter::ClearSeries)
+      .def("AddSeries", &pangolin::Plotter::AddSeries)
+      .def("PlotTitleFromExpr", &pangolin::Plotter::PlotTitleFromExpr)
+      .def("ClearMarkers", &pangolin::Plotter::ClearMarkers)
+      .def("AddMarker", (pangolin::Marker& (pangolin::Plotter::*)(pangolin::Marker::Direction, float, pangolin::Marker::Equality, pangolin::Colour))&pangolin::Plotter::AddMarker, pybind11::arg("d"), pybind11::arg("value"), pybind11::arg("leg") = pangolin::Marker::Equality::Equal, pybind11::arg("c")=pangolin::Colour())
+      .def("AddMarker", (pangolin::Marker& (pangolin::Plotter::*)(const pangolin::Marker&))&pangolin::Plotter::AddMarker)
+    //      .def("ClearImplicitPlots", &pangolin::Plotter::ClearImplicitPlots);
+      //   .def("AddImplicitPlot", &pangolin::Plotter::AddImplicitPlot);
+      .def("SetBounds", (pangolin::View& (pangolin::Plotter::*)(pangolin::Attach, pangolin::Attach, pangolin::Attach, pangolin::Attach))&pangolin::Plotter::SetBounds)
+      .def("SetBounds", (pangolin::View& (pangolin::Plotter::*)(pangolin::Attach, pangolin::Attach, pangolin::Attach, pangolin::Attach, bool))&pangolin::Plotter::SetBounds)
+      .def("SetBounds", (pangolin::View& (pangolin::Plotter::*)(pangolin::Attach, pangolin::Attach, pangolin::Attach, pangolin::Attach, double))&pangolin::Plotter::SetBounds);
+
+  }
+
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/plotter.hpp

@@ -0,0 +1,37 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py_pangolin {
+
+  void bind_plotter(pybind11::module& m);
+
+}  // py_pangolin
+

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/pypangoio.cpp

@@ -0,0 +1,35 @@
+#include "pypangoio.h"
+
+namespace py_pangolin
+{
+
+PyPangoIO::PyPangoIO(std::queue<InterpreterLine>& line_queue, InterpreterLineType line_type)
+    : line_queue(line_queue), line_type(line_type)
+{
+}
+
+void PyPangoIO::write(const std::string& text)
+{
+    buffer += text;
+    size_t nl = buffer.find_first_of('\n');
+    while(nl != std::string::npos) {
+        const std::string line = buffer.substr(0,nl);
+        line_queue.push(InterpreterLine(line,line_type));
+        buffer = buffer.substr(nl+1);
+        nl = buffer.find_first_of('\n');
+    }
+}
+
+void PyPangoIO::flush()
+{
+    // Do nothing
+}
+
+void bind_pango_write_object(pybind11::module& m)
+{
+    pybind11::class_<PyPangoIO>(m, "PyPangoIO")
+      .def("write", &PyPangoIO::write)
+      .def("flush", &PyPangoIO::flush);
+}
+
+}

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/pypangoio.h

@@ -0,0 +1,59 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/embed.h>
+#include <iomanip>
+#include <queue>
+
+#include <pangolin/var/var.h>
+#include <pangolin/console/InterpreterInterface.h>
+
+namespace py_pangolin
+{
+
+using namespace pangolin;
+
+void bind_pango_write_object(pybind11::module& m);
+
+struct PyPangoIO {
+    PyPangoIO(std::queue<InterpreterLine>& line_queue, InterpreterLineType line_type);
+
+    void write(const std::string& text);
+
+    void flush();
+
+    std::string buffer;
+    std::queue<InterpreterLine>& line_queue;
+    InterpreterLineType line_type;
+};
+
+
+
+
+}

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/pypangolin.h

@@ -0,0 +1,87 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Steven Lovegrove
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <pybind11/embed.h>
+
+#include "attach.hpp"
+#include "colour.hpp"
+#include "datalog.hpp"
+#include "display.hpp"
+#include "gl.hpp"
+#include "glsl.hpp"
+#include "gl_draw.hpp"
+#include "glvbo.hpp"
+#include "handler.hpp"
+#include "image.hpp"
+#include "opengl_render_state.hpp"
+#include "params.hpp"
+#include "pixel_format.hpp"
+#include "plotter.hpp"
+#include "var.hpp"
+#include "video.hpp"
+#include "view.hpp"
+#include "viewport.hpp"
+#include "widget.hpp"
+#include "window.hpp"
+#include "image_view.hpp"
+#include "pypangoio.h"
+
+namespace pypangolin {
+
+inline void PopulateModule(pybind11::module& m)
+{
+    m.doc() = "pypangolin python wrapper for Pangolin rapid prototyping graphics and video library.";
+
+    py_pangolin::bind_var(m);
+    py_pangolin::bind_params(m);
+    py_pangolin::bind_viewport(m);
+    py_pangolin::bind_view(m);
+    py_pangolin::bind_window(m);
+    py_pangolin::bind_display(m);
+    py_pangolin::bind_opengl_render_state(m);
+    py_pangolin::bind_attach(m);
+    py_pangolin::bind_colour(m);
+    py_pangolin::bind_datalog(m);
+    py_pangolin::bind_plotter(m);
+    py_pangolin::bind_handler(m);
+    py_pangolin::bind_gl(m);
+    py_pangolin::bind_glsl(m);
+    py_pangolin::bind_gl_draw(m);
+    py_pangolin::bind_glvbo(m);
+    py_pangolin::bind_widget(m);
+    py_pangolin::bind_pixel_format(m);
+    py_pangolin::bind_image<unsigned char>(m, "Image");
+    py_pangolin::bind_video(m);
+    py_pangolin::bind_image_view(m);
+    py_pangolin::bind_pango_write_object(m);
+}
+
+}

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/var.cpp

@@ -0,0 +1,184 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "var.hpp"
+#include <functional>
+#include <pybind11/functional.h>
+#include <pybind11/stl.h>
+
+namespace py_pangolin {
+
+var_t::var_t(const std::string& top_level_ns){
+   if( top_level_ns=="" || top_level_ns.find_first_of('.') != std::string::npos ) {
+       throw std::invalid_argument("Expected top level namespace name, got '" + top_level_ns + "'");
+   }
+
+  namespace_prefix=top_level_ns+".";
+
+  // Callback function to populate sub-namespaces
+  var_callback_connection = pangolin::VarState::I().RegisterForVarEvents(
+      std::bind(&var_t::new_var_callback,this,std::placeholders::_1),
+      true
+  );
+}
+
+void  var_t::new_var_callback(const pangolin::VarState::Event& e)
+{
+    if(e.action == pangolin::VarState::Event::Action::Added) {
+        const int namespace_size = namespace_prefix.size();
+        const std::string name = e.var->Meta().full_name;
+        if (!name.compare(0, namespace_size, namespace_prefix)) {
+            const size_t dot = name.find_first_of('.', namespace_size);
+            members.push_back(
+                        (dot != std::string::npos) ? name.substr(namespace_size, dot - namespace_size) :
+                                                     name.substr(namespace_size)
+                                                     );
+        }
+    }
+}
+
+  
+var_t::~var_t() noexcept{}
+
+var_t::var_t(const var_t &/*other*/){}
+
+var_t::var_t(var_t &&/*other*/) noexcept{}
+  
+var_t& var_t::operator=(const var_t &/*other*/){
+  return *this;
+}
+
+var_t& var_t::operator=(var_t &&/*other*/) noexcept{
+  return *this;
+}
+
+pybind11::object var_t::get_attr(const std::string &name){
+    const std::shared_ptr<pangolin::VarValueGeneric> var = pangolin::VarState::I().GetByName(namespace_prefix+name);
+    if(var) {
+        if (!strcmp(var->TypeId(), typeid(bool).name())) {
+            const bool val = pangolin::Var<bool>(var).Get();
+            return pybind11::bool_(val);
+        } else if (!strcmp(var->TypeId(), typeid(short).name()) ||
+                   !strcmp(var->TypeId(), typeid(int).name()) ||
+                   !strcmp(var->TypeId(), typeid(long).name())) {
+            const long val = pangolin::Var<long>(var).Get();
+            return pybind11::int_(val);
+        } else if (!strcmp(var->TypeId(), typeid(double).name()) ||
+                   !strcmp(var->TypeId(), typeid(float).name())) {
+            const double val = pangolin::Var<double>(var).Get();
+            return pybind11::float_(val);
+        } else {
+            const std::string val = var->str->Get();
+            return pybind11::str(val);
+        }
+    }
+    return pybind11::none();
+}
+
+template <typename T>
+void var_t::set_attr_(const std::string& name, T val, const PyVarMeta & meta){
+    using namespace pangolin;
+
+    const std::string full_name = namespace_prefix+name;
+    auto p_var = VarState::I().GetByName(full_name);
+
+  if (p_var) {
+      Var<T> setter(p_var);
+      setter = val;
+  } else {
+    int flags = pangolin::META_FLAG_NONE;
+    if (meta.toggle) flags |= pangolin::META_FLAG_TOGGLE;
+    if (meta.read_only)  flags |= pangolin::META_FLAG_READONLY;
+    pangolin::Var<T> pango_var(namespace_prefix+name, val, flags);
+    pango_var.Meta().gui_changed = true;
+    pango_var.Meta().range[0] = meta.low;
+    pango_var.Meta().range[1] = meta.high;
+    pango_var.Meta().logscale = meta.logscale;
+  }
+}
+
+
+pybind11::object var_t::gui_changed(const std::string &name){
+    const std::shared_ptr<pangolin::VarValueGeneric> var = pangolin::VarState::I().GetByName(namespace_prefix+name);
+    if(var) {
+        bool result = var->Meta().gui_changed;
+        var->Meta().gui_changed = false;
+        return pybind11::bool_(result);
+    }
+    return pybind11::none();
+}
+
+    
+std::vector<std::string>& var_t::get_members(){
+    return members;
+}
+
+template <typename ... Ts>
+struct VarBinder {
+
+  static inline void Bind(pybind11::class_<var_t> & varClass) {}
+
+};
+
+template <typename Head, typename ... Tail> 
+struct VarBinder<Head, Tail...> {
+
+  static inline void Bind(pybind11::class_<var_t> & varClass) {
+      
+    varClass.def("__setattr__", [](var_t& v, const std::string& name, Head val) {
+      v.set_attr_<Head>(name, val);
+    }).def("__setattr__", [](var_t& v, const std::string& name, const std::tuple<Head, PyVarMeta> & valMeta) {
+      v.set_attr_<Head>(name, std::get<0>(valMeta), std::get<1>(valMeta));
+    });
+
+    VarBinder<Tail...>::Bind(varClass);
+
+  }
+
+};
+
+void bind_var(pybind11::module& m){
+
+  pybind11::class_<PyVarMeta>(m, "VarMeta")
+    .def(pybind11::init<double, double, bool, bool, bool>(), 
+      pybind11::arg("low") = 0.0, 
+      pybind11::arg("high") = 1.0, 
+      pybind11::arg("logscale") = false, 
+      pybind11::arg("toggle") = false,
+      pybind11::arg("read_only") = false);
+
+  pybind11::class_<py_pangolin::var_t> varClass(m, "Var");
+    varClass.def(pybind11::init<const std::string &>())
+      .def("__members__", &py_pangolin::var_t::get_members)
+      .def("__getattr__", &py_pangolin::var_t::get_attr)
+      .def("GuiChanged", &py_pangolin::var_t::gui_changed);
+
+  VarBinder<bool, int, double, std::string, std::function<void(void)> >::Bind(varClass);
+
+}
+
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/var.hpp

@@ -0,0 +1,74 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+#include <pangolin/var/var.h>
+#include <Python.h>
+
+namespace py_pangolin {
+
+  struct PyVarMeta {
+    double low;
+    double high;
+    bool logscale;
+    bool toggle;
+    bool read_only;
+  };
+
+  void bind_var(pybind11::module& m);
+  
+  // This class exposes Pangolin top-level Var namespaces to
+  // Python.
+  class var_t
+  {
+  public:
+    var_t(const std::string& top_level_ns);
+    virtual ~var_t() noexcept;
+    pybind11::object get_attr(const std::string &name);
+
+    template <typename T>
+    void set_attr_(const std::string& name, T val, const PyVarMeta & meta = {});
+
+    pybind11::object gui_changed(const std::string &name);
+
+    std::vector<std::string>& get_members();     
+  protected:
+    var_t(const var_t &other);
+    var_t(var_t &&other) noexcept;
+    var_t& operator=(const var_t &other);
+    var_t& operator=(var_t &&other) noexcept;
+  private:
+    void new_var_callback(const pangolin::VarState::Event &);
+
+    std::vector<std::string> members;
+    std::string namespace_prefix;
+    sigslot::scoped_connection var_callback_connection;
+  };
+  
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/video.cpp

@@ -0,0 +1,645 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "video.hpp"
+#include <pangolin/video/video_interface.h>
+#include <pangolin/video/video_input.h>
+
+#include <pybind11/numpy.h>
+#include <pybind11/stl.h>
+
+namespace py_pangolin {
+
+    class PyVideoInterface: public pangolin::VideoInterface{
+    public:
+      using pangolin::VideoInterface::VideoInterface;
+
+      size_t SizeBytes() const override {
+        PYBIND11_OVERLOAD_PURE(
+                               size_t,
+                               pangolin::VideoInterface,
+                               SizeBytes);
+      }
+
+      const std::vector<pangolin::StreamInfo>& Streams() const override {
+        PYBIND11_OVERLOAD_PURE(
+                               const std::vector<pangolin::StreamInfo>&,
+                               pangolin::VideoInterface,
+                               Streams);
+      }
+
+      void Start() override {
+        PYBIND11_OVERLOAD_PURE(
+                               void,
+                               pangolin::VideoInterface,
+                               Start);
+      }
+
+      void Stop() override {
+        PYBIND11_OVERLOAD_PURE(
+                               void,
+                               pangolin::VideoInterface,
+                               Stop);
+      }
+
+      bool GrabNext(unsigned char* image, bool wait = true) override {
+        PYBIND11_OVERLOAD_PURE(
+                               bool,
+                               pangolin::VideoInterface,
+                               GrabNext,
+                               image,
+                               wait);
+      }
+
+      bool GrabNewest(unsigned char* image, bool wait = true) override {
+        PYBIND11_OVERLOAD_PURE(
+                               bool,
+                               pangolin::VideoInterface,
+                               GrabNewest,
+                               image,
+                               wait);
+      }
+    };
+
+    class PyGenicamVideoInterface: public pangolin::GenicamVideoInterface{
+    public:
+      using pangolin::GenicamVideoInterface::GenicamVideoInterface;
+
+      bool GetParameter(const std::string& name, std::string& result) override {
+        PYBIND11_OVERLOAD_PURE(
+                               bool,
+                               pangolin::GenicamVideoInterface,
+                               GetParameter,
+                               name,
+                               result);
+      }
+
+      bool SetParameter(const std::string& name, const std::string& value) override {
+        PYBIND11_OVERLOAD_PURE(
+                               bool,
+                               pangolin::GenicamVideoInterface,
+                               SetParameter,
+                               name,
+                               value);
+      }
+      size_t CameraCount() const override
+      {
+          PYBIND11_OVERLOAD_PURE(
+                                 size_t,
+                                 pangolin::GenicamVideoInterface,
+                                 CameraCount);
+      }
+
+
+
+    };
+
+    class PyBufferAwareVideoInterface: public pangolin::BufferAwareVideoInterface{
+    public:
+      using pangolin::BufferAwareVideoInterface::BufferAwareVideoInterface;
+
+      uint32_t AvailableFrames() const override {
+        PYBIND11_OVERLOAD_PURE(
+                               uint32_t,
+                               pangolin::BufferAwareVideoInterface,
+                               AvailableFrames);
+      }
+
+      bool DropNFrames(uint32_t n) override {
+        PYBIND11_OVERLOAD_PURE(
+                               bool,
+                               pangolin::BufferAwareVideoInterface,
+                               DropNFrames,
+                               n);
+      }
+    };
+
+    class PyVideoPropertiesInterface: public pangolin::VideoPropertiesInterface{
+    public:
+      using pangolin::VideoPropertiesInterface::VideoPropertiesInterface;
+
+      const picojson::value& DeviceProperties() const override {
+        PYBIND11_OVERLOAD_PURE(
+                               const picojson::value&,
+                               pangolin::VideoPropertiesInterface,
+                               DeviceProperties);
+      }
+
+      const picojson::value& FrameProperties() const override {
+        PYBIND11_OVERLOAD_PURE(
+                               const picojson::value&,
+                               pangolin::VideoPropertiesInterface,
+                               FrameProperties);
+      }
+    };  
+
+    class PyVideoFilterInterface: public pangolin::VideoFilterInterface{
+    public:
+      using pangolin::VideoFilterInterface::VideoFilterInterface;
+
+      // template <typename T>
+      // std::vector<T*> FindMatchingStreams() override {
+      //   PYBIND11_OVERLOAD(
+      //                     std::vector<T*>,
+      //                     pangolin::VideoFilterInterface,
+      //                     FindMatchingStreams);
+      // }
+
+      std::vector<pangolin::VideoInterface*>& InputStreams() override {
+        PYBIND11_OVERLOAD_PURE(
+                               std::vector<pangolin::VideoInterface*>&,
+                               pangolin::VideoFilterInterface,
+                               InputStreams);
+      }
+    };  
+    
+    class PyVideoUvcInterface: public pangolin::VideoUvcInterface{
+    public:
+      using pangolin::VideoUvcInterface::VideoUvcInterface;
+
+      int IoCtrl(uint8_t unit, uint8_t ctrl, unsigned char* data, int len, pangolin::UvcRequestCode req_code) override {
+        PYBIND11_OVERLOAD_PURE(
+                               int,
+                               pangolin::VideoUvcInterface,
+                               IoCtrl,
+                               unit,
+                               ctrl,
+                               data,
+                               len,
+                               req_code);
+      }
+
+      bool GetExposure(int& exp_us) override {
+        PYBIND11_OVERLOAD_PURE(
+                               bool,
+                               pangolin::VideoUvcInterface,
+                               GetExposure,
+                               exp_us);
+      }
+
+      bool SetExposure(int exp_us) override {
+        PYBIND11_OVERLOAD_PURE(
+                               bool,
+                               pangolin::VideoUvcInterface,
+                               SetExposure,
+                               exp_us);
+      }
+
+      bool GetGain(float& gain) override {
+        PYBIND11_OVERLOAD_PURE(
+                               bool,
+                               pangolin::VideoUvcInterface,
+                               GetGain,
+                               gain);
+      }
+
+      bool SetGain(float gain) override {
+        PYBIND11_OVERLOAD_PURE(
+                               bool,
+                               pangolin::VideoUvcInterface,
+                               SetGain,
+                               gain);
+      }
+    };
+  
+    class PyVideoPlaybackInterface: public pangolin::VideoPlaybackInterface{
+    public:
+      using pangolin::VideoPlaybackInterface::VideoPlaybackInterface;
+    
+      size_t GetCurrentFrameId() const override {
+        PYBIND11_OVERLOAD_PURE(
+                               size_t,
+                               pangolin::VideoPlaybackInterface,
+                               GetCurrentFrameId);
+      }
+
+      size_t GetTotalFrames() const override {
+        PYBIND11_OVERLOAD_PURE(
+                               size_t,
+                               pangolin::VideoPlaybackInterface,
+                               GetTotalFrames);
+      }
+
+      size_t Seek(size_t frameid) override {
+        PYBIND11_OVERLOAD_PURE(
+                               size_t,
+                               pangolin::VideoPlaybackInterface,
+                               Seek,
+                               frameid);
+      }
+    };
+
+  class PyVideoOutputInterface: public pangolin::VideoOutputInterface{
+  public:
+    using pangolin::VideoOutputInterface::VideoOutputInterface;
+    
+    const std::vector<pangolin::StreamInfo>& Streams() const override {
+      PYBIND11_OVERLOAD_PURE(
+                             const std::vector<pangolin::StreamInfo>&,
+                             pangolin::VideoOutputInterface,
+                             Streams);
+    }
+
+    void SetStreams(const std::vector<pangolin::StreamInfo>& streams, const std::string& uri, const picojson::value& properties) override {
+      PYBIND11_OVERLOAD_PURE(
+                             void,
+                             pangolin::VideoOutputInterface,
+                             SetStreams,
+                             streams,
+                             uri,
+                             properties);
+    }
+
+    int WriteStreams(const unsigned char* data, const picojson::value& frame_properties) override {
+      PYBIND11_OVERLOAD_PURE(
+                             int,
+                             pangolin::VideoOutputInterface,
+                             WriteStreams,
+                             data,
+                             frame_properties);
+    }
+
+    bool IsPipe() const override {
+      PYBIND11_OVERLOAD_PURE(
+                             bool,
+                             pangolin::VideoOutputInterface,
+                             IsPipe);
+    }
+
+  };
+
+  pybind11::list VideoInputGrab(pangolin::VideoInput& vi, bool wait, bool newest){
+      unsigned char *buffer = new unsigned char[vi.SizeBytes()];
+
+      std::vector<pangolin::Image<unsigned char>> imgs;
+      pybind11::list imgsList;
+
+      if(vi.Grab(buffer,imgs,wait,newest)) {
+          for(size_t s=0; s < vi.Streams().size(); ++s) {
+              // Let's just return the first stream for the moment
+              const pangolin::StreamInfo& si = vi.Streams()[s];
+              const pangolin::Image<uint8_t> img = si.StreamImage(buffer);
+
+              const int c = si.PixFormat().channels;
+              const std::string fmt = si.PixFormat().format;
+              const int Bpp = si.PixFormat().bpp / (8);
+              const int Bpc = Bpp / c;
+              const int bpc = si.PixFormat().bpp / c;
+              PANGO_ASSERT(bpc == 8 || bpc == 16 || bpc == 32, "only support 8, 16, 32 bits channel");
+
+              pangolin::Image<uint8_t> dstImage(
+                  new unsigned char[img.h * img.w * Bpp],
+                  img.w, img.h, img.w*Bpp
+              );
+
+              pangolin::PitchedCopy((char*)dstImage.ptr, dstImage.pitch, (char*)img.ptr, img.pitch, img.w * Bpp, img.h);
+
+              // Create a Python object that will free the allocated memory
+              pybind11::capsule free_when_done(dstImage.ptr,[](void* f) {
+                unsigned char* buffer = (unsigned char*)f;
+                delete[] buffer;
+              });
+
+              if (bpc == 8) {
+                  imgsList.append(
+                      pybind11::array_t<uint8_t>(
+                      {(int)dstImage.h, (int)dstImage.w, c },
+                      {(int)dstImage.pitch, Bpp, Bpc},
+                      (uint8_t*)dstImage.ptr,
+                      free_when_done)
+                      );
+              }
+              else if (bpc == 16){
+                  imgsList.append(
+                      pybind11::array_t<uint16_t>(
+                      {(int)dstImage.h, (int)dstImage.w, c },
+                      {(int)dstImage.pitch, Bpp, Bpc},
+                      (uint16_t*)dstImage.ptr,
+                      free_when_done)
+                      );
+              }
+              else if (bpc == 32){
+                  if (fmt == "GRAY32")
+                  {
+                      imgsList.append(
+                          pybind11::array_t<uint32_t>(
+                          {(int)dstImage.h, (int)dstImage.w, c },
+                          {(int)dstImage.pitch, Bpp, Bpc},
+                          (uint32_t*)dstImage.ptr,
+                          free_when_done)
+                          );
+                  }
+                  else if (fmt == "GRAY32F" ||
+                           fmt == "RGB96F" ||
+                           fmt == "RGBA128F")
+                  {
+                      imgsList.append(
+                          pybind11::array_t<float>(
+                          {(int)dstImage.h, (int)dstImage.w, c },
+                          {(int)dstImage.pitch, Bpp, Bpc},
+                          (float*)dstImage.ptr,
+                          free_when_done)
+                          );
+                  }
+                  else{
+                      PANGO_ASSERT(false, "unsupported 32 bpc format");
+                  }
+              }
+              else{
+                  PANGO_ASSERT(false, "incompatible bpc");
+              }
+          }
+      }
+      delete[] buffer;
+      return imgsList;
+  }
+
+  picojson::value PicojsonFromPyObject(pybind11::object& obj)
+  {
+      // convert frame_properties to std::string via json.dumps(...)
+      pybind11::module pymodjson = pybind11::module::import("json");
+      auto pydumps = pymodjson.attr("dumps");
+      const std::string json = pydumps(obj).cast<pybind11::str>();
+      std::stringstream ss(json);
+      picojson::value pjson;
+      picojson::parse(pjson, ss);
+      return pjson;
+  }
+
+  void bind_video(pybind11::module& m){
+        pybind11::class_<pangolin::VideoInterface, PyVideoInterface > video_interface(m, "VideoInterface");
+    video_interface
+      .def(pybind11::init<>())
+      .def("SizeBytes", &pangolin::VideoInterface::SizeBytes)
+      .def("Streams", &pangolin::VideoInterface::Streams)
+      .def("Start", &pangolin::VideoInterface::Start)
+      .def("Stop", &pangolin::VideoInterface::Stop)
+      .def("GrabNext", &pangolin::VideoInterface::GrabNext)
+      .def("GrabNewest", &pangolin::VideoInterface::GrabNewest);
+
+    pybind11::class_<pangolin::GenicamVideoInterface, PyGenicamVideoInterface > genicam_video_interface(m, "GenicamVideoInterface");
+    genicam_video_interface
+      .def(pybind11::init<>())
+      .def("GetParameter", &pangolin::GenicamVideoInterface::GetParameter)
+      .def("SetParameter", &pangolin::GenicamVideoInterface::SetParameter);
+
+    pybind11::class_<pangolin::BufferAwareVideoInterface, PyBufferAwareVideoInterface > buffer_aware_video_interface(m, "BufferAwareVideoInterface");
+    buffer_aware_video_interface
+      .def(pybind11::init<>())
+      .def("AvailableFrames", &pangolin::BufferAwareVideoInterface::AvailableFrames)
+      .def("DropNFrames", &pangolin::BufferAwareVideoInterface::DropNFrames);
+
+    pybind11::class_<pangolin::VideoPropertiesInterface, PyVideoPropertiesInterface > video_properties_interface(m, "VideoPropertiesInterface");
+    video_properties_interface
+      .def(pybind11::init<>())
+      .def("DeviceProperties", &pangolin::VideoPropertiesInterface::DeviceProperties)
+      .def("FrameProperties", &pangolin::VideoPropertiesInterface::FrameProperties);
+
+    pybind11::class_<pangolin::VideoFilterInterface, PyVideoFilterInterface > video_filter_interface(m, "VideoFilterInterface");
+    video_filter_interface
+      .def(pybind11::init<>())
+      //      .def("FindMatchingStreams", &pangolin::VideoFilterInterface::FindMatchingStreams)
+      .def("InputStreams", &pangolin::VideoFilterInterface::InputStreams);
+    
+    pybind11::class_<pangolin::VideoUvcInterface, PyVideoUvcInterface > video_uvc_interface(m, "VideoUvcInterface");
+    video_uvc_interface
+      .def(pybind11::init<>())
+      .def("IoCtrl", &pangolin::VideoUvcInterface::IoCtrl)
+      .def("GetExposure", &pangolin::VideoUvcInterface::GetExposure)
+      .def("SetExposure", &pangolin::VideoUvcInterface::SetExposure)
+      .def("GetGain", &pangolin::VideoUvcInterface::GetGain)
+      .def("SetGain", &pangolin::VideoUvcInterface::SetGain);
+
+    pybind11::class_<pangolin::VideoPlaybackInterface, PyVideoPlaybackInterface > video_playback_interface(m, "VideoPlaybackInterface");
+    video_playback_interface
+      .def(pybind11::init<>())
+      .def("GetCurrentFrameId", &pangolin::VideoPlaybackInterface::GetCurrentFrameId)
+      .def("GetTotalFrames", &pangolin::VideoPlaybackInterface::GetTotalFrames)
+      .def("Seek", &pangolin::VideoPlaybackInterface::Seek);
+
+    pybind11::class_<pangolin::VideoOutputInterface, PyVideoOutputInterface > video_output_interface(m, "VideoOutputInterface");
+    video_output_interface
+      .def(pybind11::init<>())
+      .def("Streams", &pangolin::VideoOutputInterface::Streams)
+      .def("SetStreams", &pangolin::VideoOutputInterface::SetStreams) 
+      .def("WriteStreams", &pangolin::VideoOutputInterface::WriteStreams)
+      .def("IsPipe", &pangolin::VideoOutputInterface::IsPipe);
+
+    pybind11::enum_<pangolin::UvcRequestCode>(m, "UvcRequestCode")
+      .value("UVC_RC_UNDEFINED", pangolin::UvcRequestCode::UVC_RC_UNDEFINED)
+      .value("UVC_SET_CUR", pangolin::UvcRequestCode::UVC_SET_CUR)
+      .value("UVC_GET_CUR", pangolin::UvcRequestCode::UVC_GET_CUR)
+      .value("UVC_GET_MIN", pangolin::UvcRequestCode::UVC_GET_MIN)
+      .value("UVC_GET_MAX", pangolin::UvcRequestCode::UVC_GET_MAX)
+      .value("UVC_GET_RES", pangolin::UvcRequestCode::UVC_GET_RES)
+      .value("UVC_GET_LEN", pangolin::UvcRequestCode::UVC_GET_LEN)
+      .value("UVC_GET_INFO", pangolin::UvcRequestCode::UVC_GET_INFO)
+      .value("UVC_GET_DEF", pangolin::UvcRequestCode::UVC_GET_DEF)
+      .export_values();
+
+    /// This iterator enable pythonic video iterations a la `for frame in video_input: ...`
+    struct VideoInputIterator {
+        VideoInputIterator(pangolin::VideoInput& vi, pybind11::object ref) : vi(vi), ref(ref) { }
+
+        pybind11::list next() {
+            pybind11::list result = VideoInputGrab(vi, true, false);
+            if(result.size()==0)
+                throw pybind11::stop_iteration();
+            return result;
+        }
+        pangolin::VideoInput& vi;
+        pybind11::object ref; // keep a reference
+    };
+    pybind11::class_<VideoInputIterator>(m, "Iterator")
+      .def("__iter__", [](VideoInputIterator &it) -> VideoInputIterator& { return it; })
+      .def("__next__", &VideoInputIterator::next);
+
+    pybind11::class_<pangolin::VideoInput>(m, "VideoInput", video_interface)
+      .def(pybind11::init<>())
+      .def(pybind11::init<const std::string&, const std::string&>(), pybind11::arg("input_uri"), pybind11::arg("output_uri")="pango:[buffer_size_mb=100]//video_log.pango")      
+      .def("SizeBytes", &pangolin::VideoInput::SizeBytes)
+      .def("Streams", &pangolin::VideoInput::Streams)
+      .def("Start", &pangolin::VideoInput::Start)
+      .def("Stop", &pangolin::VideoInput::Stop)
+      .def("InputStreams", &pangolin::VideoInput::InputStreams)
+      .def("Open", &pangolin::VideoInput::Open, pybind11::arg("input_uri"), pybind11::arg("output_uri")="pango:[buffer_size_mb=100]//video_log.pango")      
+      .def("Close", &pangolin::VideoInput::Close)
+      .def("Grab", VideoInputGrab, pybind11::arg("wait")=true, pybind11::arg("newest")=false )
+      .def("GetStreamsBitDepth", [](pangolin::VideoInput& vi){
+        std::vector<int> bitDepthList;
+        for(size_t s=0; s < vi.Streams().size(); ++s) {
+            bitDepthList.push_back(vi.Streams()[s].PixFormat().channel_bit_depth);
+        }
+        return bitDepthList;
+       })
+      .def("GetNumStreams", [](pangolin::VideoInput& vi){
+        return (int) vi.Streams().size();
+        })
+      .def("GetCurrentFrameId", [](pangolin::VideoInput& vi){
+        return (int) vi.Cast<pangolin::VideoPlaybackInterface>()->GetCurrentFrameId();
+        })
+      .def("GetTotalFrames", [](pangolin::VideoInput& vi){
+        return (int) vi.Cast<pangolin::VideoPlaybackInterface>()->GetTotalFrames();
+        })
+      .def("Seek", [](pangolin::VideoInput& vi, size_t frameid){
+        vi.Cast<pangolin::VideoPlaybackInterface>()->Seek(frameid);
+        return;
+        })
+      .def("DeviceProperties", [](pangolin::VideoInput& vi) -> pybind11::object {
+            // Use std::string as an intermediate representation
+            const std::string props = vi.template Cast<pangolin::VideoPropertiesInterface>()->DeviceProperties().serialize();
+            pybind11::module pymodjson = pybind11::module::import("json");
+            auto pyloads = pymodjson.attr("loads");
+            auto json = pyloads(pybind11::str(props));
+            return json;
+            })
+      .def("FrameProperties", [](pangolin::VideoInput& vi) -> pybind11::object {
+            // Use std::string as an intermediate representation
+            const std::string props = vi.template Cast<pangolin::VideoPropertiesInterface>()->FrameProperties().serialize();
+            pybind11::module pymodjson = pybind11::module::import("json");
+            auto pyloads = pymodjson.attr("loads");
+            auto json = pyloads(pybind11::str(props));
+            return json;
+            })
+      .def("Width", &pangolin::VideoInput::Width)
+      .def("Height", &pangolin::VideoInput::Height)
+      .def("PixFormat", &pangolin::VideoInput::PixFormat)
+      .def("VideoUri", &pangolin::VideoInput::VideoUri)
+      .def("Reset", &pangolin::VideoInput::Reset)
+      .def("LogFilename", (const std::string& (pangolin::VideoInput::*)() const)&pangolin::VideoInput::LogFilename)
+      .def("LogFilename", (std::string& (pangolin::VideoInput::*)())&pangolin::VideoInput::LogFilename)
+      .def("Record", &pangolin::VideoInput::Record)
+      .def("RecordOneFrame", &pangolin::VideoInput::RecordOneFrame)
+      .def("SetTimelapse", &pangolin::VideoInput::SetTimelapse)
+      .def("IsRecording", &pangolin::VideoInput::IsRecording)
+      .def("__iter__", [](pybind11::object s) { return VideoInputIterator(s.cast<pangolin::VideoInput&>(), s);});
+
+    pybind11::class_<pangolin::VideoOutput>(m, "VideoOutput", video_output_interface)
+      .def(pybind11::init<>())
+      .def(pybind11::init<const std::string&>())
+      .def("IsOpen", &pangolin::VideoOutput::IsOpen)
+      .def("Open", &pangolin::VideoOutput::Open)
+      .def("Close", &pangolin::VideoOutput::Close)
+      .def("Streams", &pangolin::VideoOutput::Streams)
+      .def("WriteStreams", [](pangolin::VideoOutput& vo, pybind11::list images, const std::vector<int> &streamsBitDepth, pybind11::object frame_properties, pybind11::object device_properties, const std::string& descriptive_uri){
+        if(vo.SizeBytes()==0) {
+            PANGO_ASSERT(streamsBitDepth.size() == images.size() || streamsBitDepth.size() == 0);
+
+            // Setup stream info
+            for(size_t i = 0; i < images.size(); ++i){
+                // num bits per channel
+                auto arr = pybind11::array::ensure(images[i]);
+
+                // num channels
+                PANGO_ASSERT(arr.ndim() == 2 || arr.ndim() == 3, "Method only accepts ndarrays of 2 or 3 dimensions.");
+                const size_t channels = (arr.ndim() == 3) ? arr.shape(2) : 1;
+
+                std::string fmtStr;
+                if(pybind11::isinstance<pybind11::array_t<std::uint8_t>>(arr)){
+                   if(channels == 1) fmtStr = "GRAY8";
+                   else if(channels == 3) fmtStr = "RGB24";
+                   else if(channels == 4) fmtStr = "RGBA32";
+                   else PANGO_ASSERT(false, "Only 1, 3 and 4 channel uint8_t formats are supported.");
+                } else if (pybind11::isinstance<pybind11::array_t<std::uint16_t>>(arr)){
+                   if(channels == 1) fmtStr = "GRAY16LE";
+                   else if(channels == 3) fmtStr = "RGB48";
+                   else if(channels == 4) fmtStr = "RGBA64";
+                   else PANGO_ASSERT(false, "Only 1, 3 and 4 channel uint16_t formats are supported.");
+                } else if (pybind11::isinstance<pybind11::array_t<std::float_t>>(arr)){
+                    if(channels == 1) fmtStr = "GRAY32F";
+                    else if(channels == 3) fmtStr = "RGB96F";
+                    else if(channels == 4) fmtStr = "RGBA128F";
+                    else PANGO_ASSERT(false, "Only 1, 3 and 4 channel float_t formats are supported.");
+                } else if (pybind11::isinstance<pybind11::array_t<std::double_t>>(arr)){
+                    if(channels == 1) fmtStr = "GRAY64F";
+                    else PANGO_ASSERT(false, "Only 1 channel double_t format is supported.");
+                } else {
+                    PANGO_ASSERT(false, "numpy dtype must be either uint8_t, uint16_t, float_t or double_t");
+                }
+
+                pangolin::PixelFormat pf = pangolin::PixelFormatFromString(fmtStr);
+                if(streamsBitDepth.size())
+                    pf.channel_bit_depth = (unsigned int) streamsBitDepth[i];
+
+                vo.AddStream(pf, arr.shape(1), arr.shape(0));
+            }
+
+            picojson::value json_device_properties;
+            if(device_properties) {
+                json_device_properties = PicojsonFromPyObject(device_properties);
+            }
+
+            vo.SetStreams(descriptive_uri, json_device_properties);
+        }
+
+        picojson::value json_frame_properties;
+        if(frame_properties) {
+            json_frame_properties = PicojsonFromPyObject(frame_properties);
+        }
+
+        std::unique_ptr<uint8_t[]> buffer(new uint8_t[vo.SizeBytes()]);
+        std::vector<pangolin::Image<unsigned char>> bimgs = vo.GetOutputImages(buffer.get());
+        PANGO_ASSERT(bimgs.size() == images.size(), "length of input streams not consistent");
+        for(size_t i=0; i < images.size(); ++i) {
+            const pangolin::StreamInfo& so = vo.Streams()[i];
+            const unsigned int bpc = so.PixFormat().channel_bit_depth;
+            const unsigned int Bpp = so.PixFormat().bpp / (8);
+            if (bpc == 8){
+                pybind11::array_t<uint8_t> arr = images[i].cast<pybind11::array_t<unsigned char, pybind11::array::c_style | pybind11::array::forcecast>>();
+                pangolin::Image<uint8_t> srcImg(arr.mutable_data(0,0), bimgs[i].w, bimgs[i].h, bimgs[i].w * Bpp);
+                pangolin::PitchedCopy((char*)bimgs[i].ptr, bimgs[i].pitch, (char*)srcImg.ptr,
+                                      srcImg.pitch, srcImg.pitch, srcImg.h);
+            }else if (bpc == 12 || bpc == 16){
+                pybind11::array_t<uint16_t> arr = images[i].cast<pybind11::array_t<uint16_t, pybind11::array::c_style | pybind11::array::forcecast>>();
+                pangolin::Image<uint16_t> srcImg(arr.mutable_data(0,0), bimgs[i].w, bimgs[i].h, bimgs[i].w * Bpp);
+                pangolin::PitchedCopy((char*)bimgs[i].ptr, bimgs[i].pitch, (char*)srcImg.ptr,
+                                      srcImg.pitch, srcImg.pitch, srcImg.h);
+            }else if (bpc == 32){
+                pybind11::array_t<float_t> arr = images[i].cast<pybind11::array_t<float_t, pybind11::array::c_style | pybind11::array::forcecast>>();
+                pangolin::Image<float_t> srcImg(arr.mutable_data(0,0), bimgs[i].w, bimgs[i].h, bimgs[i].w * Bpp);
+                pangolin::PitchedCopy((char*)bimgs[i].ptr, bimgs[i].pitch, (char*)srcImg.ptr,
+                                      srcImg.pitch, srcImg.pitch, srcImg.h);
+            }else if (bpc == 64){
+                pybind11::array_t<double_t> arr = images[i].cast<pybind11::array_t<double_t, pybind11::array::c_style | pybind11::array::forcecast>>();
+                pangolin::Image<double_t> srcImg(arr.mutable_data(0,0), bimgs[i].w, bimgs[i].h, bimgs[i].w * Bpp);
+                pangolin::PitchedCopy((char*)bimgs[i].ptr, bimgs[i].pitch, (char*)srcImg.ptr,
+                                      srcImg.pitch, srcImg.pitch, srcImg.h);
+            }else{
+                PANGO_ASSERT(false, "format must have 8, 12, 16, 32 or 64 bit depth");
+            }
+        }
+        vo.WriteStreams(buffer.get(), json_frame_properties);
+      }, pybind11::arg("images"), pybind11::arg("streamsBitDepth") = std::vector<int>(), pybind11::arg("frame_properties") = pybind11::none(), pybind11::arg("device_properties") = pybind11::none(), pybind11::arg("descriptive_uri") = "python://")
+      .def("IsPipe", &pangolin::VideoOutput::IsPipe)
+      .def("AddStream", (void (pangolin::VideoOutput::*)(const pangolin::PixelFormat&, size_t,size_t,size_t))&pangolin::VideoOutput::AddStream)
+      .def("AddStream", (void (pangolin::VideoOutput::*)(const pangolin::PixelFormat&, size_t,size_t))&pangolin::VideoOutput::AddStream)
+      .def("SizeBytes", &pangolin::VideoOutput::SizeBytes)
+      .def("GetOutputImages", (std::vector<pangolin::Image<unsigned char>> (pangolin::VideoOutput::*)(unsigned char*) const)&pangolin::VideoOutput::GetOutputImages)    
+      .def("GetOutputImages", (std::vector<pangolin::Image<unsigned char>> (pangolin::VideoOutput::*)(std::vector<unsigned char>&) const)&pangolin::VideoOutput::GetOutputImages);   
+    
+  }
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/video.hpp

@@ -0,0 +1,37 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py_pangolin {
+
+  void bind_video(pybind11::module& m);
+
+}  // py_pangolin
+

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/view.cpp

@@ -0,0 +1,84 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "view.hpp"
+#include <pangolin/display/view.h>
+#include <pangolin/gl/opengl_render_state.h>
+#include <pangolin/handler/handler.h>
+#include <pybind11/functional.h>
+
+namespace py_pangolin {
+
+    void bind_view(pybind11::module &m) {
+    pybind11::class_<pangolin::View>(m, "View")
+      .def(pybind11::init<double>(), pybind11::arg("aspect") = 0.0)
+      .def("Activate", (void(pangolin::View::*)() const)&pangolin::View::Activate)
+      .def("Activate", (void(pangolin::View::*)(const pangolin::OpenGlRenderState&) const)&pangolin::View::Activate)
+      .def("ActivateAndScissor", (void(pangolin::View::*)() const)&pangolin::View::ActivateAndScissor)
+      .def("ActivateScissorAndClear", (void(pangolin::View::*)() const)&pangolin::View::ActivateScissorAndClear)
+      .def("ActivateAndScissor", (void(pangolin::View::*)(const pangolin::OpenGlRenderState&) const)&pangolin::View::ActivateAndScissor)
+      .def("ActivateScissorAndClear", (void(pangolin::View::*)(const pangolin::OpenGlRenderState&) const)&pangolin::View::ActivateScissorAndClear)
+      .def("ActivatePixelOrthographic", &pangolin::View::ActivatePixelOrthographic)
+      .def("ActivateIdentity", &pangolin::View::ActivateIdentity)
+      .def("GetClosestDepth", &pangolin::View::GetClosestDepth)
+      .def("GetCamCoordinates", &pangolin::View::GetCamCoordinates)
+      .def("GetObjectCoordinates", &pangolin::View::GetObjectCoordinates)
+      .def("Resize", &pangolin::View::Resize)
+      .def("ResizeChildren", &pangolin::View::ResizeChildren)
+      .def("Render", &pangolin::View::Render)
+      .def("RenderChildren", &pangolin::View::RenderChildren)
+      .def("SetFocus", &pangolin::View::SetFocus, pybind11::return_value_policy::reference)
+      .def("HasFocus", &pangolin::View::HasFocus)
+      .def("SetBounds", (pangolin::View& (pangolin::View::*)(pangolin::Attach, pangolin::Attach, pangolin::Attach, pangolin::Attach))&pangolin::View::SetBounds, pybind11::return_value_policy::reference)
+      .def("SetBounds", (pangolin::View& (pangolin::View::*)(pangolin::Attach, pangolin::Attach, pangolin::Attach, pangolin::Attach, bool))&pangolin::View::SetBounds, pybind11::return_value_policy::reference)
+      .def("SetBounds", (pangolin::View& (pangolin::View::*)(pangolin::Attach, pangolin::Attach, pangolin::Attach, pangolin::Attach, double))&pangolin::View::SetBounds, pybind11::return_value_policy::reference)
+      .def("SetHandler", &pangolin::View::SetHandler, pybind11::return_value_policy::reference)
+      .def("SetDrawFunction", &pangolin::View::SetDrawFunction, pybind11::return_value_policy::reference)
+      .def("SetAspect", &pangolin::View::SetAspect, pybind11::return_value_policy::reference)
+      .def("SetLock", &pangolin::View::SetLock, pybind11::return_value_policy::reference)
+      .def("SetLayout", &pangolin::View::SetLayout, pybind11::return_value_policy::reference)
+      .def("AddDisplay", &pangolin::View::AddDisplay, pybind11::return_value_policy::reference)
+      .def("Show", &pangolin::View::Show, pybind11::arg("show") = true, pybind11::return_value_policy::reference)
+      .def("ToggleShow", &pangolin::View::ToggleShow)
+      .def("IsShown", &pangolin::View::IsShown)
+      .def("GetBounds", &pangolin::View::GetBounds)
+      .def("NumChildren", &pangolin::View::NumChildren)
+      .def("GetChild", [] (pangolin::View &v, size_t i) -> pangolin::View& { return v[i];}, pybind11::return_value_policy::reference)
+      .def("VisibleChild", &pangolin::View::VisibleChild, pybind11::return_value_policy::reference)
+      .def("FindChild", &pangolin::View::FindChild)
+      .def("NumVisibleChildren", &pangolin::View::NumVisibleChildren);
+
+    pybind11::enum_<pangolin::Layout>(m, "Layout")
+        .value("Overlay", pangolin::LayoutOverlay)
+        .value("Vertical", pangolin::LayoutVertical)
+        .value("Horizontal", pangolin::LayoutHorizontal)
+        .value("Equal", pangolin::LayoutEqual)
+        .value("EqualVertical", pangolin::LayoutEqualVertical)
+        .value("EqualHorizontal", pangolin::LayoutEqualHorizontal);
+
+  }
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/view.hpp

@@ -0,0 +1,37 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py_pangolin {
+  
+    void bind_view(pybind11::module &m);
+
+}  // py_pangolin
+

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/viewport.cpp

@@ -0,0 +1,56 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "viewport.hpp"
+#include <pangolin/gl/viewport.h>
+
+namespace py_pangolin {
+
+  void bind_viewport(pybind11::module &m) {
+    pybind11::class_<pangolin::Viewport>(m, "Viewport")
+      .def(pybind11::init<>())
+      .def(pybind11::init<int, int, int, int>())
+      .def("Activate", &pangolin::Viewport::Activate)
+      .def("ActivateIdentity", &pangolin::Viewport::ActivateIdentity)
+      .def("ActivatePixelOrthographic", &pangolin::Viewport::ActivatePixelOrthographic)
+      .def("Scissor", &pangolin::Viewport::Scissor)
+      .def("ActivateAndScissor", &pangolin::Viewport::ActivateAndScissor)
+      .def("Contains", &pangolin::Viewport::Contains)
+      .def("Inset", (pangolin::Viewport (pangolin::Viewport::*)(int)const)&pangolin::Viewport::Inset)
+      .def("Inset", (pangolin::Viewport (pangolin::Viewport::*)(int, int)const)&pangolin::Viewport::Inset)
+      .def("Insetsect", &pangolin::Viewport::Intersect)
+      .def("DisableScissor", &pangolin::Viewport::DisableScissor)
+      .def("r", &pangolin::Viewport::r)
+      .def("t", &pangolin::Viewport::t)
+      .def("aspect", &pangolin::Viewport::aspect)
+      .def_readwrite("l", &pangolin::Viewport::l)
+      .def_readwrite("b", &pangolin::Viewport::b)
+      .def_readwrite("w", &pangolin::Viewport::w)
+      .def_readwrite("h", &pangolin::Viewport::h);
+  }
+
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/viewport.hpp

@@ -0,0 +1,38 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+
+namespace py_pangolin{
+
+  void bind_viewport(pybind11::module &m);
+  
+}  // py_pangolin
+

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/widget.cpp

@@ -0,0 +1,36 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "widget.hpp"
+#include <pangolin/display/widgets.h>
+
+namespace py_pangolin {
+
+  void bind_widget(pybind11::module &m){
+    m.def("CreatePanel", &pangolin::CreatePanel, pybind11::return_value_policy::reference);
+  }
+}  // py_pangolin

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/widget.hpp

@@ -0,0 +1,37 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace py_pangolin {
+  
+  void bind_widget(pybind11::module &m);
+
+}  // py_pangolin
+

third-party/DPVO/Pangolin/components/pango_python/src/pypangolin/window.cpp

@@ -0,0 +1,120 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) Andrey Mnatsakanov
+ *
+ * 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.
+ */
+
+#include "window.hpp"
+#include <pangolin/windowing/window.h>
+#include <functional>
+
+namespace py_pangolin {
+
+  class PyWindowInterface: public pangolin::WindowInterface{
+    public:
+    using pangolin::WindowInterface::WindowInterface;
+
+    void ShowFullscreen(const pangolin::TrueFalseToggle on_off) override {
+      PYBIND11_OVERLOAD_PURE(
+                             void,
+                             pangolin::WindowInterface,
+                             ShowFullscreen,
+                             on_off);
+    }
+
+    void Move(int x, int y) override {
+      PYBIND11_OVERLOAD_PURE(
+                             void,
+                             pangolin::WindowInterface,
+                             Move,
+                             x,
+                             y);
+    }
+
+    void Resize(unsigned int w, unsigned int h) override {
+      PYBIND11_OVERLOAD_PURE(
+                             void,
+                             pangolin::WindowInterface,
+                             Resize,
+                             w,
+                             h);
+    }
+
+    void MakeCurrent() override {
+      PYBIND11_OVERLOAD_PURE(
+                             void,
+                             pangolin::WindowInterface,
+                             MakeCurrent);
+    }
+
+    void RemoveCurrent() override {
+      PYBIND11_OVERLOAD_PURE(
+                             void,
+                             pangolin::WindowInterface,
+                             RemoveCurrent);
+    }
+
+    void ProcessEvents() override {
+      PYBIND11_OVERLOAD_PURE(
+                             void,
+                             pangolin::WindowInterface,
+                             ProcessEvents);
+    }
+
+
+    void SwapBuffers() override {
+      PYBIND11_OVERLOAD_PURE(
+                             void,
+                             pangolin::WindowInterface,
+                             SwapBuffers);
+    }
+
+    void SetOnRender(std::function<void ()> on_render) {
+      PYBIND11_OVERLOAD_PURE(
+                             void,
+                             pangolin::WindowInterface,
+                             SetOnRender,
+                             on_render);
+    }
+
+    void Run() {
+      PYBIND11_OVERLOAD_PURE(
+                             void,
+                             pangolin::WindowInterface,
+                             Run);
+    }
+  };
+  
+  void bind_window(pybind11::module &m) {
+    pybind11::class_<pangolin::WindowInterface, PyWindowInterface > windows_interface(m, "WindowsInterface");
+    windows_interface
+      .def(pybind11::init<>())
+      .def("ShowFullscreen", &pangolin::WindowInterface::ShowFullscreen)
+      .def("Move", &pangolin::WindowInterface::Move)
+      .def("Resize", &pangolin::WindowInterface::Resize)
+      .def("MakeCurrent", &pangolin::WindowInterface::MakeCurrent)
+      .def("ProcessEvents", &pangolin::WindowInterface::ProcessEvents)
+      .def("SwapBuffers", &pangolin::WindowInterface::SwapBuffers);
+  }
+}