diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..4c66785
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,104 @@
+cmake_minimum_required(VERSION 2.6)
+project("Pangolin")
+set(PANGOLIN_VERSION_MAJOR 0)
+set(PANGOLIN_VERSION_MINOR 5)
+set(PANGOLIN_VERSION ${PANGOLIN_VERSION_MAJOR}.${PANGOLIN_VERSION_MINOR})
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules/")
+
+# Platform configuration vars
+include(SetPlatformVars)
+
+SET(CPACK_GENERATOR "DEB")
+SET(CPACK_DEBIAN_PACKAGE_MAINTAINER "Steven Lovegrove")
+SET(CPACK_PACKAGE_VERSION_MAJOR ${PANGOLIN_VERSION_MAJOR})
+SET(CPACK_PACKAGE_VERSION_MINOR ${PANGOLIN_VERSION_MINOR})
+SET(CPACK_PACKAGE_VERSION_PATCH "0")
+include(CPack)
+
+option( BUILD_EXAMPLES "Build Examples" ON )
+option( BUILD_TESTS "Build Tests" ON )
+
+if(_WIN_)
+ option( BUILD_SHARED_LIBS "Build Shared Library" OFF)
+ option( BUILD_EXTERN_GLEW "Automatically download, build and compile GLEW" ON)
+ option( BUILD_EXTERN_LIBPNG "Automatically download, build and compile libpng" ON)
+ option( BUILD_EXTERN_LIBJPEG "Automatically download, build and compile libjpeg" ON)
+ option( MSVC_USE_STATIC_CRT "Use static C Runtime with MSVC, /MT instead of /MD" ON)
+
+ # Make sure there are no erroneous C Runtime flags
+ list(APPEND FLAG_VARS
+ CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO
+ CMAKE_C_FLAGS CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_C_FLAGS_MINSIZEREL CMAKE_C_FLAGS_RELWITHDEBINFO
+ )
+ if(MSVC_USE_STATIC_CRT)
+ foreach(FLAG_VAR ${FLAG_VARS})
+ string(REGEX REPLACE "/MD" "/MT" NEW_FLAGS "${${FLAG_VAR}}")
+ set(${FLAG_VAR} "${NEW_FLAGS}" CACHE STRING "" FORCE)
+ endforeach()
+ else()
+ foreach(FLAG_VAR ${FLAG_VARS})
+ string(REGEX REPLACE "/MT" "/MD" NEW_FLAGS "${${FLAG_VAR}}")
+ set(${FLAG_VAR} "${NEW_FLAGS}" CACHE STRING "" FORCE)
+ endforeach()
+ endif()
+else()
+ option( BUILD_SHARED_LIBS "Build Shared Library" ON)
+endif()
+
+if(NOT MSVC)
+ set( CMAKE_CXX_FLAGS "-std=c++14 -Wall -Wextra ${CMAKE_CXX_FLAGS} -fPIC" ) # modified for python binding (add " -fPIC")
+ if(_CLANG_)
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++ -fPIC") # modified for python binding (add " -fPIC")
+ endif()
+endif()
+
+if(ANDROID)
+ set(ANDROID_PACKAGE_NAME "com.github.stevenlovegrove.pangolin")
+ include(AndroidUtils)
+endif()
+
+if(ANDROID OR IOS)
+ set(HAVE_GLES 1)
+ option(BUILD_FOR_GLES_2 "Build for OpenGL ES 2 instead of ES 1" ON )
+ if(BUILD_FOR_GLES_2)
+ set(HAVE_GLES_2 1)
+ endif()
+endif()
+
+if(_OSX_)
+ set(CMAKE_MACOSX_RPATH ON)
+endif()
+
+# Overide with cmake -DCMAKE_BUILD_TYPE=Debug {dir}
+if( NOT CMAKE_BUILD_TYPE AND NOT _WIN_ )
+ message("Build type not set (defaults to release)")
+ message("-DCMAKE_BUILD_TYPE=Debug for debug")
+ set( CMAKE_BUILD_TYPE Release )
+endif()
+
+string(TOLOWER _${PROJECT_NAME} LIBRARY_NAME) # modified for python binding (add "_" to avoid naming conflict with python library "pangolin")
+
+# make an uninstall target
+configure_file(
+ "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
+ "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
+ IMMEDIATE @ONLY
+)
+
+add_custom_target(uninstall
+ "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
+
+add_subdirectory("external")
+add_subdirectory("src")
+add_subdirectory("python")
+
+if(BUILD_TESTS)
+ add_subdirectory("test")
+endif()
+
+if(BUILD_EXAMPLES)
+ set(Pangolin_DIR ${Pangolin_BINARY_DIR}/src)
+ add_subdirectory(examples)
+ add_subdirectory(tools)
+endif()
diff --git a/CMakeModules/AndroidUtils.cmake b/CMakeModules/AndroidUtils.cmake
new file mode 100644
index 0000000..cfb13dc
--- /dev/null
+++ b/CMakeModules/AndroidUtils.cmake
@@ -0,0 +1,245 @@
+if(NOT ANDROID_PACKAGE_NAME)
+ set(ANDROID_PACKAGE_NAME "com.github.stevenlovegrove.pangolin")
+endif()
+
+if(NOT ANDROID_DEFERRED_ENTRY_SO)
+ set(ANDROID_DEFERRED_ENTRY_SO "libpangolin.so")
+endif()
+
+# Configure build environment to automatically generate APK's instead of executables.
+if(ANDROID AND NOT TARGET apk)
+ # virtual targets which we'll add apks and push actions to.
+ add_custom_target( apk )
+ add_custom_target( push )
+ add_custom_target( run )
+
+ # Reset output directories to be in binary folder (rather than source)
+ set(LIBRARY_OUTPUT_PATH_ROOT ${CMAKE_CURRENT_BINARY_DIR})
+ set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME})
+ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH_ROOT}/libs/${ANDROID_NDK_ABI_NAME})
+ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${LIBRARY_OUTPUT_PATH_ROOT}/bin/${ANDROID_NDK_ABI_NAME})
+
+ macro( create_android_manifest_xml filename prog_name package_name activity_name)
+ file( WRITE ${filename}
+"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+" )
+ endmacro()
+
+ macro( create_bootstrap_library prog_name package_name)
+ set(bootstrap_cpp "${CMAKE_CURRENT_BINARY_DIR}/${prog_name}_start.cpp" )
+ file( WRITE ${bootstrap_cpp}
+"#include
+#include
+#include
+#include
+#include
+#include
+
+#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, \"AndroidUtils.cmake\", __VA_ARGS__))
+#define LIB_PATH \"/data/data/${package_name}.${prog_name}/lib/\"
+
+void * load_lib(const char * l) {
+ void * handle = dlopen(l, RTLD_NOW | RTLD_GLOBAL);
+ if (!handle) LOGE( \"dlopen('%s'): %s\", l, strerror(errno) );
+ return handle;
+}
+
+void ANativeActivity_onCreate(ANativeActivity * app, void * ud, size_t udsize) {
+ #include \"${prog_name}_shared_load.h\"
+
+ // Look for standard entrypoint in user lib
+ void (*stdentrypoint)(ANativeActivity*, void*, size_t);
+ *(void **) (&stdentrypoint) = dlsym(load_lib( LIB_PATH \"lib${prog_name}.so\"), \"ANativeActivity_onCreate\");
+ if (stdentrypoint) {
+ (*stdentrypoint)(app, ud, udsize);
+ }else{
+ // Look for deferred load entry point
+ void (*exdentrypoint)(ANativeActivity*, void*, size_t, const char*);
+ *(void **) (&exdentrypoint) = dlsym(load_lib( LIB_PATH \"lib${prog_name}.so\"), \"DeferredNativeActivity_onCreate\");
+ if (!exdentrypoint) {
+ // Look in specific shared lib
+ *(void **) (&exdentrypoint) = dlsym(load_lib( LIB_PATH \"${ANDROID_DEFERRED_ENTRY_SO}\"), \"DeferredNativeActivity_onCreate\");
+ }
+ if(exdentrypoint) {
+ (*exdentrypoint)(app, ud, udsize, LIB_PATH \"lib${prog_name}.so\" );
+ }else{
+ LOGE( \"Unable to find compatible entry point\" );
+ }
+ }
+}" )
+ add_library( "${prog_name}_start" SHARED ${bootstrap_cpp} )
+ target_link_libraries( "${prog_name}_start" android log )
+ add_dependencies( ${prog_name} "${prog_name}_start" )
+ endmacro()
+
+ macro( android_update android_project_name)
+ # Find which android platforms are available.
+ execute_process(
+ COMMAND android list targets -c
+ OUTPUT_VARIABLE android_target_list
+ )
+
+ # Pick first platform from this list.
+ string(REGEX MATCH "^[^\n]+" android_target "${android_target_list}" )
+ message(STATUS "Android Target: ${android_target}")
+
+ if( NOT "${android_target}" STREQUAL "" )
+ # Generate ant build scripts for making APK
+ execute_process(
+ COMMAND android update project --name ${android_project_name} --path . --target ${android_target} --subprojects
+ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+ )
+ else()
+ message( FATAL_ERROR "No Android SDK platforms found. Please install an Android platform SDK. On Linux, run 'android'." )
+ endif()
+ endmacro()
+
+ # Override add_executable to build android .so instead!
+ macro( add_executable prog_name)
+ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/libs/${ANDROID_NDK_ABI_NAME})
+ add_library( ${prog_name} SHARED ${ARGN} )
+
+ # Add required link libs for android
+ target_link_libraries(${prog_name} log android )
+
+ # Create manifest required for APK
+ create_android_manifest_xml(
+ "${CMAKE_CURRENT_BINARY_DIR}/AndroidManifest.xml" "${prog_name}"
+ "${ANDROID_PACKAGE_NAME}" "${prog_name}"
+ )
+
+ # Create library that will launch this program and load shared libs
+ create_bootstrap_library( ${prog_name} ${ANDROID_PACKAGE_NAME} )
+
+ # Generate ant build system for APK
+ android_update( ${prog_name} )
+
+ # Target to invoke ant build system for APK
+ set( APK_FILE "${CMAKE_CURRENT_BINARY_DIR}/bin/${prog_name}-debug.apk" )
+ add_custom_command(
+ OUTPUT ${APK_FILE}
+ COMMAND ant debug
+ DEPENDS ${prog_name}
+ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+ )
+
+ # Target to install on device
+ add_custom_target( ${prog_name}-apk
+ DEPENDS ${APK_FILE}
+ )
+ add_dependencies(apk ${prog_name}-apk)
+
+ # Target to install on device
+ add_custom_target( ${prog_name}-push
+ COMMAND adb install -r ${APK_FILE}
+ DEPENDS ${APK_FILE}
+ )
+ add_dependencies(push ${prog_name}-push)
+
+ # install and run on device
+ add_custom_target( ${prog_name}-run
+ COMMAND adb shell am start -n ${ANDROID_PACKAGE_NAME}.${prog_name}/android.app.NativeActivity
+ DEPENDS ${prog_name}-push
+ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ )
+ add_dependencies(run ${prog_name}-run)
+
+ # Flag to package dependent libs
+ set_property(TARGET ${prog_name} APPEND PROPERTY MAKE_APK 1 )
+
+ # Clear shared library loading header
+ file( WRITE "${CMAKE_CURRENT_BINARY_DIR}/${prog_name}_shared_load.h" "")
+ endmacro()
+
+ macro( package_with_target prog_name lib_path )
+ # Mark lib_path as dependent of prog_name
+ set_property(TARGET ${prog_name} APPEND PROPERTY IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE ${lib_path} )
+
+ # If prog_name is to be packaged, add file copy command to package .so's.
+ get_target_property( package_dependent_libs ${prog_name} MAKE_APK )
+ if( package_dependent_libs )
+ get_filename_component(target_filename ${lib_path} NAME)
+ file( APPEND ${depend_file} "load_lib(LIB_PATH \"${target_filename}\" );\n")
+ add_custom_command(TARGET ${prog_name} POST_BUILD
+ COMMAND ${CMAKE_COMMAND} -E copy_if_different
+ ${lib_path} "${CMAKE_CURRENT_BINARY_DIR}/libs/${ANDROID_NDK_ABI_NAME}/"
+ )
+ endif()
+ endmacro()
+
+ macro( add_to_depend_libs prog_name depend_file lib_name )
+ # Recursively Process dependents of lib_name
+ get_target_property(TARGET_LIBS ${lib_name} IMPORTED_LINK_INTERFACE_LIBRARIES_RELEASE)
+ if(NOT TARGET_LIBS)
+ get_target_property(TARGET_LIBS ${lib_name} IMPORTED_LINK_INTERFACE_LIBRARIES_NOCONFIG)
+ endif()
+ if(NOT TARGET_LIBS)
+ get_target_property(TARGET_LIBS ${lib_name} IMPORTED_LINK_INTERFACE_LIBRARIES_DEBUG)
+ endif()
+
+ foreach(SUBLIB ${TARGET_LIBS})
+ if(SUBLIB)
+ add_to_depend_libs( ${prog_name} ${depend_file} ${SUBLIB} )
+ endif()
+ endforeach()
+
+ # Check if lib itself is an external shared library
+ if("${lib_name}" MATCHES "\\.so$")
+ package_with_target( ${prog_name} ${lib_name} )
+ endif()
+
+ # Check if lib itself is an internal shared library
+ get_target_property(TARGET_LIB ${lib_name} LOCATION)
+ if("${TARGET_LIB}" MATCHES "\\.so$")
+ package_with_target( ${prog_name} ${TARGET_LIB} )
+ endif()
+ endmacro()
+
+ macro( target_link_libraries prog_name)
+ # _target_link_libraries corresponds to original
+ _target_link_libraries( ${prog_name} ${ARGN} )
+
+ # Recursively process dependencies
+ set(depend_file "${CMAKE_CURRENT_BINARY_DIR}/${prog_name}_shared_load.h" )
+ foreach( LIB ${ARGN} )
+ add_to_depend_libs( ${prog_name} ${depend_file} ${LIB} )
+ endforeach()
+ endmacro()
+
+endif()
diff --git a/CMakeModules/CreateMethodCallFile.cmake b/CMakeModules/CreateMethodCallFile.cmake
new file mode 100644
index 0000000..c1ae95b
--- /dev/null
+++ b/CMakeModules/CreateMethodCallFile.cmake
@@ -0,0 +1,11 @@
+macro( CreateMethodCallFile filename namespace function symbols)
+ file(WRITE ${filename} "// CMake generated file. Do Not Edit.\n\n#pragma once\n\nnamespace ${namespace} {\n\n")
+ foreach( symbol ${symbols} )
+ file(APPEND ${filename} "void ${symbol}();\n")
+ endforeach()
+ file(APPEND ${filename} "\ninline bool ${function}()\n{\n")
+ foreach( symbol ${symbols} )
+ file(APPEND ${filename} " ${symbol}();\n")
+ endforeach()
+ file(APPEND ${filename} " return true;\n}\n\n} // ${namespace}\n")
+endmacro()
diff --git a/CMakeModules/EmbedBinaryFiles.cmake b/CMakeModules/EmbedBinaryFiles.cmake
new file mode 100644
index 0000000..d595165
--- /dev/null
+++ b/CMakeModules/EmbedBinaryFiles.cmake
@@ -0,0 +1,32 @@
+# Creates C resources file from files in given directory
+# Based on http://stackoverflow.com/a/27206982
+function(embed_binary_files file_glob output)
+ # Collect input files
+ file(GLOB bins ${file_glob})
+ # Stop when output file is newer than all binary files
+ set(output_newer_than_bins 1)
+ foreach(bin ${bins})
+ if(bin IS_NEWER_THAN output)
+ set(output_newer_than_bins 0)
+ break()
+ endif()
+ endforeach()
+ if(output_newer_than_bins)
+ return()
+ endif()
+ # Create empty output file
+ file(WRITE ${output} "")
+ # Iterate through input files
+ foreach(bin ${bins})
+ # Get short filename
+ string(REGEX MATCH "([^/]+)$" filename ${bin})
+ # Replace filename spaces & extension separator for C compatibility
+ string(REGEX REPLACE "\\.| " "_" filename ${filename})
+ # Read hex data from file
+ file(READ ${bin} filedata HEX)
+ # Convert hex data for C compatibility
+ string(REGEX REPLACE "([0-9a-f][0-9a-f])" "0x\\1," filedata ${filedata})
+ # Append data to output file
+ file(APPEND ${output} "const unsigned char ${filename}[] = {${filedata}};\nconst unsigned ${filename}_size = sizeof(${filename});\n")
+ endforeach()
+endfunction()
diff --git a/CMakeModules/FindDC1394.cmake b/CMakeModules/FindDC1394.cmake
new file mode 100644
index 0000000..1dbce01
--- /dev/null
+++ b/CMakeModules/FindDC1394.cmake
@@ -0,0 +1,32 @@
+# Try to find the dc1394 v2 lib and include files
+#
+# DC1394_INCLUDE_DIR
+# DC1394_LIBRARIES
+# DC1394_FOUND
+
+FIND_PATH( DC1394_INCLUDE_DIR dc1394/control.h
+ /usr/include
+ /usr/local/include
+)
+
+FIND_LIBRARY( DC1394_LIBRARY dc1394
+ /usr/lib64
+ /usr/lib
+ /usr/local/lib
+)
+
+IF(DC1394_INCLUDE_DIR AND DC1394_LIBRARY)
+ SET( DC1394_FOUND TRUE )
+ SET( DC1394_LIBRARIES ${DC1394_LIBRARY} )
+ENDIF(DC1394_INCLUDE_DIR AND DC1394_LIBRARY)
+
+IF(DC1394_FOUND)
+ IF(NOT DC1394_FIND_QUIETLY)
+ MESSAGE(STATUS "Found DC1394: ${DC1394_LIBRARY}")
+ ENDIF(NOT DC1394_FIND_QUIETLY)
+ELSE(DC1394_FOUND)
+ IF(DC1394_FIND_REQUIRED)
+ MESSAGE(FATAL_ERROR "Could not find libdc1394")
+ ENDIF(DC1394_FIND_REQUIRED)
+ENDIF(DC1394_FOUND)
+
diff --git a/CMakeModules/FindDepthSense.cmake b/CMakeModules/FindDepthSense.cmake
new file mode 100644
index 0000000..ede0034
--- /dev/null
+++ b/CMakeModules/FindDepthSense.cmake
@@ -0,0 +1,43 @@
+# Try to find the DepthSense SDK For SoftKinetic Cameras
+#
+# DepthSense_INCLUDE_DIRS
+# DepthSense_LIBRARIES
+# DepthSense_FOUND
+
+FIND_PATH( DepthSense_INCLUDE_DIR DepthSense.hxx
+ PATHS
+ "${PROGRAM_FILES}/SoftKinetic/DepthSenseSDK/include"
+ "${PROGRAM_FILES}/Meta/DepthSenseSDK/include"
+ /usr/include
+ /usr/local/include
+ /opt/local/include
+ /opt/softkinetic/DepthSenseSDK/include
+)
+
+FIND_LIBRARY( DepthSense_LIBRARY DepthSense
+ PATHS
+ "${PROGRAM_FILES}/SoftKinetic/DepthSenseSDK/lib"
+ "${PROGRAM_FILES}/Meta/DepthSenseSDK/lib"
+ /usr/lib64
+ /usr/lib
+ /usr/local/lib
+ /opt/local/lib
+ /opt/softkinetic/DepthSenseSDK/lib
+)
+
+IF(DepthSense_INCLUDE_DIR AND DepthSense_LIBRARY)
+ SET( DepthSense_FOUND TRUE )
+ SET( DepthSense_LIBRARIES ${DepthSense_LIBRARY} )
+ SET( DepthSense_INCLUDE_DIRS ${DepthSense_INCLUDE_DIR} )
+ENDIF()
+
+IF(DepthSense_FOUND)
+ IF(NOT DepthSense_FIND_QUIETLY)
+ MESSAGE(STATUS "Found DepthSense: ${DepthSense_LIBRARY}")
+ ENDIF()
+ELSE()
+ IF(DepthSense_FIND_REQUIRED)
+ MESSAGE(FATAL_ERROR "Could not find DepthSense")
+ ENDIF()
+ENDIF()
+
diff --git a/CMakeModules/FindEigen.cmake b/CMakeModules/FindEigen.cmake
new file mode 100644
index 0000000..1df56fd
--- /dev/null
+++ b/CMakeModules/FindEigen.cmake
@@ -0,0 +1,83 @@
+# - Try to find Eigen lib
+#
+# This module supports requiring a minimum version, e.g. you can do
+# find_package(Eigen 3.1.2)
+# to require version 3.1.2 or newer of Eigen.
+#
+# Once done this will define
+#
+# EIGEN_FOUND - system has eigen lib with correct version
+# EIGEN_INCLUDE_DIR - the eigen include directory
+# EIGEN_VERSION - eigen version
+
+# Copyright (c) 2006, 2007 Montel Laurent,
+# Copyright (c) 2008, 2009 Gael Guennebaud,
+# Copyright (c) 2009 Benoit Jacob
+# Redistribution and use is allowed according to the terms of the 2-clause BSD license.
+
+if(NOT Eigen_FIND_VERSION)
+ if(NOT Eigen_FIND_VERSION_MAJOR)
+ set(Eigen_FIND_VERSION_MAJOR 2)
+ endif(NOT Eigen_FIND_VERSION_MAJOR)
+ if(NOT Eigen_FIND_VERSION_MINOR)
+ set(Eigen_FIND_VERSION_MINOR 91)
+ endif(NOT Eigen_FIND_VERSION_MINOR)
+ if(NOT Eigen_FIND_VERSION_PATCH)
+ set(Eigen_FIND_VERSION_PATCH 0)
+ endif(NOT Eigen_FIND_VERSION_PATCH)
+
+ set(Eigen_FIND_VERSION "${Eigen_FIND_VERSION_MAJOR}.${Eigen_FIND_VERSION_MINOR}.${Eigen_FIND_VERSION_PATCH}")
+endif(NOT Eigen_FIND_VERSION)
+
+macro(_eigen3_check_version)
+ file(READ "${EIGEN_INCLUDE_DIR}/Eigen/src/Core/util/Macros.h" _eigen3_version_header)
+
+ string(REGEX MATCH "define[ \t]+EIGEN_WORLD_VERSION[ \t]+([0-9]+)" _eigen3_world_version_match "${_eigen3_version_header}")
+ set(Eigen_WORLD_VERSION "${CMAKE_MATCH_1}")
+ string(REGEX MATCH "define[ \t]+EIGEN_MAJOR_VERSION[ \t]+([0-9]+)" _eigen3_major_version_match "${_eigen3_version_header}")
+ set(Eigen_MAJOR_VERSION "${CMAKE_MATCH_1}")
+ string(REGEX MATCH "define[ \t]+EIGEN_MINOR_VERSION[ \t]+([0-9]+)" _eigen3_minor_version_match "${_eigen3_version_header}")
+ set(Eigen_MINOR_VERSION "${CMAKE_MATCH_1}")
+
+ set(EIGEN_VERSION ${Eigen_WORLD_VERSION}.${Eigen_MAJOR_VERSION}.${Eigen_MINOR_VERSION})
+ if(${EIGEN_VERSION} VERSION_LESS ${Eigen_FIND_VERSION})
+ set(EIGEN_VERSION_OK FALSE)
+ else(${EIGEN_VERSION} VERSION_LESS ${Eigen_FIND_VERSION})
+ set(EIGEN_VERSION_OK TRUE)
+ endif(${EIGEN_VERSION} VERSION_LESS ${Eigen_FIND_VERSION})
+
+ if(NOT EIGEN_VERSION_OK)
+ message(STATUS "Eigen version ${EIGEN_VERSION} found in ${EIGEN_INCLUDE_DIR}, "
+ "but at least version ${Eigen_FIND_VERSION} is required")
+ endif(NOT EIGEN_VERSION_OK)
+endmacro(_eigen3_check_version)
+
+if (EIGEN_INCLUDE_DIR)
+ # in cache already
+ _eigen3_check_version()
+ set(EIGEN_FOUND ${EIGEN_VERSION_OK})
+else()
+ find_path(EIGEN_INCLUDE_DIR NAMES signature_of_eigen3_matrix_library
+ PATHS
+ third_party/eigen
+ ../eigen
+ ../../eigen
+ /usr/local/include
+ /opt/local/include
+ ${CMAKE_INSTALL_PREFIX}/include
+ ${KDE4_INCLUDE_DIR}
+ PATH_SUFFIXES eigen3 eigen
+ )
+
+ if(EIGEN_INCLUDE_DIR)
+ _eigen3_check_version()
+ endif(EIGEN_INCLUDE_DIR)
+
+ include(FindPackageHandleStandardArgs)
+ find_package_handle_standard_args(Eigen DEFAULT_MSG EIGEN_INCLUDE_DIR EIGEN_VERSION_OK)
+
+ mark_as_advanced(EIGEN_INCLUDE_DIR)
+endif()
+
+# In case anyone relies on the plural form.
+set(EIGEN_INCLUDE_DIRS "${EIGEN_INCLUDE_DIR}")
diff --git a/CMakeModules/FindFFMPEG.cmake b/CMakeModules/FindFFMPEG.cmake
new file mode 100644
index 0000000..4f77e5a
--- /dev/null
+++ b/CMakeModules/FindFFMPEG.cmake
@@ -0,0 +1,88 @@
+# Try to find the ffmpeg libraries and headers for avcodec avformat swscale
+#
+# FFMPEG_INCLUDE_DIRS
+# FFMPEG_LIBRARIES
+# FFMPEG_FOUND
+
+# Find header files
+FIND_PATH(
+ AVCODEC_INCLUDE_DIR libavcodec/avcodec.h
+ /usr/include /usr/local/include /opt/local/include
+)
+FIND_PATH(
+ AVFORMAT_INCLUDE_DIR libavformat/avformat.h
+ /usr/include /usr/local/include /opt/local/include
+)
+FIND_PATH(
+ AVUTIL_INCLUDE_DIR libavutil/avutil.h
+ /usr/include /usr/local/include /opt/local/include
+)
+FIND_PATH(
+ SWSCALE_INCLUDE_DIR libswscale/swscale.h
+ /usr/include /usr/local/include /opt/local/include
+)
+
+# Find Library files
+FIND_LIBRARY(
+ AVCODEC_LIBRARY
+ NAMES avcodec
+ PATH /usr/lib /usr/local/lib /opt/local/lib
+)
+FIND_LIBRARY(
+ AVFORMAT_LIBRARY
+ NAMES avformat
+ PATH /usr/lib /usr/local/lib /opt/local/lib
+)
+FIND_LIBRARY(
+ AVUTIL_LIBRARY
+ NAMES avutil
+ PATH /usr/lib /usr/local/lib /opt/local/lib
+)
+FIND_LIBRARY(
+ SWSCALE_LIBRARY
+ NAMES swscale
+ PATH /usr/lib /usr/local/lib /opt/local/lib
+)
+
+IF( EXISTS "${AVUTIL_INCLUDE_DIR}/libavutil/pixdesc.h" )
+ SET( AVUTIL_HAVE_PIXDESC TRUE)
+endif()
+
+IF(AVCODEC_INCLUDE_DIR AND AVFORMAT_INCLUDE_DIR AND AVUTIL_INCLUDE_DIR AND SWSCALE_INCLUDE_DIR AND AVCODEC_LIBRARY AND AVFORMAT_LIBRARY AND AVUTIL_LIBRARY AND SWSCALE_LIBRARY AND AVUTIL_HAVE_PIXDESC)
+ SET(FFMPEG_FOUND TRUE)
+ SET(FFMPEG_LIBRARIES ${AVCODEC_LIBRARY} ${AVFORMAT_LIBRARY} ${AVUTIL_LIBRARY} ${SWSCALE_LIBRARY})
+ SET(FFMPEG_INCLUDE_DIRS ${AVCODEC_INCLUDE_DIR} ${AVFORMAT_INCLUDE_DIR} ${AVUTIL_INCLUDE_DIR} ${SWSCALE_INCLUDE_DIR})
+
+ include(CheckCXXSourceCompiles)
+
+ SET(CMAKE_REQUIRED_INCLUDES ${FFMPEG_INCLUDE_DIRS})
+
+ CHECK_CXX_SOURCE_COMPILES(
+ "#include \"${AVCODEC_INCLUDE_DIR}/libavformat/avformat.h\"
+ int main() {
+ sizeof(AVFormatContext::max_analyze_duration2);
+ }" HAVE_FFMPEG_MAX_ANALYZE_DURATION2
+ )
+ CHECK_CXX_SOURCE_COMPILES(
+ "#include \"${AVCODEC_INCLUDE_DIR}/libavformat/avformat.h\"
+ int main() {
+ &avformat_alloc_output_context2;
+ }" HAVE_FFMPEG_AVFORMAT_ALLOC_OUTPUT_CONTEXT2
+ )
+ CHECK_CXX_SOURCE_COMPILES(
+ "#include \"${AVCODEC_INCLUDE_DIR}/libavutil/pixdesc.h\"
+ int main() {
+ AVPixelFormat test = AV_PIX_FMT_GRAY8;
+ }" HAVE_FFMPEG_AVPIXELFORMAT
+ )
+ENDIF()
+
+IF (FFMPEG_FOUND)
+ IF (NOT FFMPEG_FIND_QUIETLY)
+ MESSAGE(STATUS "Found FFMPEG: ${FFMPEG_LIBRARIES}")
+ ENDIF (NOT FFMPEG_FIND_QUIETLY)
+ELSE (FFMPEG_FOUND)
+ IF (FFMPEG_FIND_REQUIRED)
+ MESSAGE(FATAL_ERROR "Could not find FFMPEG")
+ ENDIF (FFMPEG_FIND_REQUIRED)
+ENDIF (FFMPEG_FOUND)
diff --git a/CMakeModules/FindFREEGLUT.cmake b/CMakeModules/FindFREEGLUT.cmake
new file mode 100644
index 0000000..b3e32b0
--- /dev/null
+++ b/CMakeModules/FindFREEGLUT.cmake
@@ -0,0 +1,44 @@
+# Try to find the FREEGLUT library
+#
+# FREEGLUT_INCLUDE_DIR
+# FREEGLUT_LIBRARY
+# FREEGLUT_FOUND
+
+FIND_PATH(
+ FREEGLUT_INCLUDE_DIR GL/freeglut.h
+ ${CMAKE_INCLUDE_PATH}
+ $ENV{include}
+ ${OPENGL_INCLUDE_DIR}
+ /usr/include
+ /usr/local/include
+)
+
+SET(STORE_CMAKE_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK})
+SET(CMAKE_FIND_FRAMEWORK NEVER)
+
+FIND_LIBRARY(
+ FREEGLUT_LIBRARY
+ NAMES freeglut_static freeglut glut
+ PATH
+ /opt/local/lib
+ ${CMAKE_LIBRARY_PATH}
+ $ENV{lib}
+ /usr/lib
+ /usr/local/lib
+)
+
+SET(CMAKE_FIND_FRAMEWORK ${STORE_CMAKE_FIND_FRAMEWORK})
+
+IF (FREEGLUT_INCLUDE_DIR AND FREEGLUT_LIBRARY)
+ SET(FREEGLUT_FOUND TRUE)
+ENDIF (FREEGLUT_INCLUDE_DIR AND FREEGLUT_LIBRARY)
+
+IF (FREEGLUT_FOUND)
+ IF (NOT FREEGLUT_FIND_QUIETLY)
+ MESSAGE(STATUS "Found FREEGLUT: ${FREEGLUT_LIBRARY}")
+ ENDIF (NOT FREEGLUT_FIND_QUIETLY)
+ELSE (FREEGLUT_FOUND)
+ IF (FREEGLUT_FIND_REQUIRED)
+ MESSAGE(FATAL_ERROR "Could not find FREEGLUT")
+ ENDIF (FREEGLUT_FIND_REQUIRED)
+ENDIF (FREEGLUT_FOUND)
diff --git a/CMakeModules/FindGLEW.cmake b/CMakeModules/FindGLEW.cmake
new file mode 100644
index 0000000..65ef6f9
--- /dev/null
+++ b/CMakeModules/FindGLEW.cmake
@@ -0,0 +1,53 @@
+#
+# Try to find GLEW library and include path.
+# Once done this will define
+#
+# GLEW_FOUND
+# GLEW_INCLUDE_DIR
+# GLEW_LIBRARY
+#
+
+IF (WIN32)
+ FIND_PATH( GLEW_INCLUDE_DIR GL/glew.h
+ $ENV{PROGRAMFILES}/GLEW/include
+ ${PROJECT_SOURCE_DIR}/src/nvgl/glew/include
+ DOC "The directory where GL/glew.h resides")
+ FIND_LIBRARY( GLEW_LIBRARY
+ NAMES glew GLEW glew32 glew32s
+ PATHS
+ $ENV{PROGRAMFILES}/GLEW/lib
+ ${PROJECT_SOURCE_DIR}/src/nvgl/glew/bin
+ ${PROJECT_SOURCE_DIR}/src/nvgl/glew/lib
+ DOC "The GLEW library")
+ELSE (WIN32)
+ FIND_PATH( GLEW_INCLUDE_DIR GL/glew.h
+ /usr/include
+ /usr/local/include
+ /sw/include
+ /opt/local/include
+ DOC "The directory where GL/glew.h resides")
+ FIND_LIBRARY( GLEW_LIBRARY
+ NAMES GLEW glew
+ PATHS
+ /usr/lib64
+ /usr/lib
+ /usr/local/lib64
+ /usr/local/lib
+ /sw/lib
+ /opt/local/lib
+ DOC "The GLEW library")
+ENDIF (WIN32)
+
+IF (GLEW_INCLUDE_DIR AND GLEW_LIBRARY)
+ SET( GLEW_FOUND TRUE )
+ENDIF (GLEW_INCLUDE_DIR AND GLEW_LIBRARY)
+
+IF (GLEW_FOUND)
+ IF (NOT GLEW_FIND_QUIETLY)
+ MESSAGE(STATUS "Found GLEW: ${GLEW_LIBRARY}")
+ ENDIF (NOT GLEW_FIND_QUIETLY)
+ELSE (GLEW_FOUND)
+ IF (GLEW_FIND_REQUIRED)
+ MESSAGE(FATAL_ERROR "Could not find GLEW")
+ ENDIF (GLEW_FIND_REQUIRED)
+ENDIF (GLEW_FOUND)
diff --git a/CMakeModules/FindGLUES.cmake b/CMakeModules/FindGLUES.cmake
new file mode 100644
index 0000000..2c64fe8
--- /dev/null
+++ b/CMakeModules/FindGLUES.cmake
@@ -0,0 +1,38 @@
+# Try to find the GLUES lib and include files
+#
+# GLUES_INCLUDE_DIR
+# GLUES_LIBRARIES
+# GLUES_FOUND
+
+FIND_PATH( GLUES_INCLUDE_DIR glues/glues.h
+ /usr/include
+ /usr/local/include
+ /opt/include
+ /opt/local/include
+ ${CMAKE_INSTALL_PREFIX}/include
+)
+
+FIND_LIBRARY( GLUES_LIBRARY glues
+ /usr/lib64
+ /usr/lib
+ /usr/local/lib
+ /opt/local/lib
+ /opt/local/lib64
+ ${CMAKE_INSTALL_PREFIX}/lib
+)
+
+IF(GLUES_INCLUDE_DIR AND GLUES_LIBRARY)
+ SET( GLUES_FOUND TRUE )
+ SET( GLUES_LIBRARIES ${GLUES_LIBRARY} )
+ENDIF(GLUES_INCLUDE_DIR AND GLUES_LIBRARY)
+
+IF(GLUES_FOUND)
+ IF(NOT GLUES_FIND_QUIETLY)
+ MESSAGE(STATUS "Found GLUES: ${GLUES_LIBRARY}")
+ ENDIF(NOT GLUES_FIND_QUIETLY)
+ELSE(GLUES_FOUND)
+ IF(GLUES_FIND_REQUIRED)
+ MESSAGE(FATAL_ERROR "Could not find GLUES")
+ ENDIF(GLUES_FIND_REQUIRED)
+ENDIF(GLUES_FOUND)
+
diff --git a/CMakeModules/FindLibRealSense.cmake b/CMakeModules/FindLibRealSense.cmake
new file mode 100644
index 0000000..fc8982f
--- /dev/null
+++ b/CMakeModules/FindLibRealSense.cmake
@@ -0,0 +1,34 @@
+# -*- mode: cmake; -*-
+###############################################################################
+# Find librealsense https://github.com/IntelRealSense/librealsense
+#
+# This sets the following variables:
+# LIBREALSENSE_FOUND - True if OPENNI was found.
+# LIBREALSENSE_INCLUDE_DIRS - Directories containing the OPENNI include files.
+# LIBREALSENSE_LIBRARIES - Libraries needed to use OPENNI.
+# LIBREALSENSE_DEFINITIONS - Compiler flags for OPENNI.
+#
+# File forked from augmented_dev, project of alantrrs
+# (https://github.com/alantrrs/augmented_dev).
+
+find_package(PkgConfig)
+if(${CMAKE_VERSION} VERSION_LESS 2.8.2)
+endif()
+
+#add a hint so that it can find it without the pkg-config
+find_path(LIBREALSENSE_INCLUDE_DIR rs.h
+ HINTS /usr/include/ /usr/local/include
+ PATH_SUFFIXES librealsense)
+#add a hint so that it can find it without the pkg-config
+find_library(LIBREALSENSE_LIBRARY
+ NAMES librealsense.so
+ HINTS /usr/lib /usr/local/lib )
+
+ set(LIBREALSENSE_INCLUDE_DIRS ${LIBREALSENSE_INCLUDE_DIR})
+ set(LIBREALSENSE_LIBRARIES ${LIBREALSENSE_LIBRARY})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(LibRealSense DEFAULT_MSG
+ LIBREALSENSE_LIBRARY LIBREALSENSE_INCLUDE_DIR)
+
+mark_as_advanced(LIBREALSENSE_LIBRARY LIBREALSENSE_INCLUDE_DIR)
diff --git a/CMakeModules/FindMediaFoundation.cmake b/CMakeModules/FindMediaFoundation.cmake
new file mode 100644
index 0000000..107efa5
--- /dev/null
+++ b/CMakeModules/FindMediaFoundation.cmake
@@ -0,0 +1,20 @@
+# - Find MediaFoundation
+# Find the Windows SDK MediaFoundation libraries
+#
+# MediaFoundation_LIBRARIES - List of libraries when using MediaFoundation
+# MediaFoundation_FOUND - True if MediaFoundation found
+
+IF (MSVC)
+ SET( MediaFoundation_LIBRARIES mf.lib mfplat.lib mfreadwrite.lib mfuuid.lib strmiids.lib )
+ SET( MediaFoundation_FOUND true )
+ENDIF (MSVC)
+
+IF (MediaFoundation_FOUND)
+ IF (NOT MediaFoundation_FIND_QUIETLY)
+ MESSAGE(STATUS "Found MediaFoundation: ${MediaFoundation_LIBRARIES}")
+ ENDIF (NOT MediaFoundation FIND_QUIETLY)
+ELSE (MediaFoundation_FOUND)
+ IF (MediaFoundation_FIND_REQUIRED)
+ MESSAGE(FATAL_ERROR "Could not find MediaFoundation")
+ ENDIF (MediaFoundation_FIND_REQUIRED)
+ENDIF (MediaFoundation_FOUND)
diff --git a/CMakeModules/FindOculus.cmake b/CMakeModules/FindOculus.cmake
new file mode 100644
index 0000000..0408162
--- /dev/null
+++ b/CMakeModules/FindOculus.cmake
@@ -0,0 +1,63 @@
+# - Try to find Oculus Rift SDK
+#
+# Oculus_FOUND - system has libuvc
+# Oculus_INCLUDE_DIRS - the libuvc include directories
+# Oculus_LIBRARIES - link these to use libuvc
+
+FIND_PATH(
+ Oculus_INCLUDE_DIRS
+ NAMES OVR.h
+ PATHS
+ ${CMAKE_SOURCE_DIR}/../LibOVR/Include
+ ${CMAKE_SOURCE_DIR}/../OculusSDK/LibOVR/Include
+ /usr/include/LibOVR/Include
+ /usr/local/include/LibOVR/Include
+ /opt/local/include/LibOVR/Include
+ /usr/include/
+ /usr/local/include
+ /opt/local/include
+)
+
+FIND_LIBRARY(
+ Oculus_LIBRARIES
+ NAMES ovr
+ PATHS
+ ${CMAKE_SOURCE_DIR}/../LibOVR/Lib/MacOS/Release
+ ${CMAKE_SOURCE_DIR}/../OculusSDK/LibOVR/Lib/Linux/Release/x86_64
+ /usr/include/LibOVR/Lib
+ /usr/local/include/LibOVR/Lib
+ /opt/local/include/LibOVR/Lib
+ /usr/lib
+ /usr/local/lib
+ /opt/local/lib
+)
+
+IF(Oculus_INCLUDE_DIRS AND Oculus_LIBRARIES)
+ IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+ find_library(CARBON_LIBRARIES NAMES Carbon)
+ find_library(IOKIT_LIBRARIES NAMES IOKit)
+ list(APPEND Oculus_LIBRARIES ${CARBON_LIBRARIES})
+ list(APPEND Oculus_LIBRARIES ${IOKIT_LIBRARIES})
+ SET(Oculus_FOUND TRUE)
+ ELSEIF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+ FIND_PACKAGE(Xrandr QUIET)
+ IF( Xrandr_FOUND )
+ list(APPEND Oculus_LIBRARIES ${Xrandr_LIBRARIES} -ludev -lXrandr -lXinerama )
+ SET(Oculus_FOUND TRUE)
+ ENDIF()
+ ENDIF()
+ENDIF(Oculus_INCLUDE_DIRS AND Oculus_LIBRARIES)
+
+
+
+IF(Oculus_FOUND)
+ IF(NOT Oculus_FIND_QUIETLY)
+ MESSAGE(STATUS "Found Oculus: ${Oculus_LIBRARIES}")
+ MESSAGE(STATUS "Found Oculus: ${Oculus_INCLUDE_DIRS}")
+ ENDIF(NOT Oculus_FIND_QUIETLY)
+ELSE(Oculus_FOUND)
+message(STATUS "Oculus NOT found")
+ IF(Oculus_FIND_REQUIRED)
+ MESSAGE(FATAL_ERROR "Could not find Oculus")
+ ENDIF(Oculus_FIND_REQUIRED)
+ENDIF(Oculus_FOUND)
diff --git a/CMakeModules/FindOpenEXR.cmake b/CMakeModules/FindOpenEXR.cmake
new file mode 100644
index 0000000..f4f5d8a
--- /dev/null
+++ b/CMakeModules/FindOpenEXR.cmake
@@ -0,0 +1,33 @@
+# Try to find the OpenEXR v2 lib and include files
+#
+# OpenEXR_INCLUDE_DIR
+# OpenEXR_LIBRARIES
+# OpenEXR_FOUND
+
+FIND_PATH( OpenEXR_INCLUDE_DIR ImfHeader.h
+ /usr/include
+ /usr/local/include
+ PATH_SUFFIXES OpenEXR
+)
+
+FIND_LIBRARY( OpenEXR_LIBRARY IlmImf
+ /usr/lib64
+ /usr/lib
+ /usr/local/lib
+)
+
+IF(OpenEXR_INCLUDE_DIR AND OpenEXR_LIBRARY)
+ SET( OpenEXR_FOUND TRUE )
+ SET( OpenEXR_LIBRARIES ${OpenEXR_LIBRARY} )
+ENDIF()
+
+IF(OpenEXR_FOUND)
+ IF(NOT OpenEXR_FIND_QUIETLY)
+ MESSAGE(STATUS "Found OpenEXR: ${OpenEXR_LIBRARY}")
+ ENDIF(NOT OpenEXR_FIND_QUIETLY)
+ELSE(OpenEXR_FOUND)
+ IF(OpenEXR_FIND_REQUIRED)
+ MESSAGE(FATAL_ERROR "Could not find libOpenEXR")
+ ENDIF(OpenEXR_FIND_REQUIRED)
+ENDIF(OpenEXR_FOUND)
+
diff --git a/CMakeModules/FindOpenNI.cmake b/CMakeModules/FindOpenNI.cmake
new file mode 100644
index 0000000..b5e9d9c
--- /dev/null
+++ b/CMakeModules/FindOpenNI.cmake
@@ -0,0 +1,49 @@
+# -*- mode: cmake; -*-
+###############################################################################
+# Find OpenNI
+#
+# This sets the following variables:
+# OPENNI_FOUND - True if OPENNI was found.
+# OPENNI_INCLUDE_DIRS - Directories containing the OPENNI include files.
+# OPENNI_LIBRARIES - Libraries needed to use OPENNI.
+# OPENNI_DEFINITIONS - Compiler flags for OPENNI.
+#
+# File forked from augmented_dev, project of alantrrs
+# (https://github.com/alantrrs/augmented_dev).
+
+find_package(PkgConfig)
+if(${CMAKE_VERSION} VERSION_LESS 2.8.2)
+ pkg_check_modules(PC_OPENNI openni-dev)
+else()
+ pkg_check_modules(PC_OPENNI QUIET openni-dev)
+endif()
+
+set(OPENNI_DEFINITIONS ${PC_OPENNI_CFLAGS_OTHER})
+
+#using the 64bit version of OpenNi if generating for 64bit
+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+ set(PROGRAMFILES_ "$ENV{PROGRAMW6432}")
+ set(OPENNI_SUFFIX "64")
+else(CMAKE_SIZEOF_VOID_P EQUAL 8)
+ set(PROGRAMFILES_ "$ENV{PROGRAMFILES}")
+ set(OPENNI_SUFFIX "")
+endif(CMAKE_SIZEOF_VOID_P EQUAL 8)
+
+#add a hint so that it can find it without the pkg-config
+find_path(OPENNI_INCLUDE_DIR XnStatus.h
+ HINTS ${PC_OPENNI_INCLUDEDIR} ${PC_OPENNI_INCLUDE_DIRS} /usr/include/ni /usr/include/openni
+ "${PROGRAMFILES_}/OpenNI/Include"
+ PATH_SUFFIXES openni)
+#add a hint so that it can find it without the pkg-config
+find_library(OPENNI_LIBRARY
+ NAMES OpenNI64 OpenNI
+ HINTS ${PC_OPENNI_LIBDIR} ${PC_OPENNI_LIBRARY_DIRS} /usr/lib "${PROGRAMFILES_}/OpenNI/Lib${OPENNI_SUFFIX}")
+
+set(OPENNI_INCLUDE_DIRS ${OPENNI_INCLUDE_DIR})
+set(OPENNI_LIBRARIES ${OPENNI_LIBRARY})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(OpenNI DEFAULT_MSG
+ OPENNI_LIBRARY OPENNI_INCLUDE_DIR)
+
+mark_as_advanced(OPENNI_LIBRARY OPENNI_INCLUDE_DIR)
diff --git a/CMakeModules/FindOpenNI2.cmake b/CMakeModules/FindOpenNI2.cmake
new file mode 100644
index 0000000..2beb7aa
--- /dev/null
+++ b/CMakeModules/FindOpenNI2.cmake
@@ -0,0 +1,59 @@
+###############################################################################
+# Find OpenNI2
+#
+# This sets the following variables:
+# OPENNI2_FOUND - True if OPENNI was found.
+# OPENNI2_INCLUDE_DIRS - Directories containing the OPENNI include files.
+# OPENNI2_LIBRARIES - Libraries needed to use OPENNI.
+
+find_package(PkgConfig)
+if(${CMAKE_VERSION} VERSION_LESS 2.8.2)
+ pkg_check_modules(PC_OPENNI openni2-dev)
+else()
+ pkg_check_modules(PC_OPENNI QUIET openni2-dev)
+endif()
+
+set(OPENNI2_DEFINITIONS ${PC_OPENNI_CFLAGS_OTHER})
+
+#add a hint so that it can find it without the pkg-config
+find_path(OPENNI2_INCLUDE_DIR OpenNI.h
+ HINTS
+ ${PC_OPENNI_INCLUDEDIR}
+ ${PC_OPENNI_INCLUDE_DIRS}
+ PATHS
+ "${PROGRAM_FILES}/OpenNI2/Include"
+ "${CMAKE_SOURCE_DIR}/../OpenNI2/Include"
+ /usr/include
+ /user/include
+ PATH_SUFFIXES openni2 ni2
+)
+
+if(${CMAKE_CL_64})
+ set(OPENNI_PATH_SUFFIXES lib64 lib)
+else()
+ set(OPENNI_PATH_SUFFIXES lib)
+endif()
+
+#add a hint so that it can find it without the pkg-config
+find_library(OPENNI2_LIBRARY
+ NAMES OpenNI2
+ HINTS
+ ${PC_OPENNI_LIBDIR}
+ ${PC_OPENNI_LIBRARY_DIRS}
+ PATHS
+ "${PROGRAM_FILES}/OpenNI2/Redist"
+ "${PROGRAM_FILES}/OpenNI2"
+ "${CMAKE_SOURCE_DIR}/../OpenNI2/Bin/x64-Release"
+ /usr/lib
+ /user/lib
+ PATH_SUFFIXES ${OPENNI_PATH_SUFFIXES}
+)
+
+set(OPENNI2_INCLUDE_DIRS ${OPENNI2_INCLUDE_DIR})
+set(OPENNI2_LIBRARIES ${OPENNI2_LIBRARY})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(OpenNI2 DEFAULT_MSG
+ OPENNI2_LIBRARY OPENNI2_INCLUDE_DIR)
+
+mark_as_advanced(OPENNI2_LIBRARY OPENNI2_INCLUDE_DIR)
diff --git a/CMakeModules/FindPleora.cmake b/CMakeModules/FindPleora.cmake
new file mode 100644
index 0000000..6a4a94d
--- /dev/null
+++ b/CMakeModules/FindPleora.cmake
@@ -0,0 +1,143 @@
+# - Try to find Pleora SDK
+#
+# Pleora_FOUND - system has pleora eUSB SDK
+# Pleora_INCLUDE_DIRS - the pleora eUSB SDK include directories
+# Pleora_LIBRARIES - link these to use pleora eUSB SDK
+# Pleora_BASE_DIR - set env varivales to this to use pleora eUSB SDK
+
+set( INCLUDE_SEARCH_PATHS
+ "/opt/pleora/ebus_sdk/Ubuntu-12.04-x86_64/include"
+ "/opt/pleora/ebus_sdk/Ubuntu-14.04-x86_64/include"
+ "$ENV{ProgramFiles}/Pleora Technologies Inc/eBUS SDK/Includes"
+)
+
+set( LIBRARIES_SEARCH_PATHS
+ "/opt/pleora/ebus_sdk/Ubuntu-12.04-x86_64/lib"
+ "/opt/pleora/ebus_sdk/Ubuntu-14.04-x86_64/lib"
+ "$ENV{ProgramFiles}/Pleora Technologies Inc/eBUS SDK/Libraries"
+)
+
+set( GENAPI_SEARCH_PATHS
+ "/opt/pleora/ebus_sdk/Ubuntu-12.04-x86_64/lib/genicam/bin/Linux64_x64"
+ "/opt/pleora/ebus_sdk/Ubuntu-12.04-x86_64/lib/genicam/bin/Linux32_ARM"
+ "/opt/pleora/ebus_sdk/Ubuntu-14.04-x86_64/lib/genicam/bin/Linux64_x64"
+ "/opt/pleora/ebus_sdk/Ubuntu-14.04-x86_64/lib/genicam/bin/Linux32_ARM"
+ "$ENV{ProgramW6432}/GenICam_v2_4/library/CPP/lib/Win64_x64"
+)
+
+IF (${CMAKE_CL_64})
+ set (LIB_NAME_SUFFIX "64")
+ELSE()
+ set (LIB_NAME_SUFFIX "")
+ENDIF()
+
+# Find header files
+FIND_PATH(
+ PVBASE_INCLUDE_DIR PvBase.h
+ HINTS ${PC_PLEORA_DIR}/include
+ PATHS ${INCLUDE_SEARCH_PATHS}
+)
+FIND_PATH(
+ PVDEVICE_INCLUDE_DIR PvDevice.h
+ HINTS ${PC_PLEORA_DIR}/include
+ PATHS ${INCLUDE_SEARCH_PATHS}
+)
+FIND_PATH(
+ PVBUFFER_INCLUDE_DIR PvBuffer.h
+ HINTS ${PC_PLEORA_DIR}/include
+ PATHS ${INCLUDE_SEARCH_PATHS}
+)
+FIND_PATH(
+ PVGENICAM_INCLUDE_DIR PvGenICamLib.h
+ HINTS ${PC_PLEORA_DIR}/include
+ PATHS ${INCLUDE_SEARCH_PATHS}
+)
+FIND_PATH(
+ PVSTREAM_INCLUDE_DIR PvStream.h
+ HINTS ${PC_PLEORA_DIR}/include
+ PATHS ${INCLUDE_SEARCH_PATHS}
+)
+FIND_PATH(
+ PVTRANSMITTER_INCLUDE_DIR PvTransmitterLib.h
+ HINTS ${PC_PLEORA_DIR}/include
+ PATHS ${INCLUDE_SEARCH_PATHS}
+)
+FIND_PATH(
+ PVVIRTUALDEVICE_INCLUDE_DIR PvVirtualDeviceLib.h
+ HINTS ${PC_PLEORA_DIR}/include
+ PATHS ${INCLUDE_SEARCH_PATHS}
+)
+FIND_PATH(
+ PVSAMPLEUTILS_INCLUDE_DIR PvSampleUtils.h
+ HINTS ${PC_PLEORA_DIR}/include
+ PATHS ${INCLUDE_SEARCH_PATHS}
+)
+
+# Find Library files
+FIND_LIBRARY(
+ PVBASE_LIBRARY
+ NAMES "PvBase${LIB_NAME_SUFFIX}"
+ HINTS ${PC_PLEORA_DIR}/lib
+ PATH ${LIBRARIES_SEARCH_PATHS}
+)
+FIND_LIBRARY(
+ PVDEVICE_LIBRARY
+ NAMES "PvDevice${LIB_NAME_SUFFIX}"
+ HINTS ${PC_PLEORA_DIR}/lib
+ PATH ${LIBRARIES_SEARCH_PATHS}
+)
+
+FIND_LIBRARY(
+ PVBUFFER_LIBRARY
+ NAMES "PvBuffer${LIB_NAME_SUFFIX}"
+ HINTS ${PC_PLEORA_DIR}/lib
+ PATH ${LIBRARIES_SEARCH_PATHS}
+)
+FIND_LIBRARY(
+ PVGENICAM_LIBRARY
+ NAMES "PvGenICam${LIB_NAME_SUFFIX}"
+ HINTS ${PC_PLEORA_DIR}/lib
+ PATH ${LIBRARIES_SEARCH_PATHS}
+)
+FIND_LIBRARY(
+ PVSTREAM_LIBRARY
+ NAMES "PvStream${LIB_NAME_SUFFIX}"
+ HINTS ${PC_PLEORA_DIR}/lib
+ PATH ${LIBRARIES_SEARCH_PATHS}
+)
+FIND_LIBRARY(
+ PVTRANSMITTER_LIBRARY
+ NAMES "PvTransmitter${LIB_NAME_SUFFIX}"
+ HINTS ${PC_PLEORA_DIR}/lib
+ PATH ${LIBRARIES_SEARCH_PATHS}
+)
+FIND_LIBRARY(
+ PVVIRTUALDEVICE_LIBRARY
+ NAMES "PvVirtualDevice${LIB_NAME_SUFFIX}"
+ HINTS ${PC_PLEORA_DIR}/lib
+ PATH ${LIBRARIES_SEARCH_PATHS}
+)
+FIND_LIBRARY(
+ GENAPI_LIBRARY
+ NAMES GenApi_gcc40_v2_4 GenApi_gcc43_v2_4 GenApi_MD_VC80_v2_4
+ HINTS ${PC_GENAPI_LIBRARY_DIR}
+ PATH ${GENAPI_SEARCH_PATHS}
+)
+
+IF(PVBASE_INCLUDE_DIR AND PVDEVICE_INCLUDE_DIR AND PVBUFFER_INCLUDE_DIR AND PVGENICAM_INCLUDE_DIR AND PVSTREAM_INCLUDE_DIR AND PVTRANSMITTER_INCLUDE_DIR AND PVVIRTUALDEVICE_INCLUDE_DIR AND PVSAMPLEUTILS_INCLUDE_DIR AND PVBASE_LIBRARY AND PVDEVICE_LIBRARY AND PVBUFFER_LIBRARY AND PVGENICAM_LIBRARY AND PVSTREAM_LIBRARY AND PVTRANSMITTER_LIBRARY AND PVVIRTUALDEVICE_LIBRARY AND GENAPI_LIBRARY)
+ SET(Pleora_FOUND TRUE)
+ string(REGEX REPLACE "include$" "" Pleora_BASE_DIR ${PVBASE_INCLUDE_DIR})
+ SET(Pleora_LIBRARIES ${PVBASE_LIBRARY} ${PVDEVICE_LIBRARY} ${PVBUFFER_LIBRARY} ${PVGENICAM_LIBRARY} ${PVSTREAM_LIBRARY} ${PVTRANSMITTER_LIBRARY} ${PVVIRTUALDEVICE_LIBRARY} ${GENAPI_LIBRARY})
+ SET(Pleora_INCLUDE_DIRS ${PVBASE_INCLUDE_DIR} ${PVDEVICE_INCLUDE_DIR} ${PVBUFFER_INCLUDE_DIR} ${PVGENICAM_INCLUDE_DIR} ${PVSTREAM_INCLUDE_DIR} ${PVTRANSMITTER_INCLUDE_DIR} ${PVVIRTUALDEVICE_INCLUDE_DIR} ${PVSAMPLEUTILS_INCLUDE_DIR})
+ENDIF()
+
+
+IF (Pleora_FOUND)
+ IF (NOT Pleora_FIND_QUIETLY)
+ message(STATUS "Found Pleora: ${Pleora_LIBRARIES}")
+ ENDIF (NOT Pleora_FIND_QUIETLY)
+ELSE (Pleora_FOUND)
+ IF (Pleora_FIND_REQUIRED)
+ message(FATAL_ERROR "Could not find Pleora")
+ ENDIF (Pleora_FIND_REQUIRED)
+ENDIF (Pleora_FOUND)
diff --git a/CMakeModules/FindROBOTVISION.cmake b/CMakeModules/FindROBOTVISION.cmake
new file mode 100644
index 0000000..ea600d1
--- /dev/null
+++ b/CMakeModules/FindROBOTVISION.cmake
@@ -0,0 +1,31 @@
+# - Try to find librobotvision
+#
+# ROBOTVISION_FOUND - system has librobotvision
+# ROBOTVISION_INCLUDE_DIR - the librobotvision include directories
+# ROBOTVISION_LIBRARY - link these to use librobotvision
+
+FIND_PATH(
+ ROBOTVISION_INCLUDE_DIR
+ NAMES robotvision/bundle_adjuster.h
+ PATHS ${CMAKE_SOURCE_DIR}/.. /usr/include/robotvision /usr/local/include/robotvision
+)
+
+FIND_LIBRARY(
+ ROBOTVISION_LIBRARY
+ NAMES robotvision
+ PATHS ${CMAKE_SOURCE_DIR}/../robotvision/release /usr/lib /usr/local/lib
+)
+
+IF (ROBOTVISION_INCLUDE_DIR AND ROBOTVISION_LIBRARY)
+ SET(ROBOTVISION_FOUND TRUE)
+ENDIF (ROBOTVISION_INCLUDE_DIR AND ROBOTVISION_LIBRARY)
+
+IF (ROBOTVISION_FOUND)
+ IF (NOT ROBOTVISION_FIND_QUIETLY)
+ MESSAGE(STATUS "Found ROBOTVISION: ${ROBOTVISION_LIBRARY}")
+ ENDIF (NOT ROBOTVISION_FIND_QUIETLY)
+ELSE (ROBOTVISION_FOUND)
+ IF (ROBOTVISION_FIND_REQUIRED)
+ MESSAGE(FATAL_ERROR "Could not find ROBOTVISION")
+ ENDIF (ROBOTVISION_FIND_REQUIRED)
+ENDIF (ROBOTVISION_FOUND)
diff --git a/CMakeModules/FindTeliCam.cmake b/CMakeModules/FindTeliCam.cmake
new file mode 100644
index 0000000..d2f7032
--- /dev/null
+++ b/CMakeModules/FindTeliCam.cmake
@@ -0,0 +1,58 @@
+###############################################################################
+# Find Toshiba TeliCam
+#
+# This sets the following variables:
+# TeliCam_FOUND - True if TeliCam was found.
+# TeliCam_INCLUDE_DIRS - Directories containing the TeliCam include files.
+# TeliCam_LIBRARIES - Libraries needed to use TeliCam.
+
+find_path(
+ TeliCam_INCLUDE_DIR TeliCamApi.h
+ PATHS
+ "${PROGRAM_FILES}/Toshiba Teli/TeliCamSDK/TeliCamApi/Include"
+ "${CMAKE_SOURCE_DIR}/../TeliCamSDK/TeliCamApi/Include"
+ /usr/include
+ /user/include
+ /opt/TeliCamSDK/include
+ PATH_SUFFIXES TeliCam
+)
+
+if(${CMAKE_CL_64})
+ set(TELI_PATH_SUFFIXES x64)
+else()
+ set(TELI_PATH_SUFFIXES x86)
+endif()
+
+find_library(
+ TeliCamApi_LIBRARY
+ NAMES TeliCamApi TeliCamApi64 TeliCamApi_64
+ PATHS
+ "${PROGRAM_FILES}/Toshiba Teli/TeliCamSDK/TeliCamApi/lib"
+ "${CMAKE_SOURCE_DIR}/../TeliCamSDK/TeliCamApi/lib"
+ /usr/lib
+ /user/lib
+ /opt/TeliCamSDK/lib
+ PATH_SUFFIXES ${TELI_PATH_SUFFIXES}
+)
+
+find_library(
+ TeliCamUtl_LIBRARY
+ NAMES TeliCamUtl TeliCamUtl64 TeliCamUtl_64
+ PATHS
+ "${PROGRAM_FILES}/Toshiba Teli/TeliCamSDK/TeliCamApi/lib"
+ "${CMAKE_SOURCE_DIR}/../TeliCamSDK/TeliCamApi/lib"
+ /usr/lib
+ /user/lib
+ /opt/TeliCamSDK/lib
+ PATH_SUFFIXES ${TELI_PATH_SUFFIXES}
+)
+
+set(TeliCam_INCLUDE_DIRS ${TeliCam_INCLUDE_DIR})
+set(TeliCam_LIBRARY "${TeliCamApi_LIBRARY}" "${TeliCamUtl_LIBRARY}")
+set(TeliCam_LIBRARIES ${TeliCam_LIBRARY})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args( TeliCam
+ FOUND_VAR TeliCam_FOUND
+ REQUIRED_VARS TeliCamApi_LIBRARY TeliCamUtl_LIBRARY TeliCam_INCLUDE_DIR
+)
diff --git a/CMakeModules/FindTooN.cmake b/CMakeModules/FindTooN.cmake
new file mode 100644
index 0000000..13ce3d5
--- /dev/null
+++ b/CMakeModules/FindTooN.cmake
@@ -0,0 +1,28 @@
+# - Try to find libTooN
+#
+# TooN_FOUND - system has libTooN
+# TooN_INCLUDE_DIR - the libTooN include directories
+
+FIND_PATH(
+ TooN_INCLUDE_DIR
+ NAMES TooN/TooN.h
+ PATHS
+ ${CMAKE_SOURCE_DIR}
+ ${CMAKE_SOURCE_DIR}/..
+ /usr/include
+ /usr/local/include
+)
+
+IF(TooN_INCLUDE_DIR)
+ SET(TooN_FOUND TRUE)
+ENDIF()
+
+IF(TooN_FOUND)
+ IF(NOT TooN_FIND_QUIETLY)
+ MESSAGE(STATUS "Found TooN: ${TooN_INCLUDE_DIR}")
+ ENDIF()
+ELSE()
+ IF(TooN_FIND_REQUIRED)
+ MESSAGE(FATAL_ERROR "Could not find TooN")
+ ENDIF()
+ENDIF()
diff --git a/CMakeModules/FindXrandr.cmake b/CMakeModules/FindXrandr.cmake
new file mode 100644
index 0000000..0ec8440
--- /dev/null
+++ b/CMakeModules/FindXrandr.cmake
@@ -0,0 +1,32 @@
+# - Try to find Xrandr
+#
+# Xrandr_FOUND - system has libXrandr
+# Xrandr_INCLUDE_DIRS - the libXrandr include directories
+# Xrandr_LIBRARIES - link these to use libXrandr
+
+FIND_PATH(
+ Xrandr_INCLUDE_DIRS
+ NAMES X11/extensions/Xrandr.h
+ PATH_SUFFIXES X11/extensions
+ DOC "The Xrandr include directory"
+)
+
+FIND_LIBRARY(
+ Xrandr_LIBRARIES
+ NAMES Xrandr
+ DOC "The Xrandr library"
+)
+
+IF (Xrandr_INCLUDE_DIRS AND Xrandr_LIBRARIES)
+ SET(Xrandr_FOUND TRUE)
+ENDIF (Xrandr_INCLUDE_DIRS AND Xrandr_LIBRARIES)
+
+IF (Xrandr_FOUND)
+ IF (NOT Xrandr_FIND_QUIETLY)
+ MESSAGE(STATUS "Found Xrandr: ${Xrandr_LIBRARIES}")
+ ENDIF (NOT Xrandr_FIND_QUIETLY)
+ELSE (Xrandr_FOUND)
+ IF (Xrandr_FIND_REQUIRED)
+ MESSAGE(FATAL_ERROR "Could not find Xrandr")
+ ENDIF (Xrandr_FIND_REQUIRED)
+ENDIF (Xrandr_FOUND)
diff --git a/CMakeModules/Findlibusb1.cmake b/CMakeModules/Findlibusb1.cmake
new file mode 100644
index 0000000..a208728
--- /dev/null
+++ b/CMakeModules/Findlibusb1.cmake
@@ -0,0 +1,42 @@
+# - Try to find libusb1
+#
+# libusb1_FOUND - system has libusb1
+# libusb1_INCLUDE_DIRS - the libusb1 include directories
+# libusb1_LIBRARIES - link these to use libusb1
+
+FIND_PATH(
+ libusb1_INCLUDE_DIRS
+ NAMES libusb-1.0/libusb.h
+ PATHS
+ c:/dev/sysroot32/usr/include
+ ${CMAKE_SOURCE_DIR}/../libusb1/include
+ /usr/include/
+ /usr/local/include
+ /opt/local/include
+)
+
+FIND_LIBRARY(
+ libusb1_LIBRARIES
+ NAMES libusb-1.0
+ PATHS
+ c:/dev/sysroot32/usr/lib
+ ${CMAKE_SOURCE_DIR}/../libusb1/lib
+ /usr/lib
+ /usr/local/lib
+ /opt/local/lib
+)
+
+IF(libusb1_INCLUDE_DIRS AND libusb1_LIBRARIES)
+ SET(libusb1_FOUND TRUE)
+ENDIF(libusb1_INCLUDE_DIRS AND libusb1_LIBRARIES)
+
+IF(libusb1_FOUND)
+ IF(NOT libusb1_FIND_QUIETLY)
+ MESSAGE(STATUS "Found libusb1: ${libusb1_LIBRARIES}")
+ ENDIF(NOT libusb1_FIND_QUIETLY)
+ELSE(libusb1_FOUND)
+message(STATUS "libusb1 NOT found")
+ IF(libusb1_FIND_REQUIRED)
+ MESSAGE(FATAL_ERROR "Could not find libusb1")
+ ENDIF(libusb1_FIND_REQUIRED)
+ENDIF(libusb1_FOUND)
diff --git a/CMakeModules/Findpthread.cmake b/CMakeModules/Findpthread.cmake
new file mode 100644
index 0000000..40a76f2
--- /dev/null
+++ b/CMakeModules/Findpthread.cmake
@@ -0,0 +1,42 @@
+# - Try to find pthread
+#
+# pthread_FOUND - system has pthread
+# pthread_INCLUDE_DIRS - the pthread include directories
+# pthread_LIBRARIES - link these to use pthread
+
+FIND_PATH(
+ pthread_INCLUDE_DIRS
+ NAMES pthread.h
+ PATHS
+ c:/dev/sysroot32/usr/include
+ ${CMAKE_SOURCE_DIR}/../pthread/include
+ /usr/include/
+ /usr/local/include
+ /opt/local/include
+)
+
+FIND_LIBRARY(
+ pthread_LIBRARIES
+ NAMES pthreadVSE2 pthread
+ PATHS
+ c:/dev/sysroot32/usr/lib
+ ${CMAKE_SOURCE_DIR}/../pthread/lib
+ /usr/lib
+ /usr/local/lib
+ /opt/local/lib
+)
+
+IF(pthread_INCLUDE_DIRS AND pthread_LIBRARIES)
+ SET(pthread_FOUND TRUE)
+ENDIF(pthread_INCLUDE_DIRS AND pthread_LIBRARIES)
+
+IF(pthread_FOUND)
+ IF(NOT pthread_FIND_QUIETLY)
+ MESSAGE(STATUS "Found pthread: ${pthread_LIBRARIES}")
+ ENDIF(NOT pthread_FIND_QUIETLY)
+ELSE(pthread_FOUND)
+message(STATUS "pthread NOT found")
+ IF(pthread_FIND_REQUIRED)
+ MESSAGE(FATAL_ERROR "Could not find pthread")
+ ENDIF(pthread_FIND_REQUIRED)
+ENDIF(pthread_FOUND)
diff --git a/CMakeModules/Finduvc.cmake b/CMakeModules/Finduvc.cmake
new file mode 100644
index 0000000..fefe72f
--- /dev/null
+++ b/CMakeModules/Finduvc.cmake
@@ -0,0 +1,39 @@
+# - Try to find uvc
+#
+# uvc_FOUND - system has libuvc
+# uvc_INCLUDE_DIRS - the libuvc include directories
+# uvc_LIBRARIES - link these to use libuvc
+
+FIND_PATH(
+ uvc_INCLUDE_DIRS
+ NAMES libuvc/libuvc.h
+ PATHS
+ ${CMAKE_SOURCE_DIR}/..
+ /usr/include/
+ /usr/local/include
+ /opt/local/include
+)
+
+FIND_LIBRARY(
+ uvc_LIBRARIES
+ NAMES uvc
+ PATHS
+ ${CMAKE_SOURCE_DIR}/../uvc/build
+ /usr/lib
+ /usr/local/lib
+ /opt/local/lib
+)
+
+IF (uvc_INCLUDE_DIRS AND uvc_LIBRARIES)
+ SET(uvc_FOUND TRUE)
+ENDIF (uvc_INCLUDE_DIRS AND uvc_LIBRARIES)
+
+IF (uvc_FOUND)
+ IF (NOT uvc_FIND_QUIETLY)
+ MESSAGE(STATUS "Found uvc: ${uvc_LIBRARIES}")
+ ENDIF (NOT uvc_FIND_QUIETLY)
+ELSE (uvc_FOUND)
+ IF (uvc_FIND_REQUIRED)
+ MESSAGE(FATAL_ERROR "Could not find uvc")
+ ENDIF (uvc_FIND_REQUIRED)
+ENDIF (uvc_FOUND)
diff --git a/CMakeModules/Findzstd.cmake b/CMakeModules/Findzstd.cmake
new file mode 100644
index 0000000..f4faabb
--- /dev/null
+++ b/CMakeModules/Findzstd.cmake
@@ -0,0 +1,35 @@
+###############################################################################
+# Find Toshiba TeliCam
+#
+# This sets the following variables:
+# TeliCam_FOUND - True if TeliCam was found.
+# TeliCam_INCLUDE_DIRS - Directories containing the TeliCam include files.
+# TeliCam_LIBRARIES - Libraries needed to use TeliCam.
+
+find_path(
+ zstd_INCLUDE_DIR zstd.h
+ PATHS
+ /opt/local/include
+ /usr/local/include
+ /usr/include
+ PATH_SUFFIXES TeliCam
+)
+
+find_library(
+ zstd_LIBRARY
+ NAMES zstd
+ PATHS
+ /opt/local/lib
+ /user/local/lib
+ /usr/lib
+)
+
+# Plural forms
+set(zstd_INCLUDE_DIRS ${zstd_INCLUDE_DIR})
+set(zstd_LIBRARIES ${zstd_LIBRARY})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args( zstd
+ FOUND_VAR zstd_FOUND
+ REQUIRED_VARS zstd_INCLUDE_DIR zstd_LIBRARY
+)
diff --git a/CMakeModules/SetPlatformVars.cmake b/CMakeModules/SetPlatformVars.cmake
new file mode 100644
index 0000000..a07b35a
--- /dev/null
+++ b/CMakeModules/SetPlatformVars.cmake
@@ -0,0 +1,56 @@
+## Compiler configuration
+IF(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_GNUCC)
+ SET(_GCC_ 1)
+ENDIF()
+
+IF(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
+ SET(_CLANG_ 1)
+ENDIF()
+
+IF(MSVC)
+ SET(_MSVC_ 1)
+ENDIF()
+
+## Platform configuration
+
+IF(WIN32 OR WIN64)
+ SET(_WIN_ 1)
+ENDIF()
+
+IF(UNIX)
+ SET(_UNIX_ 1)
+ENDIF()
+
+IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+ SET(_OSX_ 1)
+ENDIF()
+
+IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+ SET(_LINUX_ 1)
+ENDIF()
+
+IF(ANDROID)
+ SET(_ANDROID_ 1)
+ENDIF()
+
+IF(IOS)
+ SET(_APPLE_IOS_ 1)
+ENDIF()
+
+
+
+## Default search paths
+
+IF(_WIN_)
+ IF(${CMAKE_CL_64})
+ LIST(APPEND CMAKE_INCLUDE_PATH "c:/dev/sysroot64/usr/include")
+ LIST(APPEND CMAKE_LIBRARY_PATH "c:/dev/sysroot64/usr/lib")
+ LIST(APPEND CMAKE_LIBRARY_PATH "c:/dev/sysroot64/usr/bin")
+ set(PROGRAM_FILES "$ENV{PROGRAMW6432}" )
+ ELSE()
+ LIST(APPEND CMAKE_INCLUDE_PATH "c:/dev/sysroot32/usr/include")
+ LIST(APPEND CMAKE_LIBRARY_PATH "c:/dev/sysroot32/usr/lib")
+ LIST(APPEND CMAKE_LIBRARY_PATH "c:/dev/sysroot32/usr/bin")
+ set(PROGRAM_FILES "$ENV{PROGRAMFILES}" )
+ ENDIF()
+ENDIF()
diff --git a/LICENCE b/LICENCE
new file mode 100644
index 0000000..9b7376c
--- /dev/null
+++ b/LICENCE
@@ -0,0 +1,22 @@
+Copyright (c) 2011 Steven Lovegrove and Richard Newcombe
+
+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.
diff --git a/cmake_uninstall.cmake.in b/cmake_uninstall.cmake.in
new file mode 100644
index 0000000..6dc0777
--- /dev/null
+++ b/cmake_uninstall.cmake.in
@@ -0,0 +1,25 @@
+# -----------------------------------------------
+# File that provides "make uninstall" target
+# We use the file 'install_manifest.txt'
+# -----------------------------------------------
+IF(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
+ MESSAGE(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_BINARY_DIR@/install_manifest.txt\"")
+ENDIF(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt")
+
+FILE(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files)
+STRING(REGEX REPLACE "\n" ";" files "${files}")
+FOREACH(file ${files})
+ MESSAGE(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"")
+ IF(EXISTS "$ENV{DESTDIR}${file}")
+ EXEC_PROGRAM(
+ "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
+ OUTPUT_VARIABLE rm_out
+ RETURN_VALUE rm_retval
+ )
+ IF(NOT "${rm_retval}" STREQUAL 0)
+ MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"")
+ ENDIF(NOT "${rm_retval}" STREQUAL 0)
+ ELSE(EXISTS "$ENV{DESTDIR}${file}")
+ MESSAGE(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.")
+ ENDIF(EXISTS "$ENV{DESTDIR}${file}")
+ENDFOREACH(file)
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
new file mode 100644
index 0000000..1b81a80
--- /dev/null
+++ b/examples/CMakeLists.txt
@@ -0,0 +1,31 @@
+# All examples depend on Pangolin GUI
+if(BUILD_PANGOLIN_GUI)
+ add_subdirectory(HelloPangolin)
+ add_subdirectory(SimpleMultiDisplay)
+ add_subdirectory(SimpleDisplayImage)
+ add_subdirectory(SimpleScene)
+
+ if(NOT HAVE_GLES OR HAVE_GLES_2)
+ add_subdirectory(SimplePlot)
+ endif()
+
+ ## These samples require Pangolin Var support
+ if(BUILD_PANGOLIN_VARS)
+ add_subdirectory(SimpleDisplay)
+
+ ## Video Samples require Pangolin Video support
+ if(BUILD_PANGOLIN_VIDEO)
+ add_subdirectory(SimpleVideo)
+ add_subdirectory(SimpleRecord)
+ add_subdirectory(SharedMemoryCamera)
+ endif()
+
+# # This sample fails on many platforms, so exclude it for now,
+# # until we can create a better cmake test for support.
+# find_package(CUDA QUIET)
+# if( CUDA_FOUND )
+# add_subdirectory(VBODisplay)
+# endif()
+
+ endif()
+endif()
diff --git a/examples/HelloPangolin/CMakeLists.txt b/examples/HelloPangolin/CMakeLists.txt
new file mode 100644
index 0000000..f37389a
--- /dev/null
+++ b/examples/HelloPangolin/CMakeLists.txt
@@ -0,0 +1,6 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.4 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(HelloPangolin main.cpp)
+target_link_libraries(HelloPangolin ${Pangolin_LIBRARIES})
diff --git a/examples/HelloPangolin/main.cpp b/examples/HelloPangolin/main.cpp
new file mode 100644
index 0000000..2d7c582
--- /dev/null
+++ b/examples/HelloPangolin/main.cpp
@@ -0,0 +1,34 @@
+#include
+
+int main( int /*argc*/, char** /*argv*/ )
+{
+ pangolin::CreateWindowAndBind("Main",640,480);
+ glEnable(GL_DEPTH_TEST);
+
+ // Define Projection and initial ModelView matrix
+ pangolin::OpenGlRenderState s_cam(
+ pangolin::ProjectionMatrix(640,480,420,420,320,240,0.2,100),
+ pangolin::ModelViewLookAt(-2,2,-2, 0,0,0, pangolin::AxisY)
+ );
+
+ // Create Interactive View in window
+ pangolin::Handler3D handler(s_cam);
+ pangolin::View& d_cam = pangolin::CreateDisplay()
+ .SetBounds(0.0, 1.0, 0.0, 1.0, -640.0f/480.0f)
+ .SetHandler(&handler);
+
+ while( !pangolin::ShouldQuit() )
+ {
+ // Clear screen and activate view to render into
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+ d_cam.Activate(s_cam);
+
+ // Render OpenGL Cube
+ pangolin::glDrawColouredCube();
+
+ // Swap frames and Process Events
+ pangolin::FinishFrame();
+ }
+
+ return 0;
+}
diff --git a/examples/SharedMemoryCamera/CMakeLists.txt b/examples/SharedMemoryCamera/CMakeLists.txt
new file mode 100644
index 0000000..567aeed
--- /dev/null
+++ b/examples/SharedMemoryCamera/CMakeLists.txt
@@ -0,0 +1,7 @@
+if(UNIX)
+find_package(Pangolin 0.4 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(SharedMemoryCamera main.cpp)
+target_link_libraries(SharedMemoryCamera ${Pangolin_LIBRARIES})
+endif()
diff --git a/examples/SharedMemoryCamera/main.cpp b/examples/SharedMemoryCamera/main.cpp
new file mode 100644
index 0000000..29ba6ae
--- /dev/null
+++ b/examples/SharedMemoryCamera/main.cpp
@@ -0,0 +1,53 @@
+#include
+
+#include
+#include
+#include
+
+#include
+#include
+
+// This sample acts as a soft camera. It writes a pattern of GRAY8 pixels to the
+// shared memory space. It can be seen in Pangolin's SimpleVideo sample using
+// the shmem:[size=640x480]//example video URI.
+
+using namespace pangolin;
+
+unsigned char generate_value(double t)
+{
+ // 10s sinusoid
+ const double d = std::sin(t * 10.0 / M_PI) * 128.0 + 128.0;
+ return static_cast(d);
+}
+
+int main(/*int argc, char *argv[]*/)
+{
+ std::string shmem_name = "/example";
+
+ std::shared_ptr shmem_buffer =
+ create_named_shared_memory_buffer(shmem_name, 640 * 480);
+ if (!shmem_buffer) {
+ perror("Unable to create shared memory buffer");
+ exit(1);
+ }
+
+ std::string cond_name = shmem_name + "_cond";
+ std::shared_ptr buffer_full =
+ create_named_condition_variable(cond_name);
+
+ // Sit in a loop and write gray values based on some timing pattern.
+ while (true) {
+ shmem_buffer->lock();
+ unsigned char *ptr = shmem_buffer->ptr();
+ unsigned char value = generate_value(std::chrono::system_clock::now().time_since_epoch().count());
+
+ for (int i = 0; i < 640*480; ++i) {
+ ptr[i] = value;
+ }
+
+ shmem_buffer->unlock();
+ buffer_full->signal();
+
+ std::this_thread::sleep_for(std::chrono::milliseconds(10));
+ }
+}
diff --git a/examples/SimpleDisplay/CMakeLists.txt b/examples/SimpleDisplay/CMakeLists.txt
new file mode 100644
index 0000000..fe85858
--- /dev/null
+++ b/examples/SimpleDisplay/CMakeLists.txt
@@ -0,0 +1,7 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.4 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(SimpleDisplay main.cpp)
+target_link_libraries(SimpleDisplay ${Pangolin_LIBRARIES} )
+
diff --git a/examples/SimpleDisplay/app.cfg b/examples/SimpleDisplay/app.cfg
new file mode 100644
index 0000000..cf3661b
--- /dev/null
+++ b/examples/SimpleDisplay/app.cfg
@@ -0,0 +1,26 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Pangolin Sample configuration file
+% Comments start with '%' or '#'
+%
+% Declarations are name value pairs,
+% seperated with '=' and terminated with ';'
+
+% We can set any variable referenced in code directly
+ui.A Double = 3.2;
+ui.A Checkbox = false;
+
+% We can set unreferenced variables too
+a.b = 1;
+a.c = 2;
+z.b = 3;
+z.c = 4;
+start = z;
+
+% Which we might refer to by reference
+ui.An Int = ${${start}.c};
+
+% Declarations can span multiple lines
+M =
+[1, 0, 0
+ 0, 1, 0
+ 0, 0, 1];
diff --git a/examples/SimpleDisplay/main.cpp b/examples/SimpleDisplay/main.cpp
new file mode 100644
index 0000000..850bde4
--- /dev/null
+++ b/examples/SimpleDisplay/main.cpp
@@ -0,0 +1,129 @@
+#include
+#include
+
+struct CustomType
+{
+ CustomType()
+ : x(0), y(0.0f) {}
+
+ CustomType(int x, float y, std::string z)
+ : x(x), y(y), z(z) {}
+
+ int x;
+ float y;
+ std::string z;
+};
+
+std::ostream& operator<< (std::ostream& os, const CustomType& o){
+ os << o.x << " " << o.y << " " << o.z;
+ return os;
+}
+
+std::istream& operator>> (std::istream& is, CustomType& o){
+ is >> o.x;
+ is >> o.y;
+ is >> o.z;
+ return is;
+}
+
+void SampleMethod()
+{
+ std::cout << "You typed ctrl-r or pushed reset" << std::endl;
+}
+
+
+int main(/*int argc, char* argv[]*/)
+{
+ // Load configuration data
+ pangolin::ParseVarsFile("app.cfg");
+
+ // Create OpenGL window in single line
+ pangolin::CreateWindowAndBind("Main",640,480);
+
+ // 3D Mouse handler requires depth testing to be enabled
+ glEnable(GL_DEPTH_TEST);
+
+ // Define Camera Render Object (for view / scene browsing)
+ pangolin::OpenGlRenderState s_cam(
+ pangolin::ProjectionMatrix(640,480,420,420,320,240,0.1,1000),
+ pangolin::ModelViewLookAt(-0,0.5,-3, 0,0,0, pangolin::AxisY)
+ );
+
+ const int UI_WIDTH = 180;
+
+ // Add named OpenGL viewport to window and provide 3D Handler
+ pangolin::View& d_cam = pangolin::CreateDisplay()
+ .SetBounds(0.0, 1.0, pangolin::Attach::Pix(UI_WIDTH), 1.0, -640.0f/480.0f)
+ .SetHandler(new pangolin::Handler3D(s_cam));
+
+ // Add named Panel and bind to variables beginning 'ui'
+ // A Panel is just a View with a default layout and input handling
+ pangolin::CreatePanel("ui")
+ .SetBounds(0.0, 1.0, 0.0, pangolin::Attach::Pix(UI_WIDTH));
+
+ // Safe and efficient binding of named variables.
+ // Specialisations mean no conversions take place for exact types
+ // and conversions between scalar types are cheap.
+ pangolin::Var a_button("ui.A_Button",false,false);
+ pangolin::Var a_double("ui.A_Double",3,0,5);
+ pangolin::Var an_int("ui.An_Int",2,0,5);
+ pangolin::Var a_double_log("ui.Log_scale var",3,1,1E4, true);
+ pangolin::Var a_checkbox("ui.A_Checkbox",false,true);
+ pangolin::Var an_int_no_input("ui.An_Int_No_Input",2);
+ pangolin::Var any_type("ui.Some_Type", CustomType(0,1.2f,"Hello") );
+
+ pangolin::Var save_window("ui.Save_Window",false,false);
+ pangolin::Var save_cube("ui.Save_Cube",false,false);
+
+ pangolin::Var record_cube("ui.Record_Cube",false,false);
+
+ // std::function objects can be used for Var's too. These work great with C++11 closures.
+ pangolin::Var > reset("ui.Reset", SampleMethod);
+
+ // Demonstration of how we can register a keyboard hook to alter a Var
+ pangolin::RegisterKeyPressCallback(pangolin::PANGO_CTRL + 'b', pangolin::SetVarFunctor("ui.A_Double", 3.5));
+
+ // Demonstration of how we can register a keyboard hook to trigger a method
+ pangolin::RegisterKeyPressCallback(pangolin::PANGO_CTRL + 'r', SampleMethod);
+
+ // Default hooks for exiting (Esc) and fullscreen (tab).
+ while( !pangolin::ShouldQuit() )
+ {
+ // Clear entire screen
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ if( pangolin::Pushed(a_button) )
+ std::cout << "You Pushed a button!" << std::endl;
+
+ // Overloading of Var operators allows us to treat them like
+ // their wrapped types, eg:
+ if( a_checkbox )
+ an_int = (int)a_double;
+
+ if( !any_type->z.compare("robot"))
+ any_type = CustomType(1,2.3f,"Boogie");
+
+ an_int_no_input = an_int;
+
+ if( pangolin::Pushed(save_window) )
+ pangolin::SaveWindowOnRender("window");
+
+ if( pangolin::Pushed(save_cube) )
+ d_cam.SaveOnRender("cube");
+
+ if( pangolin::Pushed(record_cube) )
+ pangolin::DisplayBase().RecordOnRender("ffmpeg:[fps=50,bps=8388608,unique_filename]//screencap.avi");
+
+ // Activate efficiently by object
+ d_cam.Activate(s_cam);
+
+ // Render some stuff
+ glColor3f(1.0,1.0,1.0);
+ pangolin::glDrawColouredCube();
+
+ // Swap frames and Process Events
+ pangolin::FinishFrame();
+ }
+
+ return 0;
+}
diff --git a/examples/SimpleDisplayImage/CMakeLists.txt b/examples/SimpleDisplayImage/CMakeLists.txt
new file mode 100644
index 0000000..57f37b0
--- /dev/null
+++ b/examples/SimpleDisplayImage/CMakeLists.txt
@@ -0,0 +1,6 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.4 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(SimpleDisplayImage main.cpp)
+target_link_libraries(SimpleDisplayImage ${Pangolin_LIBRARIES})
diff --git a/examples/SimpleDisplayImage/main.cpp b/examples/SimpleDisplayImage/main.cpp
new file mode 100644
index 0000000..5dd87b4
--- /dev/null
+++ b/examples/SimpleDisplayImage/main.cpp
@@ -0,0 +1,72 @@
+#include
+#include
+#include
+
+void setImageData(unsigned char * imageArray, int size){
+ for(int i = 0 ; i < size;i++) {
+ imageArray[i] = (unsigned char)(rand()/(RAND_MAX/255.0));
+ }
+}
+
+int main(/*int argc, char* argv[]*/)
+{
+ // Create OpenGL window in single line
+ pangolin::CreateWindowAndBind("Main",640,480);
+
+ // 3D Mouse handler requires depth testing to be enabled
+ glEnable(GL_DEPTH_TEST);
+
+ pangolin::OpenGlRenderState s_cam(
+ pangolin::ProjectionMatrix(640,480,420,420,320,240,0.1,1000),
+ pangolin::ModelViewLookAt(-1,1,-1, 0,0,0, pangolin::AxisY)
+ );
+
+ // Aspect ratio allows us to constrain width and height whilst fitting within specified
+ // bounds. A positive aspect ratio makes a view 'shrink to fit' (introducing empty bars),
+ // whilst a negative ratio makes the view 'grow to fit' (cropping the view).
+ pangolin::View& d_cam = pangolin::Display("cam")
+ .SetBounds(0,1.0f,0,1.0f,-640/480.0)
+ .SetHandler(new pangolin::Handler3D(s_cam));
+
+ // This view will take up no more than a third of the windows width or height, and it
+ // will have a fixed aspect ratio to match the image that it will display. When fitting
+ // within the specified bounds, push to the top-left (as specified by SetLock).
+ pangolin::View& d_image = pangolin::Display("image")
+ .SetBounds(2/3.0f,1.0f,0,1/3.0f,640.0/480)
+ .SetLock(pangolin::LockLeft, pangolin::LockTop);
+
+ std::cout << "Resize the window to experiment with SetBounds, SetLock and SetAspect." << std::endl;
+ std::cout << "Notice that the cubes aspect is maintained even though it covers the whole screen." << std::endl;
+
+ const int width = 64;
+ const int height = 48;
+
+ unsigned char* imageArray = new unsigned char[3*width*height];
+ pangolin::GlTexture imageTexture(width,height,GL_RGB,false,0,GL_RGB,GL_UNSIGNED_BYTE);
+
+ // Default hooks for exiting (Esc) and fullscreen (tab).
+ while(!pangolin::ShouldQuit())
+ {
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ d_cam.Activate(s_cam);
+
+ glColor3f(1.0,1.0,1.0);
+ pangolin::glDrawColouredCube();
+
+ //Set some random image data and upload to GPU
+ setImageData(imageArray,3*width*height);
+ imageTexture.Upload(imageArray,GL_RGB,GL_UNSIGNED_BYTE);
+
+ //display the image
+ d_image.Activate();
+ glColor3f(1.0,1.0,1.0);
+ imageTexture.RenderToViewport();
+
+ pangolin::FinishFrame();
+ }
+
+ delete[] imageArray;
+
+ return 0;
+}
diff --git a/examples/SimpleMultiDisplay/CMakeLists.txt b/examples/SimpleMultiDisplay/CMakeLists.txt
new file mode 100644
index 0000000..3d91937
--- /dev/null
+++ b/examples/SimpleMultiDisplay/CMakeLists.txt
@@ -0,0 +1,6 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.4 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(SimpleMultiDisplay main.cpp)
+target_link_libraries(SimpleMultiDisplay ${Pangolin_LIBRARIES})
diff --git a/examples/SimpleMultiDisplay/app.cfg b/examples/SimpleMultiDisplay/app.cfg
new file mode 100644
index 0000000..08c9c8c
--- /dev/null
+++ b/examples/SimpleMultiDisplay/app.cfg
@@ -0,0 +1,28 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Pangolin Sample configuration file
+% Comments start with '%' or '#'
+%
+% Declarations are name value pairs,
+% seperated with '=' and terminated with ';'
+
+% We can set any variable referenced in code directly
+ui.A Double = 3.2;
+
+% We can set unreferenced variables too
+a.b = 1;
+a.c = 2;
+z.b = 3;
+z.c = 4;
+start = z;
+
+% Which we might refer to by reference
+ui.An Int = ${${start}.c};
+
+% Declarations can span multiple lines
+M =
+[1, 0, 0
+ 0, 1, 0
+ 0, 0, 1];
+
+ui.Aliased Double = @ui.A Double;
+ui.Aliased Double = 2.0;
diff --git a/examples/SimpleMultiDisplay/main.cpp b/examples/SimpleMultiDisplay/main.cpp
new file mode 100644
index 0000000..79bb22b
--- /dev/null
+++ b/examples/SimpleMultiDisplay/main.cpp
@@ -0,0 +1,106 @@
+#include
+#include
+
+void setImageData(unsigned char * imageArray, int size){
+ for(int i = 0 ; i < size;i++) {
+ imageArray[i] = (unsigned char)(rand()/(RAND_MAX/255.0));
+ }
+}
+
+int main(/*int argc, char* argv[]*/)
+{
+ // Create OpenGL window in single line
+ pangolin::CreateWindowAndBind("Main",640,480);
+
+ // 3D Mouse handler requires depth testing to be enabled
+ glEnable(GL_DEPTH_TEST);
+
+ // Issue specific OpenGl we might need
+ glEnable (GL_BLEND);
+ glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+ // Define Camera Render Object (for view / scene browsing)
+ pangolin::OpenGlMatrix proj = pangolin::ProjectionMatrix(640,480,420,420,320,240,0.1,1000);
+ pangolin::OpenGlRenderState s_cam(proj, pangolin::ModelViewLookAt(1,0.5,-2,0,0,0, pangolin::AxisY) );
+ pangolin::OpenGlRenderState s_cam2(proj, pangolin::ModelViewLookAt(0,0,-2,0,0,0, pangolin::AxisY) );
+
+ // Add named OpenGL viewport to window and provide 3D Handler
+ pangolin::View& d_cam1 = pangolin::Display("cam1")
+ .SetAspect(640.0f/480.0f)
+ .SetHandler(new pangolin::Handler3D(s_cam));
+
+ pangolin::View& d_cam2 = pangolin::Display("cam2")
+ .SetAspect(640.0f/480.0f)
+ .SetHandler(new pangolin::Handler3D(s_cam2));
+
+ pangolin::View& d_cam3 = pangolin::Display("cam3")
+ .SetAspect(640.0f/480.0f)
+ .SetHandler(new pangolin::Handler3D(s_cam));
+
+ pangolin::View& d_cam4 = pangolin::Display("cam4")
+ .SetAspect(640.0f/480.0f)
+ .SetHandler(new pangolin::Handler3D(s_cam2));
+
+ pangolin::View& d_img1 = pangolin::Display("img1")
+ .SetAspect(640.0f/480.0f);
+
+ pangolin::View& d_img2 = pangolin::Display("img2")
+ .SetAspect(640.0f/480.0f);
+
+ // LayoutEqual is an EXPERIMENTAL feature - it requires that all sub-displays
+ // share the same aspect ratio, placing them in a raster fasion in the
+ // viewport so as to maximise display size.
+ pangolin::Display("multi")
+ .SetBounds(0.0, 1.0, 0.0, 1.0)
+ .SetLayout(pangolin::LayoutEqual)
+ .AddDisplay(d_cam1)
+ .AddDisplay(d_img1)
+ .AddDisplay(d_cam2)
+ .AddDisplay(d_img2)
+ .AddDisplay(d_cam3)
+ .AddDisplay(d_cam4);
+
+ const int width = 64;
+ const int height = 48;
+ unsigned char* imageArray = new unsigned char[3*width*height];
+ pangolin::GlTexture imageTexture(width,height,GL_RGB,false,0,GL_RGB,GL_UNSIGNED_BYTE);
+
+ // Default hooks for exiting (Esc) and fullscreen (tab).
+ while( !pangolin::ShouldQuit() )
+ {
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ // Generate random image and place in texture memory for display
+ setImageData(imageArray,3*width*height);
+ imageTexture.Upload(imageArray,GL_RGB,GL_UNSIGNED_BYTE);
+
+ glColor3f(1.0,1.0,1.0);
+
+ d_cam1.Activate(s_cam);
+ pangolin::glDrawColouredCube();
+
+ d_cam2.Activate(s_cam2);
+ pangolin::glDrawColouredCube();
+
+ d_cam3.Activate(s_cam);
+ pangolin::glDrawColouredCube();
+
+ d_cam4.Activate(s_cam2);
+ pangolin::glDrawColouredCube();
+
+ d_img1.Activate();
+ glColor4f(1.0f,1.0f,1.0f,1.0f);
+ imageTexture.RenderToViewport();
+
+ d_img2.Activate();
+ glColor4f(1.0f,1.0f,1.0f,1.0f);
+ imageTexture.RenderToViewport();
+
+ // Swap frames and Process Events
+ pangolin::FinishFrame();
+ }
+
+ delete[] imageArray;
+
+ return 0;
+}
diff --git a/examples/SimplePlot/CMakeLists.txt b/examples/SimplePlot/CMakeLists.txt
new file mode 100644
index 0000000..62a6de7
--- /dev/null
+++ b/examples/SimplePlot/CMakeLists.txt
@@ -0,0 +1,6 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.4 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(SimplePlot main.cpp)
+target_link_libraries(SimplePlot ${Pangolin_LIBRARIES})
diff --git a/examples/SimplePlot/main.cpp b/examples/SimplePlot/main.cpp
new file mode 100644
index 0000000..a931e4e
--- /dev/null
+++ b/examples/SimplePlot/main.cpp
@@ -0,0 +1,49 @@
+#include
+
+#include
+
+int main(/*int argc, char* argv[]*/)
+{
+ // Create OpenGL window in single line
+ pangolin::CreateWindowAndBind("Main",640,480);
+
+ // Data logger object
+ pangolin::DataLog log;
+
+ // Optionally add named labels
+ std::vector labels;
+ labels.push_back(std::string("sin(t)"));
+ labels.push_back(std::string("cos(t)"));
+ labels.push_back(std::string("sin(t)+cos(t)"));
+ log.SetLabels(labels);
+
+ const float tinc = 0.01f;
+
+ // OpenGL 'view' of data. We might have many views of the same data.
+ pangolin::Plotter plotter(&log,0.0f,4.0f*(float)M_PI/tinc,-2.0f,2.0f,(float)M_PI/(4.0f*tinc),0.5f);
+ plotter.SetBounds(0.0, 1.0, 0.0, 1.0);
+ plotter.Track("$i");
+
+ // Add some sample annotations to the plot
+ plotter.AddMarker(pangolin::Marker::Vertical, -1000, pangolin::Marker::LessThan, pangolin::Colour::Blue().WithAlpha(0.2f) );
+ plotter.AddMarker(pangolin::Marker::Horizontal, 100, pangolin::Marker::GreaterThan, pangolin::Colour::Red().WithAlpha(0.2f) );
+ plotter.AddMarker(pangolin::Marker::Horizontal, 10, pangolin::Marker::Equal, pangolin::Colour::Green().WithAlpha(0.2f) );
+
+ pangolin::DisplayBase().AddDisplay(plotter);
+
+ float t = 0;
+
+ // Default hooks for exiting (Esc) and fullscreen (tab).
+ while( !pangolin::ShouldQuit() )
+ {
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ log.Log(sin(t),cos(t),sin(t)+cos(t));
+ t += tinc;
+
+ // Render graph, Swap frames and Process Events
+ pangolin::FinishFrame();
+ }
+
+ return 0;
+}
diff --git a/examples/SimpleRecord/CMakeLists.txt b/examples/SimpleRecord/CMakeLists.txt
new file mode 100644
index 0000000..8977c0e
--- /dev/null
+++ b/examples/SimpleRecord/CMakeLists.txt
@@ -0,0 +1,6 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.4 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(SimpleRecord main.cpp)
+target_link_libraries(SimpleRecord ${Pangolin_LIBRARIES})
diff --git a/examples/SimpleRecord/main.cpp b/examples/SimpleRecord/main.cpp
new file mode 100644
index 0000000..d05ab5d
--- /dev/null
+++ b/examples/SimpleRecord/main.cpp
@@ -0,0 +1,94 @@
+#include
+
+void RecordSample(const std::string input_uri, const std::string record_uri)
+{
+ // Setup Video Source
+ pangolin::VideoInput video(input_uri);
+ const pangolin::PixelFormat vid_fmt = video.PixFormat();
+ const unsigned w = video.Width();
+ const unsigned h = video.Height();
+
+ pangolin::VideoOutput recorder( record_uri );
+ recorder.SetStreams(video.Streams());
+
+ // Create OpenGL window
+ pangolin::CreateWindowAndBind("Main",w,h);
+
+ // Create viewport for video with fixed aspect
+ pangolin::View vVideo((float)w/h);
+
+ // OpenGl Texture for video frame
+ pangolin::GlTexture texVideo(w,h,GL_RGBA);
+
+ // Allocate image buffer. The +1 is to give ffmpeg some alignment slack
+ // swscale seems to have a bug which goes over the array by 1...
+ unsigned char* img = new unsigned char[video.SizeBytes() + 1];
+
+ while( !pangolin::ShouldQuit() )
+ {
+ glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
+
+ if( video.GrabNext(img,true) )
+ {
+ // Upload to GPU as texture for display
+ texVideo.Upload(img, vid_fmt.channels==1 ? GL_LUMINANCE:GL_RGB, GL_UNSIGNED_BYTE);
+
+ // Record video frame
+ recorder.WriteStreams(img);
+ }
+
+ // Activate video viewport and render texture
+ vVideo.Activate();
+ texVideo.RenderToViewportFlipY();
+
+ // Swap back buffer with front and process window events via GLUT
+ pangolin::FinishFrame();
+ }
+
+ delete[] img;
+}
+
+int main( int argc, char* argv[] )
+{
+ std::string record_uri = "ffmpeg:[fps=30,bps=8388608]//video.avi";
+
+ std::string input_uris[] = {
+ "dc1394:[fps=30,dma=10,size=640x480,iso=400]//0",
+ "convert:[fmt=RGB24]//v4l:///dev/video0",
+ "convert:[fmt=RGB24]//v4l:///dev/video1",
+ ""
+ };
+
+ if( argc >= 2 ) {
+ const std::string uri = std::string(argv[1]);
+ if( argc == 3 ) {
+ record_uri = std::string(argv[2]);
+ }
+ RecordSample(uri, record_uri);
+ }else{
+ std::cout << "Usage : SimpleRecord [video-uri] [output-uri]" << std::endl << std::endl;
+ std::cout << "Where video-uri describes a stream or file resource, e.g." << std::endl;
+ std::cout << "\tfile:[realtime=1]///home/user/video/movie.pvn" << std::endl;
+ std::cout << "\tfile:///home/user/video/movie.avi" << std::endl;
+ std::cout << "\tfiles:///home/user/seqiemce/foo%03d.jpeg" << std::endl;
+ std::cout << "\tdc1394:[fmt=RGB24,size=640x480,fps=30,iso=400,dma=10]//0" << std::endl;
+ std::cout << "\tdc1394:[fmt=FORMAT7_1,size=640x480,pos=2+2,iso=400,dma=10]//0" << std::endl;
+ std::cout << "\tv4l:///dev/video0" << std::endl;
+ std::cout << "\tconvert:[fmt=RGB24]//v4l:///dev/video0" << std::endl;
+ std::cout << "\tmjpeg://http://127.0.0.1/?action=stream" << std::endl;
+ std::cout << std::endl;
+
+ // Try to open some video device
+ for(int i=0; !input_uris[i].empty(); ++i )
+ {
+ try{
+ std::cout << "Trying: " << input_uris[i] << std::endl;
+ RecordSample(input_uris[i], record_uri);
+ return 0;
+ }catch(pangolin::VideoException) {}
+ }
+ }
+
+ return 0;
+
+}
diff --git a/examples/SimpleScene/CMakeLists.txt b/examples/SimpleScene/CMakeLists.txt
new file mode 100644
index 0000000..2ad2549
--- /dev/null
+++ b/examples/SimpleScene/CMakeLists.txt
@@ -0,0 +1,6 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.4 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(SimpleScene main.cpp)
+target_link_libraries(SimpleScene ${Pangolin_LIBRARIES})
diff --git a/examples/SimpleScene/main.cpp b/examples/SimpleScene/main.cpp
new file mode 100644
index 0000000..2423dc6
--- /dev/null
+++ b/examples/SimpleScene/main.cpp
@@ -0,0 +1,40 @@
+#include
+#include
+#include
+
+int main( int /*argc*/, char** /*argv*/ )
+{
+ pangolin::CreateWindowAndBind("Main",640,480);
+ glEnable(GL_DEPTH_TEST);
+
+ // Define Projection and initial ModelView matrix
+ pangolin::OpenGlRenderState s_cam(
+ pangolin::ProjectionMatrix(640,480,420,420,320,240,0.2,100),
+ pangolin::ModelViewLookAt(-2,2,-2, 0,0,0, pangolin::AxisY)
+ );
+
+ pangolin::Renderable tree;
+ tree.Add( std::make_shared() );
+
+ // Create Interactive View in window
+ pangolin::SceneHandler handler(tree, s_cam);
+ pangolin::View& d_cam = pangolin::CreateDisplay()
+ .SetBounds(0.0, 1.0, 0.0, 1.0, -640.0f/480.0f)
+ .SetHandler(&handler);
+
+ d_cam.SetDrawFunction([&](pangolin::View& view){
+ view.Activate(s_cam);
+ tree.Render();
+ });
+
+ while( !pangolin::ShouldQuit() )
+ {
+ // Clear screen and activate view to render into
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ // Swap frames and Process Events
+ pangolin::FinishFrame();
+ }
+
+ return 0;
+}
diff --git a/examples/SimpleVideo/CMakeLists.txt b/examples/SimpleVideo/CMakeLists.txt
new file mode 100644
index 0000000..0be7165
--- /dev/null
+++ b/examples/SimpleVideo/CMakeLists.txt
@@ -0,0 +1,6 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.4 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(SimpleVideo main.cpp)
+target_link_libraries(SimpleVideo ${Pangolin_LIBRARIES})
diff --git a/examples/SimpleVideo/main.cpp b/examples/SimpleVideo/main.cpp
new file mode 100644
index 0000000..3085b95
--- /dev/null
+++ b/examples/SimpleVideo/main.cpp
@@ -0,0 +1,111 @@
+/**
+ * @author Steven Lovegrove
+ * Copyright (C) 2010 Steven Lovegrove
+ * Imperial College London
+ **/
+
+#include
+
+void SetGlFormat(GLint& glformat, GLenum& gltype, const pangolin::PixelFormat& fmt)
+{
+ switch( fmt.channels) {
+ case 1: glformat = GL_LUMINANCE; break;
+ case 3: glformat = GL_RGB; break;
+ case 4: glformat = GL_RGBA; break;
+ default: throw std::runtime_error("Unable to display video format");
+ }
+
+ switch (fmt.channel_bits[0]) {
+ case 8: gltype = GL_UNSIGNED_BYTE; break;
+ case 16: gltype = GL_UNSIGNED_SHORT; break;
+ case 32: gltype = GL_FLOAT; break;
+ default: throw std::runtime_error("Unknown channel format");
+ }
+}
+
+void VideoSample(const std::string uri)
+{
+ // Setup Video Source
+ pangolin::VideoInput video(uri);
+ const pangolin::PixelFormat vid_fmt = video.PixFormat();
+ const unsigned w = video.Width();
+ const unsigned h = video.Height();
+
+ // Work out appropriate GL channel and format options
+ GLint glformat;
+ GLenum gltype;
+ SetGlFormat(glformat, gltype, vid_fmt);
+
+ // Create OpenGL window
+ pangolin::CreateWindowAndBind("Main",w,h);
+
+ // Create viewport for video with fixed aspect
+ pangolin::View& vVideo = pangolin::Display("Video").SetAspect((float)w/h);
+
+ // OpenGl Texture for video frame.
+ pangolin::GlTexture texVideo(w,h,glformat,false,0,glformat,gltype);
+
+ unsigned char* img = new unsigned char[video.SizeBytes()];
+
+ for(int frame=0; !pangolin::ShouldQuit(); ++frame)
+ {
+ glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
+
+ if( video.GrabNext(img,true) ) {
+ texVideo.Upload( img, glformat, gltype );
+ }
+
+ // Activate video viewport and render texture
+ vVideo.Activate();
+ texVideo.RenderToViewportFlipY();
+
+ // Swap back buffer with front and process window events via GLUT
+ pangolin::FinishFrame();
+ }
+
+ delete[] img;
+}
+
+
+int main( int argc, char* argv[] )
+{
+ std::string uris[] = {
+ "dc1394:[fps=30,dma=10,size=640x480,iso=400]//0",
+ "convert:[fmt=RGB24]//v4l:///dev/video0",
+ "convert:[fmt=RGB24]//v4l:///dev/video1",
+ "openni:[img1=rgb]//",
+ "pleora:[sn=00000215,size=640x480,pos=64x64]//",
+ "test:[size=160x120,n=1,fmt=RGB24]//"
+ ""
+ };
+
+ if( argc > 1 ) {
+ const std::string uri = std::string(argv[1]);
+ VideoSample(uri);
+ }else{
+ std::cout << "Usage : SimpleRecord [video-uri]" << std::endl << std::endl;
+ std::cout << "Where video-uri describes a stream or file resource, e.g." << std::endl;
+ std::cout << "\tfile:[realtime=1]///home/user/video/movie.pvn" << std::endl;
+ std::cout << "\tfile:///home/user/video/movie.avi" << std::endl;
+ std::cout << "\tfiles:///home/user/seqiemce/foo%03d.jpeg" << std::endl;
+ std::cout << "\tdc1394:[fmt=RGB24,size=640x480,fps=30,iso=400,dma=10]//0" << std::endl;
+ std::cout << "\tdc1394:[fmt=FORMAT7_1,size=640x480,pos=2+2,iso=400,dma=10]//0" << std::endl;
+ std::cout << "\tv4l:///dev/video0" << std::endl;
+ std::cout << "\tconvert:[fmt=RGB24]//v4l:///dev/video0" << std::endl;
+ std::cout << "\tmjpeg://http://127.0.0.1/?action=stream" << std::endl;
+ std::cout << "\topenni:[img1=rgb]//" << std::endl;
+ std::cout << std::endl;
+
+ // Try to open some video device
+ for(int i=0; !uris[i].empty(); ++i )
+ {
+ try{
+ std::cout << "Trying: " << uris[i] << std::endl;
+ VideoSample(uris[i]);
+ return 0;
+ }catch(pangolin::VideoException) { }
+ }
+ }
+
+ return 0;
+}
diff --git a/examples/VBODisplay/CMakeLists.txt b/examples/VBODisplay/CMakeLists.txt
new file mode 100644
index 0000000..28a5b7e
--- /dev/null
+++ b/examples/VBODisplay/CMakeLists.txt
@@ -0,0 +1,19 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.4 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+link_directories(${Pangolin_LIBRARY_DIRS})
+link_libraries(${Pangolin_LIBRARIES})
+
+find_package(CUDA QUIET)
+
+# This example could be made to work with C++11, but the kernel code must be
+# compiled without it.
+if(CUDA_FOUND)
+ cuda_include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+
+ cuda_add_executable(
+ VBODisplay
+ main.cpp kernal.cu
+ )
+
+endif()
diff --git a/examples/VBODisplay/kernal.cu b/examples/VBODisplay/kernal.cu
new file mode 100644
index 0000000..07d06ba
--- /dev/null
+++ b/examples/VBODisplay/kernal.cu
@@ -0,0 +1,30 @@
+// Colour Sine wave Kernal
+// Based on kernal_colour in kernelVBO.cpp by Rob Farber
+__global__ void kernel(float4* dVertexArray, uchar4 *dColorArray,
+ unsigned int width, unsigned int height, float time)
+{
+ unsigned int x = blockIdx.x*blockDim.x + threadIdx.x;
+ unsigned int y = blockIdx.y*blockDim.y + threadIdx.y;
+
+ // Each thread is unique point (u,v) in interval [-1,1],[-1,1]
+ const float u = 2.0f* (x/(float)width) - 1.0f;
+ const float v = 2.0f* (y/(float)height) - 1.0f;
+ const float w = 0.5f * sinf(4.0f*u + time) * cosf(4.0f*v + time);
+
+ // Update vertex array for point
+ dVertexArray[y*width+x] = make_float4(u, w, v, 1.0f);
+
+ // Update colour array for point
+ dColorArray[y*width+x].w = 0.0f;
+ dColorArray[y*width+x].x = 255.0f *0.5f*(1.f+sinf(w+x));
+ dColorArray[y*width+x].y = 255.0f *0.5f*(1.f+sinf(x)*cosf(y));
+ dColorArray[y*width+x].z = 255.0f *0.5f*(1.f+sinf(w+time/10.0f));
+}
+
+extern "C" void launch_kernel(float4* dVertexArray, uchar4* dColourArray,
+ unsigned int width, unsigned int height, float time)
+{
+ dim3 block(8, 8, 1);
+ dim3 grid(width / block.x, height / block.y, 1);
+ kernel<<< grid, block>>>(dVertexArray, dColourArray, width, height, time);
+}
diff --git a/examples/VBODisplay/main.cpp b/examples/VBODisplay/main.cpp
new file mode 100644
index 0000000..6b7f778
--- /dev/null
+++ b/examples/VBODisplay/main.cpp
@@ -0,0 +1,84 @@
+#include
+
+#include
+
+#include
+#include
+#include
+
+#include
+#include
+#include
+
+using namespace pangolin;
+using namespace std;
+
+// Mesh size
+const int mesh_width=256;
+const int mesh_height=256;
+
+extern "C" void launch_kernel(float4* dVertexArray, uchar4* dColourArray, unsigned int width, unsigned int height, float time);
+
+int main( int /*argc*/, char* argv[] )
+{
+// cudaGLSetGLDevice(0);
+
+ pangolin::CreateWindowAndBind("Main",640,480);
+ glewInit();
+
+ // 3D Mouse handler requires depth testing to be enabled
+ glEnable(GL_DEPTH_TEST);
+
+ // Create vertex and colour buffer objects and register them with CUDA
+ GlBufferCudaPtr vertex_array(
+ GlArrayBuffer, mesh_width*mesh_height, GL_FLOAT, 4,
+ cudaGraphicsMapFlagsWriteDiscard, GL_STREAM_DRAW
+ );
+ GlBufferCudaPtr colour_array(
+ GlArrayBuffer, mesh_width*mesh_height, GL_UNSIGNED_BYTE, 4,
+ cudaGraphicsMapFlagsWriteDiscard, GL_STREAM_DRAW
+ );
+
+ // Define Camera Render Object (for view / scene browsing)
+ pangolin::OpenGlRenderState s_cam(
+ ProjectionMatrix(640,480,420,420,320,240,0.1,1000),
+ ModelViewLookAt(-0,2,-2, 0,0,0, AxisY)
+ );
+ const int UI_WIDTH = 180;
+
+ // Add named OpenGL viewport to window and provide 3D Handler
+ View& d_cam = pangolin::Display("cam")
+ .SetBounds(0.0, 1.0, Attach::Pix(UI_WIDTH), 1.0, -640.0f/480.0f)
+ .SetHandler(new Handler3D(s_cam));
+
+ // Add named Panel and bind to variables beginning 'ui'
+ // A Panel is just a View with a default layout and input handling
+ View& d_panel = pangolin::CreatePanel("ui")
+ .SetBounds(0.0, 1.0, 0.0, Attach::Pix(UI_WIDTH));
+
+ // Default hooks for exiting (Esc) and fullscreen (tab).
+ for(int frame=0; !pangolin::ShouldQuit(); ++frame)
+ {
+ static double time = 0;
+ static Var delta("ui.time delta", 0.001, 0, 0.005);
+
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ d_cam.Activate(s_cam);
+ glColor3f(1.0,1.0,1.0);
+
+ {
+ CudaScopedMappedPtr var(vertex_array);
+ CudaScopedMappedPtr car(colour_array);
+ launch_kernel((float4*)*var,(uchar4*)*car,mesh_width,mesh_height,time);
+ time += delta;
+ }
+
+ pangolin::RenderVboCbo(vertex_array, colour_array);
+
+ // Swap frames and Process Events
+ pangolin::FinishFrame();
+ }
+
+ return 0;
+}
diff --git a/external/CMakeLists.txt b/external/CMakeLists.txt
new file mode 100644
index 0000000..e21cf33
--- /dev/null
+++ b/external/CMakeLists.txt
@@ -0,0 +1,157 @@
+include(ExternalProject)
+
+set(ExternConfig "")
+
+if( BUILD_EXTERN_GLEW )
+
+#########################################################
+# GLEW
+#########################################################
+set(glew_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/glew")
+ExternalProject_Add( __glew
+ PREFIX "${glew_PREFIX}"
+ GIT_REPOSITORY https://github.com/Perlmint/glew-cmake.git
+ GIT_TAG 7574ab4d00b683e56adbfdec7da636529dfe65d8
+ INSTALL_DIR ${glew_PREFIX}
+ CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${glew_PREFIX}
+ -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+ -DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}
+ -DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}
+ -DCMAKE_C_FLAGS_MINSIZEREL=${CMAKE_C_FLAGS_MINSIZEREL}
+ -DCMAKE_C_FLAGS_RELWITHDEBINFO=${CMAKE_C_FLAGS_RELWITHDEBINFO}
+)
+
+add_library(_glew STATIC IMPORTED GLOBAL)
+add_dependencies(_glew __glew)
+set_target_properties(_glew PROPERTIES
+ IMPORTED_LOCATION_RELWITHDEBINFO ${glew_PREFIX}/lib/glew.lib
+ IMPORTED_LOCATION_RELEASE ${glew_PREFIX}/lib/glew.lib
+ IMPORTED_LOCATION_DEBUG ${glew_PREFIX}/lib/glewd.lib
+)
+
+set(GLEW_FOUND true PARENT_SCOPE)
+set(GLEW_INCLUDE_DIR "${glew_PREFIX}/include" PARENT_SCOPE)
+set(GLEW_LIBRARY _glew PARENT_SCOPE)
+set(GLEW_STATIC 1 PARENT_SCOPE)
+set(ExternConfig "${ExternConfig}
+ add_library(_glew STATIC IMPORTED)
+ set_target_properties(_glew PROPERTIES
+ IMPORTED_LOCATION_RELWITHDEBINFO ${glew_PREFIX}/lib/glew.lib
+ IMPORTED_LOCATION_RELEASE ${glew_PREFIX}/lib/glew.lib
+ IMPORTED_LOCATION_DEBUG ${glew_PREFIX}/lib/glewd.lib
+ )")
+endif()
+
+if( BUILD_EXTERN_LIBPNG )
+
+#########################################################
+# zlib
+#########################################################
+
+set(zlib_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/zlib")
+ExternalProject_Add( __zlib
+ PREFIX "${zlib_PREFIX}"
+ GIT_REPOSITORY https://github.com/madler/zlib.git
+ GIT_TAG v1.2.8
+ INSTALL_DIR ${zlib_PREFIX}
+ CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${zlib_PREFIX}
+ -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+ -DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}
+ -DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}
+ -DCMAKE_C_FLAGS_MINSIZEREL=${CMAKE_C_FLAGS_MINSIZEREL}
+ -DCMAKE_C_FLAGS_RELWITHDEBINFO=${CMAKE_C_FLAGS_RELWITHDEBINFO}
+)
+add_library(_zlib STATIC IMPORTED GLOBAL)
+add_dependencies(_zlib __zlib)
+set_target_properties(_zlib PROPERTIES
+ IMPORTED_LOCATION_RELEASE ${zlib_PREFIX}/lib/zlibstatic.lib
+ IMPORTED_LOCATION_RELWITHDEBINFO ${zlib_PREFIX}/lib/zlibstatic.lib
+ IMPORTED_LOCATION_DEBUG ${zlib_PREFIX}/lib/zlibstaticd.lib
+)
+
+#########################################################
+# libpng
+#########################################################
+
+set(libpng_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/libpng")
+ExternalProject_Add( __libpng
+ PREFIX "${libpng_PREFIX}"
+ GIT_REPOSITORY https://github.com/glennrp/libpng.git
+ GIT_TAG v1.6.18
+ INSTALL_DIR ${libpng_PREFIX}
+ CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${libpng_PREFIX}
+ -DZLIB_INCLUDE_DIR=${zlib_PREFIX}/include
+ -DZLIB_LIBRARY=${zlib_PREFIX}/lib/zlibstatic*.lib
+ -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+ -DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}
+ -DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}
+ -DCMAKE_C_FLAGS_MINSIZEREL=${CMAKE_C_FLAGS_MINSIZEREL}
+ -DCMAKE_C_FLAGS_RELWITHDEBINFO=${CMAKE_C_FLAGS_RELWITHDEBINFO}
+ DEPENDS __zlib
+)
+
+add_library(_libpng STATIC IMPORTED GLOBAL)
+add_dependencies(_libpng __libpng)
+set_target_properties(_libpng PROPERTIES
+ IMPORTED_LOCATION_RELWITHDEBINFO ${libpng_PREFIX}/lib/libpng16_static.lib
+ IMPORTED_LOCATION_RELEASE ${libpng_PREFIX}/lib/libpng16_static.lib
+ IMPORTED_LOCATION_DEBUG ${libpng_PREFIX}/lib/libpng16_staticd.lib
+)
+
+set(PNG_FOUND true PARENT_SCOPE)
+set(PNG_INCLUDE_DIR "${libpng_PREFIX}/include" PARENT_SCOPE)
+set(PNG_LIBRARY _libpng PARENT_SCOPE)
+set(ZLIB_LIBRARY _zlib PARENT_SCOPE)
+set(ExternConfig "${ExternConfig}
+ add_library(_zlib STATIC IMPORTED)
+ set_target_properties(_zlib PROPERTIES
+ IMPORTED_LOCATION_RELEASE ${zlib_PREFIX}/lib/zlibstatic.lib
+ IMPORTED_LOCATION_RELWITHDEBINFO ${zlib_PREFIX}/lib/zlibstatic.lib
+ IMPORTED_LOCATION_DEBUG ${zlib_PREFIX}/lib/zlibstaticd.lib
+ )
+ add_library(_libpng STATIC IMPORTED)
+ set_target_properties(_libpng PROPERTIES
+ IMPORTED_LOCATION_RELEASE ${libpng_PREFIX}/lib/libpng16_static.lib
+ IMPORTED_LOCATION_RELWITHDEBINFO ${libpng_PREFIX}/lib/libpng16_static.lib
+ IMPORTED_LOCATION_DEBUG ${libpng_PREFIX}/lib/libpng16_staticd.lib
+ )")
+endif()
+
+if( BUILD_EXTERN_LIBJPEG )
+
+#########################################################
+# libjpg
+#########################################################
+
+set(libjpeg_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/libjpeg")
+ExternalProject_Add( __libjpeg
+ PREFIX "${libjpeg_PREFIX}"
+ GIT_REPOSITORY https://github.com/LuaDist/libjpeg.git
+ GIT_TAG bc8f8be222287fec977ec3f47a5cb065cceb2ee9
+ INSTALL_DIR ${libjpeg_PREFIX}
+ CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${libjpeg_PREFIX}
+ -DBUILD_SHARED_LIBS=false
+ -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+ -DCMAKE_C_FLAGS_RELEASE=${CMAKE_C_FLAGS_RELEASE}
+ -DCMAKE_C_FLAGS_DEBUG=${CMAKE_C_FLAGS_DEBUG}
+ -DCMAKE_C_FLAGS_MINSIZEREL=${CMAKE_C_FLAGS_MINSIZEREL}
+ -DCMAKE_C_FLAGS_RELWITHDEBINFO=${CMAKE_C_FLAGS_RELWITHDEBINFO}
+)
+
+add_library(_libjpeg STATIC IMPORTED GLOBAL)
+add_dependencies(_libjpeg __libjpeg)
+set_target_properties(_libjpeg PROPERTIES
+ IMPORTED_LOCATION ${libjpeg_PREFIX}/lib/jpeg.lib
+)
+
+set(JPEG_FOUND true PARENT_SCOPE)
+set(JPEG_INCLUDE_DIR "${libjpeg_PREFIX}/include" PARENT_SCOPE)
+set(JPEG_LIBRARY _libjpeg PARENT_SCOPE)
+set(ExternConfig "${ExternConfig}
+ add_library(_libjpeg STATIC IMPORTED)
+ set_target_properties(_libjpeg PROPERTIES
+ IMPORTED_LOCATION ${libjpeg_PREFIX}/lib/jpeg.lib
+ )")
+endif()
+
+set(ExternConfig "${ExternConfig}" PARENT_SCOPE)
diff --git a/external/pybind11/.appveyor.yml b/external/pybind11/.appveyor.yml
new file mode 100644
index 0000000..b150f10
--- /dev/null
+++ b/external/pybind11/.appveyor.yml
@@ -0,0 +1,66 @@
+version: 1.0.{build}
+image:
+- Visual Studio 2017
+- Visual Studio 2015
+test: off
+build:
+ parallel: true
+platform:
+- x64
+- x86
+environment:
+ matrix:
+ - PYTHON: 36
+ CPP: 14
+ CONFIG: Debug
+ - PYTHON: 27
+ CPP: 14
+ CONFIG: Debug
+ - CONDA: 36
+ CPP: latest
+ CONFIG: Release
+matrix:
+ exclude:
+ - image: Visual Studio 2015
+ platform: x86
+ - image: Visual Studio 2015
+ CPP: latest
+ - image: Visual Studio 2017
+ CPP: latest
+ platform: x86
+install:
+- ps: |
+ if ($env:PLATFORM -eq "x64") { $env:CMAKE_ARCH = "x64" }
+ if ($env:APPVEYOR_JOB_NAME -like "*Visual Studio 2017*") {
+ $env:CMAKE_GENERATOR = "Visual Studio 15 2017"
+ $env:CMAKE_INCLUDE_PATH = "C:\Libraries\boost_1_64_0"
+ } else {
+ $env:CMAKE_GENERATOR = "Visual Studio 14 2015"
+ }
+ if ($env:PYTHON) {
+ if ($env:PLATFORM -eq "x64") { $env:PYTHON = "$env:PYTHON-x64" }
+ $env:PATH = "C:\Python$env:PYTHON\;C:\Python$env:PYTHON\Scripts\;$env:PATH"
+ pip install --disable-pip-version-check --user --upgrade pip wheel
+ pip install pytest numpy
+ } elseif ($env:CONDA) {
+ if ($env:CONDA -eq "27") { $env:CONDA = "" }
+ if ($env:PLATFORM -eq "x64") { $env:CONDA = "$env:CONDA-x64" }
+ $env:PATH = "C:\Miniconda$env:CONDA\;C:\Miniconda$env:CONDA\Scripts\;$env:PATH"
+ $env:PYTHONHOME = "C:\Miniconda$env:CONDA"
+ conda install -y -q pytest numpy scipy
+ }
+- ps: |
+ Start-FileDownload 'http://bitbucket.org/eigen/eigen/get/3.3.3.zip'
+ 7z x 3.3.3.zip -y > $null
+ $env:CMAKE_INCLUDE_PATH = "eigen-eigen-67e894c6cd8f;$env:CMAKE_INCLUDE_PATH"
+build_script:
+- cmake -G "%CMAKE_GENERATOR%" -A "%CMAKE_ARCH%"
+ -DPYBIND11_CPP_STANDARD=/std:c++%CPP%
+ -DPYBIND11_WERROR=ON
+ -DDOWNLOAD_CATCH=ON
+ -DCMAKE_SUPPRESS_REGENERATION=1
+- set MSBuildLogger="C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
+- cmake --build . --config %CONFIG% --target pytest -- /m /v:m /logger:%MSBuildLogger%
+- cmake --build . --config %CONFIG% --target cpptest -- /m /v:m /logger:%MSBuildLogger%
+- if "%CPP%"=="latest" (cmake --build . --config %CONFIG% --target test_cmake_build -- /m /v:m /logger:%MSBuildLogger%)
+on_failure: if exist "tests\test_cmake_build" type tests\test_cmake_build\*.log*
diff --git a/external/pybind11/.gitignore b/external/pybind11/.gitignore
new file mode 100644
index 0000000..c444c17
--- /dev/null
+++ b/external/pybind11/.gitignore
@@ -0,0 +1,37 @@
+CMakeCache.txt
+CMakeFiles
+Makefile
+cmake_install.cmake
+.DS_Store
+*.so
+*.pyd
+*.dll
+*.sln
+*.sdf
+*.opensdf
+*.vcxproj
+*.filters
+example.dir
+Win32
+x64
+Release
+Debug
+.vs
+CTestTestfile.cmake
+Testing
+autogen
+MANIFEST
+/.ninja_*
+/*.ninja
+/docs/.build
+*.py[co]
+*.egg-info
+*~
+.DS_Store
+/dist
+/build
+/cmake/
+.cache/
+sosize-*.txt
+pybind11Config*.cmake
+pybind11Targets.cmake
diff --git a/external/pybind11/.gitmodules b/external/pybind11/.gitmodules
new file mode 100644
index 0000000..5191885
--- /dev/null
+++ b/external/pybind11/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "tools/clang"]
+ path = tools/clang
+ url = https://github.com/wjakob/clang-cindex-python3
diff --git a/external/pybind11/.readthedocs.yml b/external/pybind11/.readthedocs.yml
new file mode 100644
index 0000000..c9c6161
--- /dev/null
+++ b/external/pybind11/.readthedocs.yml
@@ -0,0 +1,3 @@
+python:
+ version: 3
+requirements_file: docs/requirements.txt
diff --git a/external/pybind11/.travis.yml b/external/pybind11/.travis.yml
new file mode 100644
index 0000000..2853ac7
--- /dev/null
+++ b/external/pybind11/.travis.yml
@@ -0,0 +1,212 @@
+language: cpp
+dist: trusty
+sudo: false
+matrix:
+ include:
+ # This config does a few things:
+ # - Checks C++ and Python code styles (check-style.sh and flake8).
+ # - Makes sure sphinx can build the docs without any errors or warnings.
+ # - Tests setup.py sdist and install (all header files should be present).
+ # - Makes sure that everything still works without optional deps (numpy/scipy/eigen) and
+ # also tests the automatic discovery functions in CMake (Python version, C++ standard).
+ - os: linux
+ env: STYLE DOCS PIP
+ cache: false
+ before_install:
+ - pyenv global $(pyenv whence 2to3) # activate all python versions
+ - PY_CMD=python3
+ - $PY_CMD -m pip install --user --upgrade pip wheel
+ install:
+ - $PY_CMD -m pip install --user --upgrade sphinx sphinx_rtd_theme breathe flake8 pep8-naming pytest
+ - curl -fsSL ftp://ftp.stack.nl/pub/users/dimitri/doxygen-1.8.12.linux.bin.tar.gz | tar xz
+ - export PATH="$PWD/doxygen-1.8.12/bin:$PATH"
+ script:
+ - tools/check-style.sh
+ - flake8
+ - $PY_CMD -m sphinx -W -b html docs docs/.build
+ - |
+ # Make sure setup.py distributes and installs all the headers
+ $PY_CMD setup.py sdist
+ $PY_CMD -m pip install --user -U ./dist/*
+ installed=$($PY_CMD -c "import pybind11; print(pybind11.get_include(True) + '/pybind11')")
+ diff -rq $installed ./include/pybind11
+ - |
+ # Barebones build
+ cmake -DCMAKE_BUILD_TYPE=Debug -DPYBIND11_WERROR=ON -DDOWNLOAD_CATCH=ON
+ make pytest -j 2
+ make cpptest -j 2
+ # The following are regular test configurations, including optional dependencies.
+ # With regard to each other they differ in Python version, C++ standard and compiler.
+ - os: linux
+ env: PYTHON=2.7 CPP=11 GCC=4.8
+ addons:
+ apt:
+ packages: [cmake=2.\*, cmake-data=2.\*]
+ - os: linux
+ env: PYTHON=3.6 CPP=11 GCC=4.8
+ addons:
+ apt:
+ sources: [deadsnakes]
+ packages: [python3.6-dev python3.6-venv, cmake=2.\*, cmake-data=2.\*]
+ - sudo: true
+ services: docker
+ env: PYTHON=2.7 CPP=14 GCC=6 CMAKE=1
+ - sudo: true
+ services: docker
+ env: PYTHON=3.5 CPP=14 GCC=6 DEBUG=1
+ - sudo: true
+ services: docker
+ env: PYTHON=3.6 CPP=17 GCC=7
+ - os: linux
+ env: PYTHON=3.6 CPP=17 CLANG=5.0
+ addons:
+ apt:
+ sources: [deadsnakes, llvm-toolchain-trusty-5.0, ubuntu-toolchain-r-test]
+ packages: [python3.6-dev python3.6-venv clang-5.0 llvm-5.0-dev, lld-5.0]
+ - os: osx
+ osx_image: xcode7.3
+ env: PYTHON=2.7 CPP=14 CLANG CMAKE=1
+ - os: osx
+ osx_image: xcode8.3
+ env: PYTHON=3.6 CPP=14 CLANG DEBUG=1
+ # Test a PyPy 2.7 build
+ - os: linux
+ env: PYPY=5.8 PYTHON=2.7 CPP=11 GCC=4.8
+ addons:
+ apt:
+ packages: [libblas-dev, liblapack-dev, gfortran]
+ # Build in 32-bit mode and tests against the CMake-installed version
+ - sudo: true
+ services: docker
+ env: ARCH=i386 PYTHON=3.5 CPP=14 GCC=6 INSTALL=1
+ script:
+ - |
+ $SCRIPT_RUN_PREFIX sh -c "set -e
+ cmake ${CMAKE_EXTRA_ARGS} -DPYBIND11_INSTALL=1 -DPYBIND11_TEST=0
+ make install
+ cp -a tests /pybind11-tests
+ mkdir /build-tests && cd /build-tests
+ cmake ../pybind11-tests ${CMAKE_EXTRA_ARGS} -DPYBIND11_WERROR=ON
+ make pytest -j 2"
+cache:
+ directories:
+ - $HOME/.local/bin
+ - $HOME/.local/lib
+ - $HOME/.local/include
+ - $HOME/Library/Python
+before_install:
+- |
+ # Configure build variables
+ if [ "$TRAVIS_OS_NAME" = "linux" ]; then
+ if [ -n "$CLANG" ]; then
+ export CXX=clang++-$CLANG CC=clang-$CLANG
+ COMPILER_PACKAGES="clang-$CLANG llvm-$CLANG-dev"
+ else
+ if [ -z "$GCC" ]; then GCC=4.8
+ else COMPILER_PACKAGES=g++-$GCC
+ fi
+ export CXX=g++-$GCC CC=gcc-$GCC
+ fi
+ if [ "$GCC" = "6" ]; then DOCKER=${ARCH:+$ARCH/}debian:stretch
+ elif [ "$GCC" = "7" ]; then DOCKER=debian:buster
+ fi
+ elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
+ export CXX=clang++ CC=clang;
+ fi
+ if [ -n "$CPP" ]; then CPP=-std=c++$CPP; fi
+ if [ "${PYTHON:0:1}" = "3" ]; then PY=3; fi
+ if [ -n "$DEBUG" ]; then CMAKE_EXTRA_ARGS="${CMAKE_EXTRA_ARGS} -DCMAKE_BUILD_TYPE=Debug"; fi
+- |
+ # Initialize environment
+ set -e
+ if [ -n "$DOCKER" ]; then
+ docker pull $DOCKER
+
+ containerid=$(docker run --detach --tty \
+ --volume="$PWD":/pybind11 --workdir=/pybind11 \
+ --env="CC=$CC" --env="CXX=$CXX" --env="DEBIAN_FRONTEND=$DEBIAN_FRONTEND" \
+ --env=GCC_COLORS=\ \
+ $DOCKER)
+ SCRIPT_RUN_PREFIX="docker exec --tty $containerid"
+ $SCRIPT_RUN_PREFIX sh -c 'for s in 0 15; do sleep $s; apt-get update && apt-get -qy dist-upgrade && break; done'
+ else
+ if [ "$PYPY" = "5.8" ]; then
+ curl -fSL https://bitbucket.org/pypy/pypy/downloads/pypy2-v5.8.0-linux64.tar.bz2 | tar xj
+ PY_CMD=$(echo `pwd`/pypy2-v5.8.0-linux64/bin/pypy)
+ CMAKE_EXTRA_ARGS="${CMAKE_EXTRA_ARGS} -DPYTHON_EXECUTABLE:FILEPATH=$PY_CMD"
+ else
+ PY_CMD=python$PYTHON
+ if [ "$TRAVIS_OS_NAME" = "osx" ]; then
+ if [ "$PY" = "3" ]; then
+ brew install python$PY;
+ else
+ curl -fsSL https://bootstrap.pypa.io/get-pip.py | $PY_CMD - --user
+ fi
+ fi
+ fi
+ if [ "$PY" = 3 ] || [ -n "$PYPY" ]; then
+ $PY_CMD -m ensurepip --user
+ fi
+ $PY_CMD -m pip install --user --upgrade pip wheel
+ fi
+ set +e
+install:
+- |
+ # Install dependencies
+ set -e
+ if [ -n "$DOCKER" ]; then
+ if [ -n "$DEBUG" ]; then
+ PY_DEBUG="python$PYTHON-dbg python$PY-scipy-dbg"
+ CMAKE_EXTRA_ARGS="${CMAKE_EXTRA_ARGS} -DPYTHON_EXECUTABLE=/usr/bin/python${PYTHON}dm"
+ fi
+ $SCRIPT_RUN_PREFIX sh -c "for s in 0 15; do sleep \$s; \
+ apt-get -qy --no-install-recommends install \
+ $PY_DEBUG python$PYTHON-dev python$PY-pytest python$PY-scipy \
+ libeigen3-dev libboost-dev cmake make ${COMPILER_PACKAGES} && break; done"
+ else
+
+ if [ "$CLANG" = "5.0" ]; then
+ if ! [ -d ~/.local/include/c++/v1 ]; then
+ # Neither debian nor llvm provide a libc++ 5.0 deb; luckily it's fairly quick
+ # to build, install (and cache), so do it ourselves:
+ git clone --depth=1 https://github.com/llvm-mirror/llvm.git llvm-source
+ git clone https://github.com/llvm-mirror/libcxx.git llvm-source/projects/libcxx -b release_50
+ git clone https://github.com/llvm-mirror/libcxxabi.git llvm-source/projects/libcxxabi -b release_50
+ mkdir llvm-build && cd llvm-build
+ # Building llvm requires a newer cmake than is provided by the trusty container:
+ CMAKE_VER=cmake-3.8.0-Linux-x86_64
+ curl https://cmake.org/files/v3.8/$CMAKE_VER.tar.gz | tar xz
+ ./$CMAKE_VER/bin/cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=~/.local ../llvm-source
+ make -j2 install-cxxabi install-cxx
+ cp -a include/c++/v1/*cxxabi*.h ~/.local/include/c++/v1
+ cd ..
+ fi
+ export CXXFLAGS="-isystem $HOME/.local/include/c++/v1 -stdlib=libc++"
+ export LDFLAGS="-L$HOME/.local/lib -fuse-ld=lld-$CLANG"
+ export LD_LIBRARY_PATH="$HOME/.local/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+ if [ "$CPP" = "-std=c++17" ]; then CPP="-std=c++1z"; fi
+ fi
+
+ export NPY_NUM_BUILD_JOBS=2
+ echo "Installing pytest, numpy, scipy..."
+ ${PYPY:+travis_wait 30} $PY_CMD -m pip install --user --upgrade pytest numpy scipy \
+ ${PYPY:+--extra-index-url https://imaginary.ca/trusty-pypi}
+ echo "done."
+
+ wget -q -O eigen.tar.gz https://bitbucket.org/eigen/eigen/get/3.3.3.tar.gz
+ tar xzf eigen.tar.gz
+ export CMAKE_INCLUDE_PATH="${CMAKE_INCLUDE_PATH:+:}$PWD/eigen-eigen-67e894c6cd8f"
+ fi
+ set +e
+script:
+- $SCRIPT_RUN_PREFIX cmake ${CMAKE_EXTRA_ARGS}
+ -DPYBIND11_PYTHON_VERSION=$PYTHON
+ -DPYBIND11_CPP_STANDARD=$CPP
+ -DPYBIND11_WERROR=${WERROR:-ON}
+ -DDOWNLOAD_CATCH=ON
+- $SCRIPT_RUN_PREFIX make pytest -j 2
+- $SCRIPT_RUN_PREFIX make cpptest -j 2
+- if [ -n "$CMAKE" ]; then $SCRIPT_RUN_PREFIX make test_cmake_build; fi
+after_failure: cat tests/test_cmake_build/*.log*
+after_script:
+- if [ -n "$DOCKER" ]; then docker stop "$containerid"; docker rm "$containerid"; fi
diff --git a/external/pybind11/CMakeLists.txt b/external/pybind11/CMakeLists.txt
new file mode 100644
index 0000000..4280ba7
--- /dev/null
+++ b/external/pybind11/CMakeLists.txt
@@ -0,0 +1,155 @@
+# CMakeLists.txt -- Build system for the pybind11 modules
+#
+# Copyright (c) 2015 Wenzel Jakob
+#
+# All rights reserved. Use of this source code is governed by a
+# BSD-style license that can be found in the LICENSE file.
+
+cmake_minimum_required(VERSION 2.8.12)
+
+if (POLICY CMP0048)
+ # cmake warns if loaded from a min-3.0-required parent dir, so silence the warning:
+ cmake_policy(SET CMP0048 NEW)
+endif()
+
+# CMake versions < 3.4.0 do not support try_compile/pthread checks without C as active language.
+if(CMAKE_VERSION VERSION_LESS 3.4.0)
+ project(pybind11)
+else()
+ project(pybind11 CXX)
+endif()
+
+# Check if pybind11 is being used directly or via add_subdirectory
+set(PYBIND11_MASTER_PROJECT OFF)
+if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+ set(PYBIND11_MASTER_PROJECT ON)
+endif()
+
+option(PYBIND11_INSTALL "Install pybind11 header files?" ${PYBIND11_MASTER_PROJECT})
+option(PYBIND11_TEST "Build pybind11 test suite?" ${PYBIND11_MASTER_PROJECT})
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/tools")
+
+include(pybind11Tools)
+
+# Cache variables so pybind11_add_module can be used in parent projects
+set(PYBIND11_INCLUDE_DIR "${CMAKE_CURRENT_LIST_DIR}/include" CACHE INTERNAL "")
+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 "")
+
+# NB: when adding a header don't forget to also add it to setup.py
+set(PYBIND11_HEADERS
+ include/pybind11/detail/class.h
+ include/pybind11/detail/common.h
+ include/pybind11/detail/descr.h
+ include/pybind11/detail/init.h
+ include/pybind11/detail/internals.h
+ include/pybind11/detail/typeid.h
+ include/pybind11/attr.h
+ include/pybind11/buffer_info.h
+ include/pybind11/cast.h
+ include/pybind11/chrono.h
+ include/pybind11/common.h
+ include/pybind11/complex.h
+ include/pybind11/options.h
+ include/pybind11/eigen.h
+ include/pybind11/embed.h
+ include/pybind11/eval.h
+ include/pybind11/functional.h
+ include/pybind11/numpy.h
+ include/pybind11/operators.h
+ include/pybind11/pybind11.h
+ include/pybind11/pytypes.h
+ include/pybind11/stl.h
+ include/pybind11/stl_bind.h
+)
+string(REPLACE "include/" "${CMAKE_CURRENT_SOURCE_DIR}/include/"
+ PYBIND11_HEADERS "${PYBIND11_HEADERS}")
+
+if (PYBIND11_TEST)
+ add_subdirectory(tests)
+endif()
+
+include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+
+# extract project version from source
+file(STRINGS "${PYBIND11_INCLUDE_DIR}/pybind11/detail/common.h" pybind11_version_defines
+ REGEX "#define PYBIND11_VERSION_(MAJOR|MINOR|PATCH) ")
+foreach(ver ${pybind11_version_defines})
+ if (ver MATCHES "#define PYBIND11_VERSION_(MAJOR|MINOR|PATCH) +([^ ]+)$")
+ set(PYBIND11_VERSION_${CMAKE_MATCH_1} "${CMAKE_MATCH_2}" CACHE INTERNAL "")
+ endif()
+endforeach()
+set(${PROJECT_NAME}_VERSION ${PYBIND11_VERSION_MAJOR}.${PYBIND11_VERSION_MINOR}.${PYBIND11_VERSION_PATCH})
+message(STATUS "pybind11 v${${PROJECT_NAME}_VERSION}")
+
+option (USE_PYTHON_INCLUDE_DIR "Install pybind11 headers in Python include directory instead of default installation prefix" OFF)
+if (USE_PYTHON_INCLUDE_DIR)
+ file(RELATIVE_PATH CMAKE_INSTALL_INCLUDEDIR ${CMAKE_INSTALL_PREFIX} ${PYTHON_INCLUDE_DIRS})
+endif()
+
+if(NOT (CMAKE_VERSION VERSION_LESS 3.0)) # CMake >= 3.0
+ # Build an interface library target:
+ add_library(pybind11 INTERFACE)
+ add_library(pybind11::pybind11 ALIAS pybind11) # to match exported target
+ target_include_directories(pybind11 INTERFACE $
+ $
+ $)
+ target_compile_options(pybind11 INTERFACE $)
+
+ add_library(module INTERFACE)
+ add_library(pybind11::module ALIAS module)
+ if(NOT MSVC)
+ target_compile_options(module INTERFACE -fvisibility=hidden)
+ endif()
+ target_link_libraries(module INTERFACE pybind11::pybind11)
+ if(WIN32 OR CYGWIN)
+ target_link_libraries(module INTERFACE $)
+ elseif(APPLE)
+ target_link_libraries(module INTERFACE "-undefined dynamic_lookup")
+ endif()
+
+ add_library(embed INTERFACE)
+ add_library(pybind11::embed ALIAS embed)
+ target_link_libraries(embed INTERFACE pybind11::pybind11 $)
+endif()
+
+if (PYBIND11_INSTALL)
+ install(DIRECTORY ${PYBIND11_INCLUDE_DIR}/pybind11 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+ # GNUInstallDirs "DATADIR" wrong here; CMake search path wants "share".
+ set(PYBIND11_CMAKECONFIG_INSTALL_DIR "share/cmake/${PROJECT_NAME}" CACHE STRING "install path for pybind11Config.cmake")
+
+ configure_package_config_file(tools/${PROJECT_NAME}Config.cmake.in
+ "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
+ INSTALL_DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR})
+ # Remove CMAKE_SIZEOF_VOID_P from ConfigVersion.cmake since the library does
+ # not depend on architecture specific settings or libraries.
+ set(_PYBIND11_CMAKE_SIZEOF_VOID_P ${CMAKE_SIZEOF_VOID_P})
+ unset(CMAKE_SIZEOF_VOID_P)
+ write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
+ VERSION ${${PROJECT_NAME}_VERSION}
+ COMPATIBILITY AnyNewerVersion)
+ set(CMAKE_SIZEOF_VOID_P ${_PYBIND11_CMAKE_SIZEOF_VOID_P})
+ install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
+ ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
+ tools/FindPythonLibsNew.cmake
+ tools/pybind11Tools.cmake
+ DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR})
+
+ if(NOT (CMAKE_VERSION VERSION_LESS 3.0))
+ if(NOT PYBIND11_EXPORT_NAME)
+ set(PYBIND11_EXPORT_NAME "${PROJECT_NAME}Targets")
+ endif()
+
+ install(TARGETS pybind11 module embed
+ EXPORT "${PYBIND11_EXPORT_NAME}")
+ if(PYBIND11_MASTER_PROJECT)
+ install(EXPORT "${PYBIND11_EXPORT_NAME}"
+ NAMESPACE "${PROJECT_NAME}::"
+ DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR})
+ endif()
+ endif()
+endif()
diff --git a/external/pybind11/CONTRIBUTING.md b/external/pybind11/CONTRIBUTING.md
new file mode 100644
index 0000000..2beaf8d
--- /dev/null
+++ b/external/pybind11/CONTRIBUTING.md
@@ -0,0 +1,37 @@
+Thank you for your interest in this project! Please refer to the following
+sections on how to contribute code and bug reports.
+
+### Reporting bugs
+
+At the moment, this project is run in the spare time of a single person
+([Wenzel Jakob](http://rgl.epfl.ch/people/wjakob)) with very limited resources
+for issue tracker tickets. Thus, before submitting a question or bug report,
+please take a moment of your time and ensure that your issue isn't already
+discussed in the project documentation provided at
+[http://pybind11.readthedocs.org/en/latest](http://pybind11.readthedocs.org/en/latest).
+
+Assuming that you have identified a previously unknown problem or an important
+question, it's essential that you submit a self-contained and minimal piece of
+code that reproduces the problem. In other words: no external dependencies,
+isolate the function(s) that cause breakage, submit matched and complete C++
+and Python snippets that can be easily compiled and run on my end.
+
+## Pull requests
+Contributions are submitted, reviewed, and accepted using Github pull requests.
+Please refer to [this
+article](https://help.github.com/articles/using-pull-requests) for details and
+adhere to the following rules to make the process as smooth as possible:
+
+* Make a new branch for every feature you're working on.
+* Make small and clean pull requests that are easy to review but make sure they
+ do add value by themselves.
+* Add tests for any new functionality and run the test suite (``make pytest``)
+ to ensure that no existing features break.
+* This project has a strong focus on providing general solutions using a
+ minimal amount of code, thus small pull requests are greatly preferred.
+
+### License
+
+pybind11 is provided under a BSD-style license that can be found in the
+``LICENSE`` file. By using, distributing, or contributing to this project, you
+agree to the terms and conditions of this license.
diff --git a/external/pybind11/ISSUE_TEMPLATE.md b/external/pybind11/ISSUE_TEMPLATE.md
new file mode 100644
index 0000000..75df399
--- /dev/null
+++ b/external/pybind11/ISSUE_TEMPLATE.md
@@ -0,0 +1,17 @@
+Make sure you've completed the following steps before submitting your issue -- thank you!
+
+1. Check if your question has already been answered in the [FAQ](http://pybind11.readthedocs.io/en/latest/faq.html) section.
+2. Make sure you've read the [documentation](http://pybind11.readthedocs.io/en/latest/). Your issue may be addressed there.
+3. If those resources didn't help and you only have a short question (not a bug report), consider asking in the [Gitter chat room](https://gitter.im/pybind/Lobby).
+4. If you have a genuine bug report or a more complex question which is not answered in the previous items (or not suitable for chat), please fill in the details below.
+5. Include a self-contained and minimal piece of code that reproduces the problem. If that's not possible, try to make the description as clear as possible.
+
+*After reading, remove this checklist and the template text in parentheses below.*
+
+## Issue description
+
+(Provide a short description, state the expected behavior and what actually happens.)
+
+## Reproducible example code
+
+(The code should be minimal, have no external dependencies, isolate the function(s) that cause breakage. Submit matched and complete C++ and Python snippets that can be easily compiled and run to diagnose the issue.)
diff --git a/external/pybind11/LICENSE b/external/pybind11/LICENSE
new file mode 100644
index 0000000..ccf4e97
--- /dev/null
+++ b/external/pybind11/LICENSE
@@ -0,0 +1,36 @@
+Copyright (c) 2016 Wenzel Jakob , All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+ may be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+You are under no obligation whatsoever to provide any bug fixes, patches, or
+upgrades to the features, functionality or performance of the source code
+("Enhancements") to anyone; however, if you choose to make your Enhancements
+available either publicly, or directly to the author of this software, without
+imposing a separate written license agreement for such Enhancements, then you
+hereby grant the following license: a non-exclusive, royalty-free perpetual
+license to install, use, modify, prepare derivative works, incorporate into
+other computer software, distribute, and sublicense such enhancements or
+derivative works thereof, in binary and source code form.
diff --git a/external/pybind11/MANIFEST.in b/external/pybind11/MANIFEST.in
new file mode 100644
index 0000000..6e57bae
--- /dev/null
+++ b/external/pybind11/MANIFEST.in
@@ -0,0 +1,2 @@
+recursive-include include/pybind11 *.h
+include LICENSE README.md CONTRIBUTING.md
diff --git a/external/pybind11/README.md b/external/pybind11/README.md
new file mode 100644
index 0000000..4477882
--- /dev/null
+++ b/external/pybind11/README.md
@@ -0,0 +1,129 @@
+
+
+# pybind11 — Seamless operability between C++11 and Python
+
+[](http://pybind11.readthedocs.org/en/master/?badge=master)
+[](http://pybind11.readthedocs.org/en/stable/?badge=stable)
+[](https://gitter.im/pybind/Lobby)
+[](https://travis-ci.org/pybind/pybind11)
+[](https://ci.appveyor.com/project/wjakob/pybind11)
+
+**pybind11** is a lightweight header-only library that exposes C++ types in Python
+and vice versa, mainly to create Python bindings of existing C++ code. Its
+goals and syntax are similar to the excellent
+[Boost.Python](http://www.boost.org/doc/libs/1_58_0/libs/python/doc/) library
+by David Abrahams: to minimize boilerplate code in traditional extension
+modules by inferring type information using compile-time introspection.
+
+The main issue with Boost.Python—and the reason for creating such a similar
+project—is Boost. Boost is an enormously large and complex suite of utility
+libraries that works with almost every C++ compiler in existence. This
+compatibility has its cost: arcane template tricks and workarounds are
+necessary to support the oldest and buggiest of compiler specimens. Now that
+C++11-compatible compilers are widely available, this heavy machinery has
+become an excessively large and unnecessary dependency.
+
+Think of this library as a tiny self-contained version of Boost.Python with
+everything stripped away that isn't relevant for binding generation. Without
+comments, the core header files only require ~4K lines of code and depend on
+Python (2.7 or 3.x, or PyPy2.7 >= 5.7) and the C++ standard library. This
+compact implementation was possible thanks to some of the new C++11 language
+features (specifically: tuples, lambda functions and variadic templates). Since
+its creation, this library has grown beyond Boost.Python in many ways, leading
+to dramatically simpler binding code in many common situations.
+
+Tutorial and reference documentation is provided at
+[http://pybind11.readthedocs.org/en/master](http://pybind11.readthedocs.org/en/master).
+A PDF version of the manual is available
+[here](https://media.readthedocs.org/pdf/pybind11/master/pybind11.pdf).
+
+## Core features
+pybind11 can map the following core C++ features to Python
+
+- Functions accepting and returning custom data structures per value, reference, or pointer
+- Instance methods and static methods
+- Overloaded functions
+- Instance attributes and static attributes
+- Arbitrary exception types
+- Enumerations
+- Callbacks
+- Iterators and ranges
+- Custom operators
+- Single and multiple inheritance
+- STL data structures
+- Iterators and ranges
+- Smart pointers with reference counting like ``std::shared_ptr``
+- Internal references with correct reference counting
+- C++ classes with virtual (and pure virtual) methods can be extended in Python
+
+## Goodies
+In addition to the core functionality, pybind11 provides some extra goodies:
+
+- Python 2.7, 3.x, and PyPy (PyPy2.7 >= 5.7) are supported with an
+ implementation-agnostic interface.
+
+- It is possible to bind C++11 lambda functions with captured variables. The
+ lambda capture data is stored inside the resulting Python function object.
+
+- pybind11 uses C++11 move constructors and move assignment operators whenever
+ possible to efficiently transfer custom data types.
+
+- It's easy to expose the internal storage of custom data types through
+ Pythons' buffer protocols. This is handy e.g. for fast conversion between
+ C++ matrix classes like Eigen and NumPy without expensive copy operations.
+
+- pybind11 can automatically vectorize functions so that they are transparently
+ applied to all entries of one or more NumPy array arguments.
+
+- Python's slice-based access and assignment operations can be supported with
+ just a few lines of code.
+
+- Everything is contained in just a few header files; there is no need to link
+ against any additional libraries.
+
+- Binaries are generally smaller by a factor of at least 2 compared to
+ equivalent bindings generated by Boost.Python. A recent pybind11 conversion
+ of PyRosetta, an enormous Boost.Python binding project,
+ [reported](http://graylab.jhu.edu/RosettaCon2016/PyRosetta-4.pdf) a binary
+ size reduction of **5.4x** and compile time reduction by **5.8x**.
+
+- When supported by the compiler, two new C++14 features (relaxed constexpr and
+ return value deduction) are used to precompute function signatures at compile
+ time, leading to smaller binaries.
+
+- With little extra effort, C++ types can be pickled and unpickled similar to
+ regular Python objects.
+
+## Supported compilers
+
+1. Clang/LLVM 3.3 or newer (for Apple Xcode's clang, this is 5.0.0 or newer)
+2. GCC 4.8 or newer
+3. Microsoft Visual Studio 2015 Update 3 or newer
+4. Intel C++ compiler 16 or newer (15 with a [workaround](https://github.com/pybind/pybind11/issues/276))
+5. Cygwin/GCC (tested on 2.5.1)
+
+## About
+
+This project was created by [Wenzel Jakob](http://rgl.epfl.ch/people/wjakob).
+Significant features and/or improvements to the code were contributed by
+Jonas Adler,
+Sylvain Corlay,
+Trent Houliston,
+Axel Huebl,
+@hulucc,
+Sergey Lyskov
+Johan Mabille,
+Tomasz Miąsko,
+Dean Moldovan,
+Ben Pritchard,
+Jason Rhinelander,
+Boris Schäling,
+Pim Schellart,
+Ivan Smirnov, and
+Patrick Stewart.
+
+### License
+
+pybind11 is provided under a BSD-style license that can be found in the
+``LICENSE`` file. By using, distributing, or contributing to this project,
+you agree to the terms and conditions of this license.
diff --git a/external/pybind11/docs/Doxyfile b/external/pybind11/docs/Doxyfile
new file mode 100644
index 0000000..1b9d129
--- /dev/null
+++ b/external/pybind11/docs/Doxyfile
@@ -0,0 +1,20 @@
+PROJECT_NAME = pybind11
+INPUT = ../include/pybind11/
+RECURSIVE = YES
+
+GENERATE_HTML = NO
+GENERATE_LATEX = NO
+GENERATE_XML = YES
+XML_OUTPUT = .build/doxygenxml
+XML_PROGRAMLISTING = YES
+
+MACRO_EXPANSION = YES
+EXPAND_ONLY_PREDEF = YES
+EXPAND_AS_DEFINED = PYBIND11_RUNTIME_EXCEPTION
+
+ALIASES = "rst=\verbatim embed:rst"
+ALIASES += "endrst=\endverbatim"
+
+QUIET = YES
+WARNINGS = YES
+WARN_IF_UNDOCUMENTED = NO
diff --git a/external/pybind11/docs/_static/theme_overrides.css b/external/pybind11/docs/_static/theme_overrides.css
new file mode 100644
index 0000000..1071809
--- /dev/null
+++ b/external/pybind11/docs/_static/theme_overrides.css
@@ -0,0 +1,11 @@
+.wy-table-responsive table td,
+.wy-table-responsive table th {
+ white-space: initial !important;
+}
+.rst-content table.docutils td {
+ vertical-align: top !important;
+}
+div[class^='highlight'] pre {
+ white-space: pre;
+ white-space: pre-wrap;
+}
diff --git a/external/pybind11/docs/advanced/cast/chrono.rst b/external/pybind11/docs/advanced/cast/chrono.rst
new file mode 100644
index 0000000..8c6b3d7
--- /dev/null
+++ b/external/pybind11/docs/advanced/cast/chrono.rst
@@ -0,0 +1,81 @@
+Chrono
+======
+
+When including the additional header file :file:`pybind11/chrono.h` conversions
+from C++11 chrono datatypes to python datetime objects are automatically enabled.
+This header also enables conversions of python floats (often from sources such
+as ``time.monotonic()``, ``time.perf_counter()`` and ``time.process_time()``)
+into durations.
+
+An overview of clocks in C++11
+------------------------------
+
+A point of confusion when using these conversions is the differences between
+clocks provided in C++11. There are three clock types defined by the C++11
+standard and users can define their own if needed. Each of these clocks have
+different properties and when converting to and from python will give different
+results.
+
+The first clock defined by the standard is ``std::chrono::system_clock``. This
+clock measures the current date and time. However, this clock changes with to
+updates to the operating system time. For example, if your time is synchronised
+with a time server this clock will change. This makes this clock a poor choice
+for timing purposes but good for measuring the wall time.
+
+The second clock defined in the standard is ``std::chrono::steady_clock``.
+This clock ticks at a steady rate and is never adjusted. This makes it excellent
+for timing purposes, however the value in this clock does not correspond to the
+current date and time. Often this clock will be the amount of time your system
+has been on, although it does not have to be. This clock will never be the same
+clock as the system clock as the system clock can change but steady clocks
+cannot.
+
+The third clock defined in the standard is ``std::chrono::high_resolution_clock``.
+This clock is the clock that has the highest resolution out of the clocks in the
+system. It is normally a typedef to either the system clock or the steady clock
+but can be its own independent clock. This is important as when using these
+conversions as the types you get in python for this clock might be different
+depending on the system.
+If it is a typedef of the system clock, python will get datetime objects, but if
+it is a different clock they will be timedelta objects.
+
+Provided conversions
+--------------------
+
+.. rubric:: C++ to Python
+
+- ``std::chrono::system_clock::time_point`` → ``datetime.datetime``
+ System clock times are converted to python datetime instances. They are
+ in the local timezone, but do not have any timezone information attached
+ to them (they are naive datetime objects).
+
+- ``std::chrono::duration`` → ``datetime.timedelta``
+ Durations are converted to timedeltas, any precision in the duration
+ greater than microseconds is lost by rounding towards zero.
+
+- ``std::chrono::[other_clocks]::time_point`` → ``datetime.timedelta``
+ Any clock time that is not the system clock is converted to a time delta.
+ This timedelta measures the time from the clocks epoch to now.
+
+.. rubric:: Python to C++
+
+- ``datetime.datetime`` → ``std::chrono::system_clock::time_point``
+ Date/time objects are converted into system clock timepoints. Any
+ timezone information is ignored and the type is treated as a naive
+ object.
+
+- ``datetime.timedelta`` → ``std::chrono::duration``
+ Time delta are converted into durations with microsecond precision.
+
+- ``datetime.timedelta`` → ``std::chrono::[other_clocks]::time_point``
+ Time deltas that are converted into clock timepoints are treated as
+ the amount of time from the start of the clocks epoch.
+
+- ``float`` → ``std::chrono::duration``
+ Floats that are passed to C++ as durations be interpreted as a number of
+ seconds. These will be converted to the duration using ``duration_cast``
+ from the float.
+
+- ``float`` → ``std::chrono::[other_clocks]::time_point``
+ Floats that are passed to C++ as time points will be interpreted as the
+ number of seconds from the start of the clocks epoch.
diff --git a/external/pybind11/docs/advanced/cast/custom.rst b/external/pybind11/docs/advanced/cast/custom.rst
new file mode 100644
index 0000000..e4f99ac
--- /dev/null
+++ b/external/pybind11/docs/advanced/cast/custom.rst
@@ -0,0 +1,91 @@
+Custom type casters
+===================
+
+In very rare cases, applications may require custom type casters that cannot be
+expressed using the abstractions provided by pybind11, thus requiring raw
+Python C API calls. This is fairly advanced usage and should only be pursued by
+experts who are familiar with the intricacies of Python reference counting.
+
+The following snippets demonstrate how this works for a very simple ``inty``
+type that that should be convertible from Python types that provide a
+``__int__(self)`` method.
+
+.. code-block:: cpp
+
+ struct inty { long long_value; };
+
+ void print(inty s) {
+ std::cout << s.long_value << std::endl;
+ }
+
+The following Python snippet demonstrates the intended usage from the Python side:
+
+.. code-block:: python
+
+ class A:
+ def __int__(self):
+ return 123
+
+ from example import print
+ print(A())
+
+To register the necessary conversion routines, it is necessary to add
+a partial overload to the ``pybind11::detail::type_caster`` template.
+Although this is an implementation detail, adding partial overloads to this
+type is explicitly allowed.
+
+.. code-block:: cpp
+
+ namespace pybind11 { namespace detail {
+ template <> struct type_caster {
+ public:
+ /**
+ * This macro establishes the name 'inty' in
+ * function signatures and declares a local variable
+ * 'value' of type inty
+ */
+ PYBIND11_TYPE_CASTER(inty, _("inty"));
+
+ /**
+ * Conversion part 1 (Python->C++): convert a PyObject into a inty
+ * instance or return false upon failure. The second argument
+ * indicates whether implicit conversions should be applied.
+ */
+ bool load(handle src, bool) {
+ /* Extract PyObject from handle */
+ PyObject *source = src.ptr();
+ /* Try converting into a Python integer value */
+ PyObject *tmp = PyNumber_Long(source);
+ if (!tmp)
+ return false;
+ /* Now try to convert into a C++ int */
+ value.long_value = PyLong_AsLong(tmp);
+ Py_DECREF(tmp);
+ /* Ensure return code was OK (to avoid out-of-range errors etc) */
+ return !(value.long_value == -1 && !PyErr_Occurred());
+ }
+
+ /**
+ * Conversion part 2 (C++ -> Python): convert an inty instance into
+ * a Python object. The second and third arguments are used to
+ * indicate the return value policy and parent object (for
+ * ``return_value_policy::reference_internal``) and are generally
+ * ignored by implicit casters.
+ */
+ static handle cast(inty src, return_value_policy /* policy */, handle /* parent */) {
+ return PyLong_FromLong(src.long_value);
+ }
+ };
+ }} // namespace pybind11::detail
+
+.. note::
+
+ A ``type_caster`` defined with ``PYBIND11_TYPE_CASTER(T, ...)`` requires
+ that ``T`` is default-constructible (``value`` is first default constructed
+ and then ``load()`` assigns to it).
+
+.. warning::
+
+ When using custom type casters, it's important to declare them consistently
+ in every compilation unit of the Python extension module. Otherwise,
+ undefined behavior can ensue.
diff --git a/external/pybind11/docs/advanced/cast/eigen.rst b/external/pybind11/docs/advanced/cast/eigen.rst
new file mode 100644
index 0000000..acdb51d
--- /dev/null
+++ b/external/pybind11/docs/advanced/cast/eigen.rst
@@ -0,0 +1,310 @@
+Eigen
+#####
+
+`Eigen `_ is C++ header-based library for dense and
+sparse linear algebra. Due to its popularity and widespread adoption, pybind11
+provides transparent conversion and limited mapping support between Eigen and
+Scientific Python linear algebra data types.
+
+To enable the built-in Eigen support you must include the optional header file
+:file:`pybind11/eigen.h`.
+
+Pass-by-value
+=============
+
+When binding a function with ordinary Eigen dense object arguments (for
+example, ``Eigen::MatrixXd``), pybind11 will accept any input value that is
+already (or convertible to) a ``numpy.ndarray`` with dimensions compatible with
+the Eigen type, copy its values into a temporary Eigen variable of the
+appropriate type, then call the function with this temporary variable.
+
+Sparse matrices are similarly copied to or from
+``scipy.sparse.csr_matrix``/``scipy.sparse.csc_matrix`` objects.
+
+Pass-by-reference
+=================
+
+One major limitation of the above is that every data conversion implicitly
+involves a copy, which can be both expensive (for large matrices) and disallows
+binding functions that change their (Matrix) arguments. Pybind11 allows you to
+work around this by using Eigen's ``Eigen::Ref`` class much as you
+would when writing a function taking a generic type in Eigen itself (subject to
+some limitations discussed below).
+
+When calling a bound function accepting a ``Eigen::Ref``
+type, pybind11 will attempt to avoid copying by using an ``Eigen::Map`` object
+that maps into the source ``numpy.ndarray`` data: this requires both that the
+data types are the same (e.g. ``dtype='float64'`` and ``MatrixType::Scalar`` is
+``double``); and that the storage is layout compatible. The latter limitation
+is discussed in detail in the section below, and requires careful
+consideration: by default, numpy matrices and eigen matrices are *not* storage
+compatible.
+
+If the numpy matrix cannot be used as is (either because its types differ, e.g.
+passing an array of integers to an Eigen paramater requiring doubles, or
+because the storage is incompatible), pybind11 makes a temporary copy and
+passes the copy instead.
+
+When a bound function parameter is instead ``Eigen::Ref`` (note the
+lack of ``const``), pybind11 will only allow the function to be called if it
+can be mapped *and* if the numpy array is writeable (that is
+``a.flags.writeable`` is true). Any access (including modification) made to
+the passed variable will be transparently carried out directly on the
+``numpy.ndarray``.
+
+This means you can can write code such as the following and have it work as
+expected:
+
+.. code-block:: cpp
+
+ void scale_by_2(Eigen::Ref v) {
+ v *= 2;
+ }
+
+Note, however, that you will likely run into limitations due to numpy and
+Eigen's difference default storage order for data; see the below section on
+:ref:`storage_orders` for details on how to bind code that won't run into such
+limitations.
+
+.. note::
+
+ Passing by reference is not supported for sparse types.
+
+Returning values to Python
+==========================
+
+When returning an ordinary dense Eigen matrix type to numpy (e.g.
+``Eigen::MatrixXd`` or ``Eigen::RowVectorXf``) pybind11 keeps the matrix and
+returns a numpy array that directly references the Eigen matrix: no copy of the
+data is performed. The numpy array will have ``array.flags.owndata`` set to
+``False`` to indicate that it does not own the data, and the lifetime of the
+stored Eigen matrix will be tied to the returned ``array``.
+
+If you bind a function with a non-reference, ``const`` return type (e.g.
+``const Eigen::MatrixXd``), the same thing happens except that pybind11 also
+sets the numpy array's ``writeable`` flag to false.
+
+If you return an lvalue reference or pointer, the usual pybind11 rules apply,
+as dictated by the binding function's return value policy (see the
+documentation on :ref:`return_value_policies` for full details). That means,
+without an explicit return value policy, lvalue references will be copied and
+pointers will be managed by pybind11. In order to avoid copying, you should
+explictly specify an appropriate return value policy, as in the following
+example:
+
+.. code-block:: cpp
+
+ class MyClass {
+ Eigen::MatrixXd big_mat = Eigen::MatrixXd::Zero(10000, 10000);
+ public:
+ Eigen::MatrixXd &getMatrix() { return big_mat; }
+ const Eigen::MatrixXd &viewMatrix() { return big_mat; }
+ };
+
+ // Later, in binding code:
+ py::class_(m, "MyClass")
+ .def(py::init<>())
+ .def("copy_matrix", &MyClass::getMatrix) // Makes a copy!
+ .def("get_matrix", &MyClass::getMatrix, py::return_value_policy::reference_internal)
+ .def("view_matrix", &MyClass::viewMatrix, py::return_value_policy::reference_internal)
+ ;
+
+.. code-block:: python
+
+ a = MyClass()
+ m = a.get_matrix() # flags.writeable = True, flags.owndata = False
+ v = a.view_matrix() # flags.writeable = False, flags.owndata = False
+ c = a.copy_matrix() # flags.writeable = True, flags.owndata = True
+ # m[5,6] and v[5,6] refer to the same element, c[5,6] does not.
+
+Note in this example that ``py::return_value_policy::reference_internal`` is
+used to tie the life of the MyClass object to the life of the returned arrays.
+
+You may also return an ``Eigen::Ref``, ``Eigen::Map`` or other map-like Eigen
+object (for example, the return value of ``matrix.block()`` and related
+methods) that map into a dense Eigen type. When doing so, the default
+behaviour of pybind11 is to simply reference the returned data: you must take
+care to ensure that this data remains valid! You may ask pybind11 to
+explicitly *copy* such a return value by using the
+``py::return_value_policy::copy`` policy when binding the function. You may
+also use ``py::return_value_policy::reference_internal`` or a
+``py::keep_alive`` to ensure the data stays valid as long as the returned numpy
+array does.
+
+When returning such a reference of map, pybind11 additionally respects the
+readonly-status of the returned value, marking the numpy array as non-writeable
+if the reference or map was itself read-only.
+
+.. note::
+
+ Sparse types are always copied when returned.
+
+.. _storage_orders:
+
+Storage orders
+==============
+
+Passing arguments via ``Eigen::Ref`` has some limitations that you must be
+aware of in order to effectively pass matrices by reference. First and
+foremost is that the default ``Eigen::Ref`` class requires
+contiguous storage along columns (for column-major types, the default in Eigen)
+or rows if ``MatrixType`` is specifically an ``Eigen::RowMajor`` storage type.
+The former, Eigen's default, is incompatible with ``numpy``'s default row-major
+storage, and so you will not be able to pass numpy arrays to Eigen by reference
+without making one of two changes.
+
+(Note that this does not apply to vectors (or column or row matrices): for such
+types the "row-major" and "column-major" distinction is meaningless).
+
+The first approach is to change the use of ``Eigen::Ref`` to the
+more general ``Eigen::Ref>`` (or similar type with a fully dynamic stride type in the
+third template argument). Since this is a rather cumbersome type, pybind11
+provides a ``py::EigenDRef`` type alias for your convenience (along
+with EigenDMap for the equivalent Map, and EigenDStride for just the stride
+type).
+
+This type allows Eigen to map into any arbitrary storage order. This is not
+the default in Eigen for performance reasons: contiguous storage allows
+vectorization that cannot be done when storage is not known to be contiguous at
+compile time. The default ``Eigen::Ref`` stride type allows non-contiguous
+storage along the outer dimension (that is, the rows of a column-major matrix
+or columns of a row-major matrix), but not along the inner dimension.
+
+This type, however, has the added benefit of also being able to map numpy array
+slices. For example, the following (contrived) example uses Eigen with a numpy
+slice to multiply by 2 all coefficients that are both on even rows (0, 2, 4,
+...) and in columns 2, 5, or 8:
+
+.. code-block:: cpp
+
+ m.def("scale", [](py::EigenDRef m, double c) { m *= c; });
+
+.. code-block:: python
+
+ # a = np.array(...)
+ scale_by_2(myarray[0::2, 2:9:3])
+
+The second approach to avoid copying is more intrusive: rearranging the
+underlying data types to not run into the non-contiguous storage problem in the
+first place. In particular, that means using matrices with ``Eigen::RowMajor``
+storage, where appropriate, such as:
+
+.. code-block:: cpp
+
+ using RowMatrixXd = Eigen::Matrix;
+ // Use RowMatrixXd instead of MatrixXd
+
+Now bound functions accepting ``Eigen::Ref`` arguments will be
+callable with numpy's (default) arrays without involving a copying.
+
+You can, alternatively, change the storage order that numpy arrays use by
+adding the ``order='F'`` option when creating an array:
+
+.. code-block:: python
+
+ myarray = np.array(source, order='F')
+
+Such an object will be passable to a bound function accepting an
+``Eigen::Ref`` (or similar column-major Eigen type).
+
+One major caveat with this approach, however, is that it is not entirely as
+easy as simply flipping all Eigen or numpy usage from one to the other: some
+operations may alter the storage order of a numpy array. For example, ``a2 =
+array.transpose()`` results in ``a2`` being a view of ``array`` that references
+the same data, but in the opposite storage order!
+
+While this approach allows fully optimized vectorized calculations in Eigen, it
+cannot be used with array slices, unlike the first approach.
+
+When *returning* a matrix to Python (either a regular matrix, a reference via
+``Eigen::Ref<>``, or a map/block into a matrix), no special storage
+consideration is required: the created numpy array will have the required
+stride that allows numpy to properly interpret the array, whatever its storage
+order.
+
+Failing rather than copying
+===========================
+
+The default behaviour when binding ``Eigen::Ref`` eigen
+references is to copy matrix values when passed a numpy array that does not
+conform to the element type of ``MatrixType`` or does not have a compatible
+stride layout. If you want to explicitly avoid copying in such a case, you
+should bind arguments using the ``py::arg().noconvert()`` annotation (as
+described in the :ref:`nonconverting_arguments` documentation).
+
+The following example shows an example of arguments that don't allow data
+copying to take place:
+
+.. code-block:: cpp
+
+ // The method and function to be bound:
+ class MyClass {
+ // ...
+ double some_method(const Eigen::Ref &matrix) { /* ... */ }
+ };
+ float some_function(const Eigen::Ref &big,
+ const Eigen::Ref &small) {
+ // ...
+ }
+
+ // The associated binding code:
+ using namespace pybind11::literals; // for "arg"_a
+ py::class_(m, "MyClass")
+ // ... other class definitions
+ .def("some_method", &MyClass::some_method, py::arg().noconvert());
+
+ m.def("some_function", &some_function,
+ "big"_a.noconvert(), // <- Don't allow copying for this arg
+ "small"_a // <- This one can be copied if needed
+ );
+
+With the above binding code, attempting to call the the ``some_method(m)``
+method on a ``MyClass`` object, or attempting to call ``some_function(m, m2)``
+will raise a ``RuntimeError`` rather than making a temporary copy of the array.
+It will, however, allow the ``m2`` argument to be copied into a temporary if
+necessary.
+
+Note that explicitly specifying ``.noconvert()`` is not required for *mutable*
+Eigen references (e.g. ``Eigen::Ref`` without ``const`` on the
+``MatrixXd``): mutable references will never be called with a temporary copy.
+
+Vectors versus column/row matrices
+==================================
+
+Eigen and numpy have fundamentally different notions of a vector. In Eigen, a
+vector is simply a matrix with the number of columns or rows set to 1 at
+compile time (for a column vector or row vector, respectively). Numpy, in
+contast, has comparable 2-dimensional 1xN and Nx1 arrays, but *also* has
+1-dimensional arrays of size N.
+
+When passing a 2-dimensional 1xN or Nx1 array to Eigen, the Eigen type must
+have matching dimensions: That is, you cannot pass a 2-dimensional Nx1 numpy
+array to an Eigen value expecting a row vector, or a 1xN numpy array as a
+column vector argument.
+
+On the other hand, pybind11 allows you to pass 1-dimensional arrays of length N
+as Eigen parameters. If the Eigen type can hold a column vector of length N it
+will be passed as such a column vector. If not, but the Eigen type constraints
+will accept a row vector, it will be passed as a row vector. (The column
+vector takes precendence when both are supported, for example, when passing a
+1D numpy array to a MatrixXd argument). Note that the type need not be
+expicitly a vector: it is permitted to pass a 1D numpy array of size 5 to an
+Eigen ``Matrix``: you would end up with a 1x5 Eigen matrix.
+Passing the same to an ``Eigen::MatrixXd`` would result in a 5x1 Eigen matrix.
+
+When returning an eigen vector to numpy, the conversion is ambiguous: a row
+vector of length 4 could be returned as either a 1D array of length 4, or as a
+2D array of size 1x4. When encoutering such a situation, pybind11 compromises
+by considering the returned Eigen type: if it is a compile-time vector--that
+is, the type has either the number of rows or columns set to 1 at compile
+time--pybind11 converts to a 1D numpy array when returning the value. For
+instances that are a vector only at run-time (e.g. ``MatrixXd``,
+``Matrix``), pybind11 returns the vector as a 2D array to
+numpy. If this isn't want you want, you can use ``array.reshape(...)`` to get
+a view of the same data in the desired dimensions.
+
+.. seealso::
+
+ The file :file:`tests/test_eigen.cpp` contains a complete example that
+ shows how to pass Eigen sparse and dense data types in more detail.
diff --git a/external/pybind11/docs/advanced/cast/functional.rst b/external/pybind11/docs/advanced/cast/functional.rst
new file mode 100644
index 0000000..d9b4605
--- /dev/null
+++ b/external/pybind11/docs/advanced/cast/functional.rst
@@ -0,0 +1,109 @@
+Functional
+##########
+
+The following features must be enabled by including :file:`pybind11/functional.h`.
+
+
+Callbacks and passing anonymous functions
+=========================================
+
+The C++11 standard brought lambda functions and the generic polymorphic
+function wrapper ``std::function<>`` to the C++ programming language, which
+enable powerful new ways of working with functions. Lambda functions come in
+two flavors: stateless lambda function resemble classic function pointers that
+link to an anonymous piece of code, while stateful lambda functions
+additionally depend on captured variables that are stored in an anonymous
+*lambda closure object*.
+
+Here is a simple example of a C++ function that takes an arbitrary function
+(stateful or stateless) with signature ``int -> int`` as an argument and runs
+it with the value 10.
+
+.. code-block:: cpp
+
+ int func_arg(const std::function &f) {
+ return f(10);
+ }
+
+The example below is more involved: it takes a function of signature ``int -> int``
+and returns another function of the same kind. The return value is a stateful
+lambda function, which stores the value ``f`` in the capture object and adds 1 to
+its return value upon execution.
+
+.. code-block:: cpp
+
+ std::function func_ret(const std::function &f) {
+ return [f](int i) {
+ return f(i) + 1;
+ };
+ }
+
+This example demonstrates using python named parameters in C++ callbacks which
+requires using ``py::cpp_function`` as a wrapper. Usage is similar to defining
+methods of classes:
+
+.. code-block:: cpp
+
+ py::cpp_function func_cpp() {
+ return py::cpp_function([](int i) { return i+1; },
+ py::arg("number"));
+ }
+
+After including the extra header file :file:`pybind11/functional.h`, it is almost
+trivial to generate binding code for all of these functions.
+
+.. code-block:: cpp
+
+ #include
+
+ PYBIND11_MODULE(example, m) {
+ m.def("func_arg", &func_arg);
+ m.def("func_ret", &func_ret);
+ m.def("func_cpp", &func_cpp);
+ }
+
+The following interactive session shows how to call them from Python.
+
+.. code-block:: pycon
+
+ $ python
+ >>> import example
+ >>> def square(i):
+ ... return i * i
+ ...
+ >>> example.func_arg(square)
+ 100L
+ >>> square_plus_1 = example.func_ret(square)
+ >>> square_plus_1(4)
+ 17L
+ >>> plus_1 = func_cpp()
+ >>> plus_1(number=43)
+ 44L
+
+.. warning::
+
+ Keep in mind that passing a function from C++ to Python (or vice versa)
+ will instantiate a piece of wrapper code that translates function
+ invocations between the two languages. Naturally, this translation
+ increases the computational cost of each function call somewhat. A
+ problematic situation can arise when a function is copied back and forth
+ between Python and C++ many times in a row, in which case the underlying
+ wrappers will accumulate correspondingly. The resulting long sequence of
+ C++ -> Python -> C++ -> ... roundtrips can significantly decrease
+ performance.
+
+ There is one exception: pybind11 detects case where a stateless function
+ (i.e. a function pointer or a lambda function without captured variables)
+ is passed as an argument to another C++ function exposed in Python. In this
+ case, there is no overhead. Pybind11 will extract the underlying C++
+ function pointer from the wrapped function to sidestep a potential C++ ->
+ Python -> C++ roundtrip. This is demonstrated in :file:`tests/test_callbacks.cpp`.
+
+.. note::
+
+ This functionality is very useful when generating bindings for callbacks in
+ C++ libraries (e.g. GUI libraries, asynchronous networking libraries, etc.).
+
+ The file :file:`tests/test_callbacks.cpp` contains a complete example
+ that demonstrates how to work with callbacks and anonymous functions in
+ more detail.
diff --git a/external/pybind11/docs/advanced/cast/index.rst b/external/pybind11/docs/advanced/cast/index.rst
new file mode 100644
index 0000000..54c1057
--- /dev/null
+++ b/external/pybind11/docs/advanced/cast/index.rst
@@ -0,0 +1,42 @@
+Type conversions
+################
+
+Apart from enabling cross-language function calls, a fundamental problem
+that a binding tool like pybind11 must address is to provide access to
+native Python types in C++ and vice versa. There are three fundamentally
+different ways to do this—which approach is preferable for a particular type
+depends on the situation at hand.
+
+1. Use a native C++ type everywhere. In this case, the type must be wrapped
+ using pybind11-generated bindings so that Python can interact with it.
+
+2. Use a native Python type everywhere. It will need to be wrapped so that
+ C++ functions can interact with it.
+
+3. Use a native C++ type on the C++ side and a native Python type on the
+ Python side. pybind11 refers to this as a *type conversion*.
+
+ Type conversions are the most "natural" option in the sense that native
+ (non-wrapped) types are used everywhere. The main downside is that a copy
+ of the data must be made on every Python ↔ C++ transition: this is
+ needed since the C++ and Python versions of the same type generally won't
+ have the same memory layout.
+
+ pybind11 can perform many kinds of conversions automatically. An overview
+ is provided in the table ":ref:`conversion_table`".
+
+The following subsections discuss the differences between these options in more
+detail. The main focus in this section is on type conversions, which represent
+the last case of the above list.
+
+.. toctree::
+ :maxdepth: 1
+
+ overview
+ strings
+ stl
+ functional
+ chrono
+ eigen
+ custom
+
diff --git a/external/pybind11/docs/advanced/cast/overview.rst b/external/pybind11/docs/advanced/cast/overview.rst
new file mode 100644
index 0000000..2ac7d30
--- /dev/null
+++ b/external/pybind11/docs/advanced/cast/overview.rst
@@ -0,0 +1,163 @@
+Overview
+########
+
+.. rubric:: 1. Native type in C++, wrapper in Python
+
+Exposing a custom C++ type using :class:`py::class_` was covered in detail
+in the :doc:`/classes` section. There, the underlying data structure is
+always the original C++ class while the :class:`py::class_` wrapper provides
+a Python interface. Internally, when an object like this is sent from C++ to
+Python, pybind11 will just add the outer wrapper layer over the native C++
+object. Getting it back from Python is just a matter of peeling off the
+wrapper.
+
+.. rubric:: 2. Wrapper in C++, native type in Python
+
+This is the exact opposite situation. Now, we have a type which is native to
+Python, like a ``tuple`` or a ``list``. One way to get this data into C++ is
+with the :class:`py::object` family of wrappers. These are explained in more
+detail in the :doc:`/advanced/pycpp/object` section. We'll just give a quick
+example here:
+
+.. code-block:: cpp
+
+ void print_list(py::list my_list) {
+ for (auto item : my_list)
+ std::cout << item << " ";
+ }
+
+.. code-block:: pycon
+
+ >>> print_list([1, 2, 3])
+ 1 2 3
+
+The Python ``list`` is not converted in any way -- it's just wrapped in a C++
+:class:`py::list` class. At its core it's still a Python object. Copying a
+:class:`py::list` will do the usual reference-counting like in Python.
+Returning the object to Python will just remove the thin wrapper.
+
+.. rubric:: 3. Converting between native C++ and Python types
+
+In the previous two cases we had a native type in one language and a wrapper in
+the other. Now, we have native types on both sides and we convert between them.
+
+.. code-block:: cpp
+
+ void print_vector(const std::vector &v) {
+ for (auto item : v)
+ std::cout << item << "\n";
+ }
+
+.. code-block:: pycon
+
+ >>> print_vector([1, 2, 3])
+ 1 2 3
+
+In this case, pybind11 will construct a new ``std::vector`` and copy each
+element from the Python ``list``. The newly constructed object will be passed
+to ``print_vector``. The same thing happens in the other direction: a new
+``list`` is made to match the value returned from C++.
+
+Lots of these conversions are supported out of the box, as shown in the table
+below. They are very convenient, but keep in mind that these conversions are
+fundamentally based on copying data. This is perfectly fine for small immutable
+types but it may become quite expensive for large data structures. This can be
+avoided by overriding the automatic conversion with a custom wrapper (i.e. the
+above-mentioned approach 1). This requires some manual effort and more details
+are available in the :ref:`opaque` section.
+
+.. _conversion_table:
+
+List of all builtin conversions
+-------------------------------
+
+The following basic data types are supported out of the box (some may require
+an additional extension header to be included). To pass other data structures
+as arguments and return values, refer to the section on binding :ref:`classes`.
+
++------------------------------------+---------------------------+-------------------------------+
+| Data type | Description | Header file |
++====================================+===========================+===============================+
+| ``int8_t``, ``uint8_t`` | 8-bit integers | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``int16_t``, ``uint16_t`` | 16-bit integers | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``int32_t``, ``uint32_t`` | 32-bit integers | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``int64_t``, ``uint64_t`` | 64-bit integers | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``ssize_t``, ``size_t`` | Platform-dependent size | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``float``, ``double`` | Floating point types | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``bool`` | Two-state Boolean type | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``char`` | Character literal | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``char16_t`` | UTF-16 character literal | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``char32_t`` | UTF-32 character literal | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``wchar_t`` | Wide character literal | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``const char *`` | UTF-8 string literal | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``const char16_t *`` | UTF-16 string literal | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``const char32_t *`` | UTF-32 string literal | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``const wchar_t *`` | Wide string literal | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::string`` | STL dynamic UTF-8 string | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::u16string`` | STL dynamic UTF-16 string | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::u32string`` | STL dynamic UTF-32 string | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::wstring`` | STL dynamic wide string | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::string_view``, | STL C++17 string views | :file:`pybind11/pybind11.h` |
+| ``std::u16string_view``, etc. | | |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::pair`` | Pair of two custom types | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::tuple<...>`` | Arbitrary tuple of types | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::reference_wrapper<...>`` | Reference type wrapper | :file:`pybind11/pybind11.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::complex`` | Complex numbers | :file:`pybind11/complex.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::array`` | STL static array | :file:`pybind11/stl.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::vector`` | STL dynamic array | :file:`pybind11/stl.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::valarray`` | STL value array | :file:`pybind11/stl.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::list`` | STL linked list | :file:`pybind11/stl.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::map`` | STL ordered map | :file:`pybind11/stl.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::unordered_map`` | STL unordered map | :file:`pybind11/stl.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::set`` | STL ordered set | :file:`pybind11/stl.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::unordered_set`` | STL unordered set | :file:`pybind11/stl.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::optional`` | STL optional type (C++17) | :file:`pybind11/stl.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::experimental::optional`` | STL optional type (exp.) | :file:`pybind11/stl.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::variant<...>`` | Type-safe union (C++17) | :file:`pybind11/stl.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::function<...>`` | STL polymorphic function | :file:`pybind11/functional.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::chrono::duration<...>`` | STL time duration | :file:`pybind11/chrono.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``std::chrono::time_point<...>`` | STL date/time | :file:`pybind11/chrono.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``Eigen::Matrix<...>`` | Eigen: dense matrix | :file:`pybind11/eigen.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``Eigen::Map<...>`` | Eigen: mapped memory | :file:`pybind11/eigen.h` |
++------------------------------------+---------------------------+-------------------------------+
+| ``Eigen::SparseMatrix<...>`` | Eigen: sparse matrix | :file:`pybind11/eigen.h` |
++------------------------------------+---------------------------+-------------------------------+
diff --git a/external/pybind11/docs/advanced/cast/stl.rst b/external/pybind11/docs/advanced/cast/stl.rst
new file mode 100644
index 0000000..3f30c02
--- /dev/null
+++ b/external/pybind11/docs/advanced/cast/stl.rst
@@ -0,0 +1,243 @@
+STL containers
+##############
+
+Automatic conversion
+====================
+
+When including the additional header file :file:`pybind11/stl.h`, conversions
+between ``std::vector<>``/``std::list<>``/``std::array<>``,
+``std::set<>``/``std::unordered_set<>``, and
+``std::map<>``/``std::unordered_map<>`` and the Python ``list``, ``set`` and
+``dict`` data structures are automatically enabled. The types ``std::pair<>``
+and ``std::tuple<>`` are already supported out of the box with just the core
+:file:`pybind11/pybind11.h` header.
+
+The major downside of these implicit conversions is that containers must be
+converted (i.e. copied) on every Python->C++ and C++->Python transition, which
+can have implications on the program semantics and performance. Please read the
+next sections for more details and alternative approaches that avoid this.
+
+.. note::
+
+ Arbitrary nesting of any of these types is possible.
+
+.. seealso::
+
+ The file :file:`tests/test_stl.cpp` contains a complete
+ example that demonstrates how to pass STL data types in more detail.
+
+.. _cpp17_container_casters:
+
+C++17 library containers
+========================
+
+The :file:`pybind11/stl.h` header also includes support for ``std::optional<>``
+and ``std::variant<>``. These require a C++17 compiler and standard library.
+In C++14 mode, ``std::experimental::optional<>`` is supported if available.
+
+Various versions of these containers also exist for C++11 (e.g. in Boost).
+pybind11 provides an easy way to specialize the ``type_caster`` for such
+types:
+
+.. code-block:: cpp
+
+ // `boost::optional` as an example -- can be any `std::optional`-like container
+ namespace pybind11 { namespace detail {
+ template
+ struct type_caster> : optional_caster> {};
+ }}
+
+The above should be placed in a header file and included in all translation units
+where automatic conversion is needed. Similarly, a specialization can be provided
+for custom variant types:
+
+.. code-block:: cpp
+
+ // `boost::variant` as an example -- can be any `std::variant`-like container
+ namespace pybind11 { namespace detail {
+ template
+ struct type_caster> : variant_caster> {};
+
+ // Specifies the function used to visit the variant -- `apply_visitor` instead of `visit`
+ template <>
+ struct visit_helper {
+ template
+ static auto call(Args &&...args) -> decltype(boost::apply_visitor(args...)) {
+ return boost::apply_visitor(args...);
+ }
+ };
+ }} // namespace pybind11::detail
+
+The ``visit_helper`` specialization is not required if your ``name::variant`` provides
+a ``name::visit()`` function. For any other function name, the specialization must be
+included to tell pybind11 how to visit the variant.
+
+.. note::
+
+ pybind11 only supports the modern implementation of ``boost::variant``
+ which makes use of variadic templates. This requires Boost 1.56 or newer.
+ Additionally, on Windows, MSVC 2017 is required because ``boost::variant``
+ falls back to the old non-variadic implementation on MSVC 2015.
+
+.. _opaque:
+
+Making opaque types
+===================
+
+pybind11 heavily relies on a template matching mechanism to convert parameters
+and return values that are constructed from STL data types such as vectors,
+linked lists, hash tables, etc. This even works in a recursive manner, for
+instance to deal with lists of hash maps of pairs of elementary and custom
+types, etc.
+
+However, a fundamental limitation of this approach is that internal conversions
+between Python and C++ types involve a copy operation that prevents
+pass-by-reference semantics. What does this mean?
+
+Suppose we bind the following function
+
+.. code-block:: cpp
+
+ void append_1(std::vector &v) {
+ v.push_back(1);
+ }
+
+and call it from Python, the following happens:
+
+.. code-block:: pycon
+
+ >>> v = [5, 6]
+ >>> append_1(v)
+ >>> print(v)
+ [5, 6]
+
+As you can see, when passing STL data structures by reference, modifications
+are not propagated back the Python side. A similar situation arises when
+exposing STL data structures using the ``def_readwrite`` or ``def_readonly``
+functions:
+
+.. code-block:: cpp
+
+ /* ... definition ... */
+
+ class MyClass {
+ std::vector contents;
+ };
+
+ /* ... binding code ... */
+
+ py::class_(m, "MyClass")
+ .def(py::init<>())
+ .def_readwrite("contents", &MyClass::contents);
+
+In this case, properties can be read and written in their entirety. However, an
+``append`` operation involving such a list type has no effect:
+
+.. code-block:: pycon
+
+ >>> m = MyClass()
+ >>> m.contents = [5, 6]
+ >>> print(m.contents)
+ [5, 6]
+ >>> m.contents.append(7)
+ >>> print(m.contents)
+ [5, 6]
+
+Finally, the involved copy operations can be costly when dealing with very
+large lists. To deal with all of the above situations, pybind11 provides a
+macro named ``PYBIND11_MAKE_OPAQUE(T)`` that disables the template-based
+conversion machinery of types, thus rendering them *opaque*. The contents of
+opaque objects are never inspected or extracted, hence they *can* be passed by
+reference. For instance, to turn ``std::vector`` into an opaque type, add
+the declaration
+
+.. code-block:: cpp
+
+ PYBIND11_MAKE_OPAQUE(std::vector);
+
+before any binding code (e.g. invocations to ``class_::def()``, etc.). This
+macro must be specified at the top level (and outside of any namespaces), since
+it instantiates a partial template overload. If your binding code consists of
+multiple compilation units, it must be present in every file (typically via a
+common header) preceding any usage of ``std::vector``. Opaque types must
+also have a corresponding ``class_`` declaration to associate them with a name
+in Python, and to define a set of available operations, e.g.:
+
+.. code-block:: cpp
+
+ py::class_>(m, "IntVector")
+ .def(py::init<>())
+ .def("clear", &std::vector::clear)
+ .def("pop_back", &std::vector::pop_back)
+ .def("__len__", [](const std::vector &v) { return v.size(); })
+ .def("__iter__", [](std::vector &v) {
+ return py::make_iterator(v.begin(), v.end());
+ }, py::keep_alive<0, 1>()) /* Keep vector alive while iterator is used */
+ // ....
+
+Please take a look at the :ref:`macro_notes` before using the
+``PYBIND11_MAKE_OPAQUE`` macro.
+
+.. seealso::
+
+ The file :file:`tests/test_opaque_types.cpp` contains a complete
+ example that demonstrates how to create and expose opaque types using
+ pybind11 in more detail.
+
+.. _stl_bind:
+
+Binding STL containers
+======================
+
+The ability to expose STL containers as native Python objects is a fairly
+common request, hence pybind11 also provides an optional header file named
+:file:`pybind11/stl_bind.h` that does exactly this. The mapped containers try
+to match the behavior of their native Python counterparts as much as possible.
+
+The following example showcases usage of :file:`pybind11/stl_bind.h`:
+
+.. code-block:: cpp
+
+ // Don't forget this
+ #include
+
+ PYBIND11_MAKE_OPAQUE(std::vector);
+ PYBIND11_MAKE_OPAQUE(std::map);
+
+ // ...
+
+ // later in binding code:
+ py::bind_vector>(m, "VectorInt");
+ py::bind_map>(m, "MapStringDouble");
+
+When binding STL containers pybind11 considers the types of the container's
+elements to decide whether the container should be confined to the local module
+(via the :ref:`module_local` feature). If the container element types are
+anything other than already-bound custom types bound without
+``py::module_local()`` the container binding will have ``py::module_local()``
+applied. This includes converting types such as numeric types, strings, Eigen
+types; and types that have not yet been bound at the time of the stl container
+binding. This module-local binding is designed to avoid potential conflicts
+between module bindings (for example, from two separate modules each attempting
+to bind ``std::vector`` as a python type).
+
+It is possible to override this behavior to force a definition to be either
+module-local or global. To do so, you can pass the attributes
+``py::module_local()`` (to make the binding module-local) or
+``py::module_local(false)`` (to make the binding global) into the
+``py::bind_vector`` or ``py::bind_map`` arguments:
+
+.. code-block:: cpp
+
+ py::bind_vector>(m, "VectorInt", py::module_local(false));
+
+Note, however, that such a global binding would make it impossible to load this
+module at the same time as any other pybind module that also attempts to bind
+the same container type (``std::vector`` in the above example).
+
+See :ref:`module_local` for more details on module-local bindings.
+
+.. seealso::
+
+ The file :file:`tests/test_stl_binders.cpp` shows how to use the
+ convenience STL container wrappers.
diff --git a/external/pybind11/docs/advanced/cast/strings.rst b/external/pybind11/docs/advanced/cast/strings.rst
new file mode 100644
index 0000000..2cdbade
--- /dev/null
+++ b/external/pybind11/docs/advanced/cast/strings.rst
@@ -0,0 +1,303 @@
+Strings, bytes and Unicode conversions
+######################################
+
+.. note::
+
+ This section discusses string handling in terms of Python 3 strings. For
+ Python 2.7, replace all occurrences of ``str`` with ``unicode`` and
+ ``bytes`` with ``str``. Python 2.7 users may find it best to use ``from
+ __future__ import unicode_literals`` to avoid unintentionally using ``str``
+ instead of ``unicode``.
+
+Passing Python strings to C++
+=============================
+
+When a Python ``str`` is passed from Python to a C++ function that accepts
+``std::string`` or ``char *`` as arguments, pybind11 will encode the Python
+string to UTF-8. All Python ``str`` can be encoded in UTF-8, so this operation
+does not fail.
+
+The C++ language is encoding agnostic. It is the responsibility of the
+programmer to track encodings. It's often easiest to simply `use UTF-8
+everywhere `_.
+
+.. code-block:: c++
+
+ m.def("utf8_test",
+ [](const std::string &s) {
+ cout << "utf-8 is icing on the cake.\n";
+ cout << s;
+ }
+ );
+ m.def("utf8_charptr",
+ [](const char *s) {
+ cout << "My favorite food is\n";
+ cout << s;
+ }
+ );
+
+.. code-block:: python
+
+ >>> utf8_test('🎂')
+ utf-8 is icing on the cake.
+ 🎂
+
+ >>> utf8_charptr('🍕')
+ My favorite food is
+ 🍕
+
+.. note::
+
+ Some terminal emulators do not support UTF-8 or emoji fonts and may not
+ display the example above correctly.
+
+The results are the same whether the C++ function accepts arguments by value or
+reference, and whether or not ``const`` is used.
+
+Passing bytes to C++
+--------------------
+
+A Python ``bytes`` object will be passed to C++ functions that accept
+``std::string`` or ``char*`` *without* conversion.
+
+
+Returning C++ strings to Python
+===============================
+
+When a C++ function returns a ``std::string`` or ``char*`` to a Python caller,
+**pybind11 will assume that the string is valid UTF-8** and will decode it to a
+native Python ``str``, using the same API as Python uses to perform
+``bytes.decode('utf-8')``. If this implicit conversion fails, pybind11 will
+raise a ``UnicodeDecodeError``.
+
+.. code-block:: c++
+
+ m.def("std_string_return",
+ []() {
+ return std::string("This string needs to be UTF-8 encoded");
+ }
+ );
+
+.. code-block:: python
+
+ >>> isinstance(example.std_string_return(), str)
+ True
+
+
+Because UTF-8 is inclusive of pure ASCII, there is never any issue with
+returning a pure ASCII string to Python. If there is any possibility that the
+string is not pure ASCII, it is necessary to ensure the encoding is valid
+UTF-8.
+
+.. warning::
+
+ Implicit conversion assumes that a returned ``char *`` is null-terminated.
+ If there is no null terminator a buffer overrun will occur.
+
+Explicit conversions
+--------------------
+
+If some C++ code constructs a ``std::string`` that is not a UTF-8 string, one
+can perform a explicit conversion and return a ``py::str`` object. Explicit
+conversion has the same overhead as implicit conversion.
+
+.. code-block:: c++
+
+ // This uses the Python C API to convert Latin-1 to Unicode
+ m.def("str_output",
+ []() {
+ std::string s = "Send your r\xe9sum\xe9 to Alice in HR"; // Latin-1
+ py::str py_s = PyUnicode_DecodeLatin1(s.data(), s.length());
+ return py_s;
+ }
+ );
+
+.. code-block:: python
+
+ >>> str_output()
+ 'Send your résumé to Alice in HR'
+
+The `Python C API
+`_ provides
+several built-in codecs.
+
+
+One could also use a third party encoding library such as libiconv to transcode
+to UTF-8.
+
+Return C++ strings without conversion
+-------------------------------------
+
+If the data in a C++ ``std::string`` does not represent text and should be
+returned to Python as ``bytes``, then one can return the data as a
+``py::bytes`` object.
+
+.. code-block:: c++
+
+ m.def("return_bytes",
+ []() {
+ std::string s("\xba\xd0\xba\xd0"); // Not valid UTF-8
+ return py::bytes(s); // Return the data without transcoding
+ }
+ );
+
+.. code-block:: python
+
+ >>> example.return_bytes()
+ b'\xba\xd0\xba\xd0'
+
+
+Note the asymmetry: pybind11 will convert ``bytes`` to ``std::string`` without
+encoding, but cannot convert ``std::string`` back to ``bytes`` implicitly.
+
+.. code-block:: c++
+
+ m.def("asymmetry",
+ [](std::string s) { // Accepts str or bytes from Python
+ return s; // Looks harmless, but implicitly converts to str
+ }
+ );
+
+.. code-block:: python
+
+ >>> isinstance(example.asymmetry(b"have some bytes"), str)
+ True
+
+ >>> example.asymmetry(b"\xba\xd0\xba\xd0") # invalid utf-8 as bytes
+ UnicodeDecodeError: 'utf-8' codec can't decode byte 0xba in position 0: invalid start byte
+
+
+Wide character strings
+======================
+
+When a Python ``str`` is passed to a C++ function expecting ``std::wstring``,
+``wchar_t*``, ``std::u16string`` or ``std::u32string``, the ``str`` will be
+encoded to UTF-16 or UTF-32 depending on how the C++ compiler implements each
+type, in the platform's native endianness. When strings of these types are
+returned, they are assumed to contain valid UTF-16 or UTF-32, and will be
+decoded to Python ``str``.
+
+.. code-block:: c++
+
+ #define UNICODE
+ #include
+
+ m.def("set_window_text",
+ [](HWND hwnd, std::wstring s) {
+ // Call SetWindowText with null-terminated UTF-16 string
+ ::SetWindowText(hwnd, s.c_str());
+ }
+ );
+ m.def("get_window_text",
+ [](HWND hwnd) {
+ const int buffer_size = ::GetWindowTextLength(hwnd) + 1;
+ auto buffer = std::make_unique< wchar_t[] >(buffer_size);
+
+ ::GetWindowText(hwnd, buffer.data(), buffer_size);
+
+ std::wstring text(buffer.get());
+
+ // wstring will be converted to Python str
+ return text;
+ }
+ );
+
+.. warning::
+
+ Wide character strings may not work as described on Python 2.7 or Python
+ 3.3 compiled with ``--enable-unicode=ucs2``.
+
+Strings in multibyte encodings such as Shift-JIS must transcoded to a
+UTF-8/16/32 before being returned to Python.
+
+
+Character literals
+==================
+
+C++ functions that accept character literals as input will receive the first
+character of a Python ``str`` as their input. If the string is longer than one
+Unicode character, trailing characters will be ignored.
+
+When a character literal is returned from C++ (such as a ``char`` or a
+``wchar_t``), it will be converted to a ``str`` that represents the single
+character.
+
+.. code-block:: c++
+
+ m.def("pass_char", [](char c) { return c; });
+ m.def("pass_wchar", [](wchar_t w) { return w; });
+
+.. code-block:: python
+
+ >>> example.pass_char('A')
+ 'A'
+
+While C++ will cast integers to character types (``char c = 0x65;``), pybind11
+does not convert Python integers to characters implicitly. The Python function
+``chr()`` can be used to convert integers to characters.
+
+.. code-block:: python
+
+ >>> example.pass_char(0x65)
+ TypeError
+
+ >>> example.pass_char(chr(0x65))
+ 'A'
+
+If the desire is to work with an 8-bit integer, use ``int8_t`` or ``uint8_t``
+as the argument type.
+
+Grapheme clusters
+-----------------
+
+A single grapheme may be represented by two or more Unicode characters. For
+example 'é' is usually represented as U+00E9 but can also be expressed as the
+combining character sequence U+0065 U+0301 (that is, the letter 'e' followed by
+a combining acute accent). The combining character will be lost if the
+two-character sequence is passed as an argument, even though it renders as a
+single grapheme.
+
+.. code-block:: python
+
+ >>> example.pass_wchar('é')
+ 'é'
+
+ >>> combining_e_acute = 'e' + '\u0301'
+
+ >>> combining_e_acute
+ 'é'
+
+ >>> combining_e_acute == 'é'
+ False
+
+ >>> example.pass_wchar(combining_e_acute)
+ 'e'
+
+Normalizing combining characters before passing the character literal to C++
+may resolve *some* of these issues:
+
+.. code-block:: python
+
+ >>> example.pass_wchar(unicodedata.normalize('NFC', combining_e_acute))
+ 'é'
+
+In some languages (Thai for example), there are `graphemes that cannot be
+expressed as a single Unicode code point
+`_, so there is
+no way to capture them in a C++ character type.
+
+
+C++17 string views
+==================
+
+C++17 string views are automatically supported when compiling in C++17 mode.
+They follow the same rules for encoding and decoding as the corresponding STL
+string type (for example, a ``std::u16string_view`` argument will be passed
+UTF-16-encoded data, and a returned ``std::string_view`` will be decoded as
+UTF-8).
+
+References
+==========
+
+* `The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!) `_
+* `C++ - Using STL Strings at Win32 API Boundaries `_
diff --git a/external/pybind11/docs/advanced/classes.rst b/external/pybind11/docs/advanced/classes.rst
new file mode 100644
index 0000000..93deeec
--- /dev/null
+++ b/external/pybind11/docs/advanced/classes.rst
@@ -0,0 +1,1001 @@
+Classes
+#######
+
+This section presents advanced binding code for classes and it is assumed
+that you are already familiar with the basics from :doc:`/classes`.
+
+.. _overriding_virtuals:
+
+Overriding virtual functions in Python
+======================================
+
+Suppose that a C++ class or interface has a virtual function that we'd like to
+to override from within Python (we'll focus on the class ``Animal``; ``Dog`` is
+given as a specific example of how one would do this with traditional C++
+code).
+
+.. code-block:: cpp
+
+ class Animal {
+ public:
+ virtual ~Animal() { }
+ virtual std::string go(int n_times) = 0;
+ };
+
+ class Dog : public Animal {
+ public:
+ std::string go(int n_times) override {
+ std::string result;
+ for (int i=0; igo(3);
+ }
+
+Normally, the binding code for these classes would look as follows:
+
+.. code-block:: cpp
+
+ PYBIND11_MODULE(example, m) {
+ py::class_ animal(m, "Animal");
+ animal
+ .def("go", &Animal::go);
+
+ py::class_(m, "Dog", animal)
+ .def(py::init<>());
+
+ m.def("call_go", &call_go);
+ }
+
+However, these bindings are impossible to extend: ``Animal`` is not
+constructible, and we clearly require some kind of "trampoline" that
+redirects virtual calls back to Python.
+
+Defining a new type of ``Animal`` from within Python is possible but requires a
+helper class that is defined as follows:
+
+.. code-block:: cpp
+
+ class PyAnimal : public Animal {
+ public:
+ /* Inherit the constructors */
+ using Animal::Animal;
+
+ /* Trampoline (need one for each virtual function) */
+ std::string go(int n_times) override {
+ PYBIND11_OVERLOAD_PURE(
+ std::string, /* Return type */
+ Animal, /* Parent class */
+ go, /* Name of function in C++ (must match Python name) */
+ n_times /* Argument(s) */
+ );
+ }
+ };
+
+The macro :func:`PYBIND11_OVERLOAD_PURE` should be used for pure virtual
+functions, and :func:`PYBIND11_OVERLOAD` should be used for functions which have
+a default implementation. There are also two alternate macros
+:func:`PYBIND11_OVERLOAD_PURE_NAME` and :func:`PYBIND11_OVERLOAD_NAME` which
+take a string-valued name argument between the *Parent class* and *Name of the
+function* slots, which defines the name of function in Python. This is required
+when the C++ and Python versions of the
+function have different names, e.g. ``operator()`` vs ``__call__``.
+
+The binding code also needs a few minor adaptations (highlighted):
+
+.. code-block:: cpp
+ :emphasize-lines: 2,4,5
+
+ PYBIND11_MODULE(example, m) {
+ py::class_ animal(m, "Animal");
+ animal
+ .def(py::init<>())
+ .def("go", &Animal::go);
+
+ py::class_(m, "Dog", animal)
+ .def(py::init<>());
+
+ m.def("call_go", &call_go);
+ }
+
+Importantly, pybind11 is made aware of the trampoline helper class by
+specifying it as an extra template argument to :class:`class_`. (This can also
+be combined with other template arguments such as a custom holder type; the
+order of template types does not matter). Following this, we are able to
+define a constructor as usual.
+
+Bindings should be made against the actual class, not the trampoline helper class.
+
+.. code-block:: cpp
+
+ py::class_ animal(m, "Animal");
+ animal
+ .def(py::init<>())
+ .def("go", &PyAnimal::go); /* <--- THIS IS WRONG, use &Animal::go */
+
+Note, however, that the above is sufficient for allowing python classes to
+extend ``Animal``, but not ``Dog``: see :ref:`virtual_and_inheritance` for the
+necessary steps required to providing proper overload support for inherited
+classes.
+
+The Python session below shows how to override ``Animal::go`` and invoke it via
+a virtual method call.
+
+.. code-block:: pycon
+
+ >>> from example import *
+ >>> d = Dog()
+ >>> call_go(d)
+ u'woof! woof! woof! '
+ >>> class Cat(Animal):
+ ... def go(self, n_times):
+ ... return "meow! " * n_times
+ ...
+ >>> c = Cat()
+ >>> call_go(c)
+ u'meow! meow! meow! '
+
+If you are defining a custom constructor in a derived Python class, you *must*
+ensure that you explicitly call the bound C++ constructor using ``__init__``,
+*regardless* of whether it is a default constructor or not. Otherwise, the
+memory for the C++ portion of the instance will be left uninitialized, which
+will generally leave the C++ instance in an invalid state and cause undefined
+behavior if the C++ instance is subsequently used.
+
+Here is an example:
+
+.. code-block:: python
+
+ class Dachschund(Dog):
+ def __init__(self, name):
+ Dog.__init__(self) # Without this, undefind behavior may occur if the C++ portions are referenced.
+ self.name = name
+ def bark(self):
+ return "yap!"
+
+Note that a direct ``__init__`` constructor *should be called*, and ``super()``
+should not be used. For simple cases of linear inheritance, ``super()``
+may work, but once you begin mixing Python and C++ multiple inheritance,
+things will fall apart due to differences between Python's MRO and C++'s
+mechanisms.
+
+Please take a look at the :ref:`macro_notes` before using this feature.
+
+.. note::
+
+ When the overridden type returns a reference or pointer to a type that
+ pybind11 converts from Python (for example, numeric values, std::string,
+ and other built-in value-converting types), there are some limitations to
+ be aware of:
+
+ - because in these cases there is no C++ variable to reference (the value
+ is stored in the referenced Python variable), pybind11 provides one in
+ the PYBIND11_OVERLOAD macros (when needed) with static storage duration.
+ Note that this means that invoking the overloaded method on *any*
+ instance will change the referenced value stored in *all* instances of
+ that type.
+
+ - Attempts to modify a non-const reference will not have the desired
+ effect: it will change only the static cache variable, but this change
+ will not propagate to underlying Python instance, and the change will be
+ replaced the next time the overload is invoked.
+
+.. seealso::
+
+ The file :file:`tests/test_virtual_functions.cpp` contains a complete
+ example that demonstrates how to override virtual functions using pybind11
+ in more detail.
+
+.. _virtual_and_inheritance:
+
+Combining virtual functions and inheritance
+===========================================
+
+When combining virtual methods with inheritance, you need to be sure to provide
+an override for each method for which you want to allow overrides from derived
+python classes. For example, suppose we extend the above ``Animal``/``Dog``
+example as follows:
+
+.. code-block:: cpp
+
+ class Animal {
+ public:
+ virtual std::string go(int n_times) = 0;
+ virtual std::string name() { return "unknown"; }
+ };
+ class Dog : public Animal {
+ public:
+ std::string go(int n_times) override {
+ std::string result;
+ for (int i=0; i class PyAnimal : public AnimalBase {
+ public:
+ using AnimalBase::AnimalBase; // Inherit constructors
+ std::string go(int n_times) override { PYBIND11_OVERLOAD_PURE(std::string, AnimalBase, go, n_times); }
+ std::string name() override { PYBIND11_OVERLOAD(std::string, AnimalBase, name, ); }
+ };
+ template class PyDog : public PyAnimal {
+ public:
+ using PyAnimal::PyAnimal; // Inherit constructors
+ // Override PyAnimal's pure virtual go() with a non-pure one:
+ std::string go(int n_times) override { PYBIND11_OVERLOAD(std::string, DogBase, go, n_times); }
+ std::string bark() override { PYBIND11_OVERLOAD(std::string, DogBase, bark, ); }
+ };
+
+This technique has the advantage of requiring just one trampoline method to be
+declared per virtual method and pure virtual method override. It does,
+however, require the compiler to generate at least as many methods (and
+possibly more, if both pure virtual and overridden pure virtual methods are
+exposed, as above).
+
+The classes are then registered with pybind11 using:
+
+.. code-block:: cpp
+
+ py::class_> animal(m, "Animal");
+ py::class_> dog(m, "Dog");
+ py::class_> husky(m, "Husky");
+ // ... add animal, dog, husky definitions
+
+Note that ``Husky`` did not require a dedicated trampoline template class at
+all, since it neither declares any new virtual methods nor provides any pure
+virtual method implementations.
+
+With either the repeated-virtuals or templated trampoline methods in place, you
+can now create a python class that inherits from ``Dog``:
+
+.. code-block:: python
+
+ class ShihTzu(Dog):
+ def bark(self):
+ return "yip!"
+
+.. seealso::
+
+ See the file :file:`tests/test_virtual_functions.cpp` for complete examples
+ using both the duplication and templated trampoline approaches.
+
+.. _extended_aliases:
+
+Extended trampoline class functionality
+=======================================
+
+The trampoline classes described in the previous sections are, by default, only
+initialized when needed. More specifically, they are initialized when a python
+class actually inherits from a registered type (instead of merely creating an
+instance of the registered type), or when a registered constructor is only
+valid for the trampoline class but not the registered class. This is primarily
+for performance reasons: when the trampoline class is not needed for anything
+except virtual method dispatching, not initializing the trampoline class
+improves performance by avoiding needing to do a run-time check to see if the
+inheriting python instance has an overloaded method.
+
+Sometimes, however, it is useful to always initialize a trampoline class as an
+intermediate class that does more than just handle virtual method dispatching.
+For example, such a class might perform extra class initialization, extra
+destruction operations, and might define new members and methods to enable a
+more python-like interface to a class.
+
+In order to tell pybind11 that it should *always* initialize the trampoline
+class when creating new instances of a type, the class constructors should be
+declared using ``py::init_alias()`` instead of the usual
+``py::init()``. This forces construction via the trampoline class,
+ensuring member initialization and (eventual) destruction.
+
+.. seealso::
+
+ See the file :file:`tests/test_virtual_functions.cpp` for complete examples
+ showing both normal and forced trampoline instantiation.
+
+.. _custom_constructors:
+
+Custom constructors
+===================
+
+The syntax for binding constructors was previously introduced, but it only
+works when a constructor of the appropriate arguments actually exists on the
+C++ side. To extend this to more general cases, pybind11 makes it possible
+to bind factory functions as constructors. For example, suppose you have a
+class like this:
+
+.. code-block:: cpp
+
+ class Example {
+ private:
+ Example(int); // private constructor
+ public:
+ // Factory function:
+ static Example create(int a) { return Example(a); }
+ };
+
+ py::class_(m, "Example")
+ .def(py::init(&Example::create));
+
+While it is possible to create a straightforward binding of the static
+``create`` method, it may sometimes be preferable to expose it as a constructor
+on the Python side. This can be accomplished by calling ``.def(py::init(...))``
+with the function reference returning the new instance passed as an argument.
+It is also possible to use this approach to bind a function returning a new
+instance by raw pointer or by the holder (e.g. ``std::unique_ptr``).
+
+The following example shows the different approaches:
+
+.. code-block:: cpp
+
+ class Example {
+ private:
+ Example(int); // private constructor
+ public:
+ // Factory function - returned by value:
+ static Example create(int a) { return Example(a); }
+
+ // These constructors are publicly callable:
+ Example(double);
+ Example(int, int);
+ Example(std::string);
+ };
+
+ py::class_(m, "Example")
+ // Bind the factory function as a constructor:
+ .def(py::init(&Example::create))
+ // Bind a lambda function returning a pointer wrapped in a holder:
+ .def(py::init([](std::string arg) {
+ return std::unique_ptr(new Example(arg));
+ }))
+ // Return a raw pointer:
+ .def(py::init([](int a, int b) { return new Example(a, b); }))
+ // You can mix the above with regular C++ constructor bindings as well:
+ .def(py::init())
+ ;
+
+When the constructor is invoked from Python, pybind11 will call the factory
+function and store the resulting C++ instance in the Python instance.
+
+When combining factory functions constructors with :ref:`virtual function
+trampolines ` there are two approaches. The first is to
+add a constructor to the alias class that takes a base value by
+rvalue-reference. If such a constructor is available, it will be used to
+construct an alias instance from the value returned by the factory function.
+The second option is to provide two factory functions to ``py::init()``: the
+first will be invoked when no alias class is required (i.e. when the class is
+being used but not inherited from in Python), and the second will be invoked
+when an alias is required.
+
+You can also specify a single factory function that always returns an alias
+instance: this will result in behaviour similar to ``py::init_alias<...>()``,
+as described in the :ref:`extended trampoline class documentation
+`.
+
+The following example shows the different factory approaches for a class with
+an alias:
+
+.. code-block:: cpp
+
+ #include
+ class Example {
+ public:
+ // ...
+ virtual ~Example() = default;
+ };
+ class PyExample : public Example {
+ public:
+ using Example::Example;
+ PyExample(Example &&base) : Example(std::move(base)) {}
+ };
+ py::class_(m, "Example")
+ // Returns an Example pointer. If a PyExample is needed, the Example
+ // instance will be moved via the extra constructor in PyExample, above.
+ .def(py::init([]() { return new Example(); }))
+ // Two callbacks:
+ .def(py::init([]() { return new Example(); } /* no alias needed */,
+ []() { return new PyExample(); } /* alias needed */))
+ // *Always* returns an alias instance (like py::init_alias<>())
+ .def(py::init([]() { return new PyExample(); }))
+ ;
+
+Brace initialization
+--------------------
+
+``pybind11::init<>`` internally uses C++11 brace initialization to call the
+constructor of the target class. This means that it can be used to bind
+*implicit* constructors as well:
+
+.. code-block:: cpp
+
+ struct Aggregate {
+ int a;
+ std::string b;
+ };
+
+ py::class_(m, "Aggregate")
+ .def(py::init());
+
+.. note::
+
+ Note that brace initialization preferentially invokes constructor overloads
+ taking a ``std::initializer_list``. In the rare event that this causes an
+ issue, you can work around it by using ``py::init(...)`` with a lambda
+ function that constructs the new object as desired.
+
+.. _classes_with_non_public_destructors:
+
+Non-public destructors
+======================
+
+If a class has a private or protected destructor (as might e.g. be the case in
+a singleton pattern), a compile error will occur when creating bindings via
+pybind11. The underlying issue is that the ``std::unique_ptr`` holder type that
+is responsible for managing the lifetime of instances will reference the
+destructor even if no deallocations ever take place. In order to expose classes
+with private or protected destructors, it is possible to override the holder
+type via a holder type argument to ``class_``. Pybind11 provides a helper class
+``py::nodelete`` that disables any destructor invocations. In this case, it is
+crucial that instances are deallocated on the C++ side to avoid memory leaks.
+
+.. code-block:: cpp
+
+ /* ... definition ... */
+
+ class MyClass {
+ private:
+ ~MyClass() { }
+ };
+
+ /* ... binding code ... */
+
+ py::class_>(m, "MyClass")
+ .def(py::init<>())
+
+.. _implicit_conversions:
+
+Implicit conversions
+====================
+
+Suppose that instances of two types ``A`` and ``B`` are used in a project, and
+that an ``A`` can easily be converted into an instance of type ``B`` (examples of this
+could be a fixed and an arbitrary precision number type).
+
+.. code-block:: cpp
+
+ py::class_(m, "A")
+ /// ... members ...
+
+ py::class_(m, "B")
+ .def(py::init())
+ /// ... members ...
+
+ m.def("func",
+ [](const B &) { /* .... */ }
+ );
+
+To invoke the function ``func`` using a variable ``a`` containing an ``A``
+instance, we'd have to write ``func(B(a))`` in Python. On the other hand, C++
+will automatically apply an implicit type conversion, which makes it possible
+to directly write ``func(a)``.
+
+In this situation (i.e. where ``B`` has a constructor that converts from
+``A``), the following statement enables similar implicit conversions on the
+Python side:
+
+.. code-block:: cpp
+
+ py::implicitly_convertible();
+
+.. note::
+
+ Implicit conversions from ``A`` to ``B`` only work when ``B`` is a custom
+ data type that is exposed to Python via pybind11.
+
+ To prevent runaway recursion, implicit conversions are non-reentrant: an
+ implicit conversion invoked as part of another implicit conversion of the
+ same type (i.e. from ``A`` to ``B``) will fail.
+
+.. _static_properties:
+
+Static properties
+=================
+
+The section on :ref:`properties` discussed the creation of instance properties
+that are implemented in terms of C++ getters and setters.
+
+Static properties can also be created in a similar way to expose getters and
+setters of static class attributes. Note that the implicit ``self`` argument
+also exists in this case and is used to pass the Python ``type`` subclass
+instance. This parameter will often not be needed by the C++ side, and the
+following example illustrates how to instantiate a lambda getter function
+that ignores it:
+
+.. code-block:: cpp
+
+ py::class_(m, "Foo")
+ .def_property_readonly_static("foo", [](py::object /* self */) { return Foo(); });
+
+Operator overloading
+====================
+
+Suppose that we're given the following ``Vector2`` class with a vector addition
+and scalar multiplication operation, all implemented using overloaded operators
+in C++.
+
+.. code-block:: cpp
+
+ class Vector2 {
+ public:
+ Vector2(float x, float y) : x(x), y(y) { }
+
+ Vector2 operator+(const Vector2 &v) const { return Vector2(x + v.x, y + v.y); }
+ Vector2 operator*(float value) const { return Vector2(x * value, y * value); }
+ Vector2& operator+=(const Vector2 &v) { x += v.x; y += v.y; return *this; }
+ Vector2& operator*=(float v) { x *= v; y *= v; return *this; }
+
+ friend Vector2 operator*(float f, const Vector2 &v) {
+ return Vector2(f * v.x, f * v.y);
+ }
+
+ std::string toString() const {
+ return "[" + std::to_string(x) + ", " + std::to_string(y) + "]";
+ }
+ private:
+ float x, y;
+ };
+
+The following snippet shows how the above operators can be conveniently exposed
+to Python.
+
+.. code-block:: cpp
+
+ #include
+
+ PYBIND11_MODULE(example, m) {
+ py::class_(m, "Vector2")
+ .def(py::init())
+ .def(py::self + py::self)
+ .def(py::self += py::self)
+ .def(py::self *= float())
+ .def(float() * py::self)
+ .def(py::self * float())
+ .def("__repr__", &Vector2::toString);
+ }
+
+Note that a line like
+
+.. code-block:: cpp
+
+ .def(py::self * float())
+
+is really just short hand notation for
+
+.. code-block:: cpp
+
+ .def("__mul__", [](const Vector2 &a, float b) {
+ return a * b;
+ }, py::is_operator())
+
+This can be useful for exposing additional operators that don't exist on the
+C++ side, or to perform other types of customization. The ``py::is_operator``
+flag marker is needed to inform pybind11 that this is an operator, which
+returns ``NotImplemented`` when invoked with incompatible arguments rather than
+throwing a type error.
+
+.. note::
+
+ To use the more convenient ``py::self`` notation, the additional
+ header file :file:`pybind11/operators.h` must be included.
+
+.. seealso::
+
+ The file :file:`tests/test_operator_overloading.cpp` contains a
+ complete example that demonstrates how to work with overloaded operators in
+ more detail.
+
+.. _pickling:
+
+Pickling support
+================
+
+Python's ``pickle`` module provides a powerful facility to serialize and
+de-serialize a Python object graph into a binary data stream. To pickle and
+unpickle C++ classes using pybind11, a ``py::pickle()`` definition must be
+provided. Suppose the class in question has the following signature:
+
+.. code-block:: cpp
+
+ class Pickleable {
+ public:
+ Pickleable(const std::string &value) : m_value(value) { }
+ const std::string &value() const { return m_value; }
+
+ void setExtra(int extra) { m_extra = extra; }
+ int extra() const { return m_extra; }
+ private:
+ std::string m_value;
+ int m_extra = 0;
+ };
+
+Pickling support in Python is enabled by defining the ``__setstate__`` and
+``__getstate__`` methods [#f3]_. For pybind11 classes, use ``py::pickle()``
+to bind these two functions:
+
+.. code-block:: cpp
+
+ py::class_(m, "Pickleable")
+ .def(py::init())
+ .def("value", &Pickleable::value)
+ .def("extra", &Pickleable::extra)
+ .def("setExtra", &Pickleable::setExtra)
+ .def(py::pickle(
+ [](const Pickleable &p) { // __getstate__
+ /* Return a tuple that fully encodes the state of the object */
+ return py::make_tuple(p.value(), p.extra());
+ },
+ [](py::tuple t) { // __setstate__
+ if (t.size() != 2)
+ throw std::runtime_error("Invalid state!");
+
+ /* Create a new C++ instance */
+ Pickleable p(t[0].cast());
+
+ /* Assign any additional state */
+ p.setExtra(t[1].cast());
+
+ return p;
+ }
+ ));
+
+The ``__setstate__`` part of the ``py::picke()`` definition follows the same
+rules as the single-argument version of ``py::init()``. The return type can be
+a value, pointer or holder type. See :ref:`custom_constructors` for details.
+
+An instance can now be pickled as follows:
+
+.. code-block:: python
+
+ try:
+ import cPickle as pickle # Use cPickle on Python 2.7
+ except ImportError:
+ import pickle
+
+ p = Pickleable("test_value")
+ p.setExtra(15)
+ data = pickle.dumps(p, 2)
+
+Note that only the cPickle module is supported on Python 2.7. The second
+argument to ``dumps`` is also crucial: it selects the pickle protocol version
+2, since the older version 1 is not supported. Newer versions are also fine—for
+instance, specify ``-1`` to always use the latest available version. Beware:
+failure to follow these instructions will cause important pybind11 memory
+allocation routines to be skipped during unpickling, which will likely lead to
+memory corruption and/or segmentation faults.
+
+.. seealso::
+
+ The file :file:`tests/test_pickling.cpp` contains a complete example
+ that demonstrates how to pickle and unpickle types using pybind11 in more
+ detail.
+
+.. [#f3] http://docs.python.org/3/library/pickle.html#pickling-class-instances
+
+Multiple Inheritance
+====================
+
+pybind11 can create bindings for types that derive from multiple base types
+(aka. *multiple inheritance*). To do so, specify all bases in the template
+arguments of the ``class_`` declaration:
+
+.. code-block:: cpp
+
+ py::class_(m, "MyType")
+ ...
+
+The base types can be specified in arbitrary order, and they can even be
+interspersed with alias types and holder types (discussed earlier in this
+document)---pybind11 will automatically find out which is which. The only
+requirement is that the first template argument is the type to be declared.
+
+It is also permitted to inherit multiply from exported C++ classes in Python,
+as well as inheriting from multiple Python and/or pybind-exported classes.
+
+There is one caveat regarding the implementation of this feature:
+
+When only one base type is specified for a C++ type that actually has multiple
+bases, pybind11 will assume that it does not participate in multiple
+inheritance, which can lead to undefined behavior. In such cases, add the tag
+``multiple_inheritance`` to the class constructor:
+
+.. code-block:: cpp
+
+ py::class_(m, "MyType", py::multiple_inheritance());
+
+The tag is redundant and does not need to be specified when multiple base types
+are listed.
+
+.. _module_local:
+
+Module-local class bindings
+===========================
+
+When creating a binding for a class, pybind by default makes that binding
+"global" across modules. What this means is that a type defined in one module
+can be returned from any module resulting in the same Python type. For
+example, this allows the following:
+
+.. code-block:: cpp
+
+ // In the module1.cpp binding code for module1:
+ py::class_(m, "Pet")
+ .def(py::init())
+ .def_readonly("name", &Pet::name);
+
+.. code-block:: cpp
+
+ // In the module2.cpp binding code for module2:
+ m.def("create_pet", [](std::string name) { return new Pet(name); });
+
+.. code-block:: pycon
+
+ >>> from module1 import Pet
+ >>> from module2 import create_pet
+ >>> pet1 = Pet("Kitty")
+ >>> pet2 = create_pet("Doggy")
+ >>> pet2.name()
+ 'Doggy'
+
+When writing binding code for a library, this is usually desirable: this
+allows, for example, splitting up a complex library into multiple Python
+modules.
+
+In some cases, however, this can cause conflicts. For example, suppose two
+unrelated modules make use of an external C++ library and each provide custom
+bindings for one of that library's classes. This will result in an error when
+a Python program attempts to import both modules (directly or indirectly)
+because of conflicting definitions on the external type:
+
+.. code-block:: cpp
+
+ // dogs.cpp
+
+ // Binding for external library class:
+ py::class(m, "Pet")
+ .def("name", &pets::Pet::name);
+
+ // Binding for local extension class:
+ py::class(m, "Dog")
+ .def(py::init());
+
+.. code-block:: cpp
+
+ // cats.cpp, in a completely separate project from the above dogs.cpp.
+
+ // Binding for external library class:
+ py::class(m, "Pet")
+ .def("get_name", &pets::Pet::name);
+
+ // Binding for local extending class:
+ py::class(m, "Cat")
+ .def(py::init());
+
+.. code-block:: pycon
+
+ >>> import cats
+ >>> import dogs
+ Traceback (most recent call last):
+ File "", line 1, in
+ ImportError: generic_type: type "Pet" is already registered!
+
+To get around this, you can tell pybind11 to keep the external class binding
+localized to the module by passing the ``py::module_local()`` attribute into
+the ``py::class_`` constructor:
+
+.. code-block:: cpp
+
+ // Pet binding in dogs.cpp:
+ py::class(m, "Pet", py::module_local())
+ .def("name", &pets::Pet::name);
+
+.. code-block:: cpp
+
+ // Pet binding in cats.cpp:
+ py::class(m, "Pet", py::module_local())
+ .def("get_name", &pets::Pet::name);
+
+This makes the Python-side ``dogs.Pet`` and ``cats.Pet`` into distinct classes,
+avoiding the conflict and allowing both modules to be loaded. C++ code in the
+``dogs`` module that casts or returns a ``Pet`` instance will result in a
+``dogs.Pet`` Python instance, while C++ code in the ``cats`` module will result
+in a ``cats.Pet`` Python instance.
+
+This does come with two caveats, however: First, external modules cannot return
+or cast a ``Pet`` instance to Python (unless they also provide their own local
+bindings). Second, from the Python point of view they are two distinct classes.
+
+Note that the locality only applies in the C++ -> Python direction. When
+passing such a ``py::module_local`` type into a C++ function, the module-local
+classes are still considered. This means that if the following function is
+added to any module (including but not limited to the ``cats`` and ``dogs``
+modules above) it will be callable with either a ``dogs.Pet`` or ``cats.Pet``
+argument:
+
+.. code-block:: cpp
+
+ m.def("pet_name", [](const pets::Pet &pet) { return pet.name(); });
+
+For example, suppose the above function is added to each of ``cats.cpp``,
+``dogs.cpp`` and ``frogs.cpp`` (where ``frogs.cpp`` is some other module that
+does *not* bind ``Pets`` at all).
+
+.. code-block:: pycon
+
+ >>> import cats, dogs, frogs # No error because of the added py::module_local()
+ >>> mycat, mydog = cats.Cat("Fluffy"), dogs.Dog("Rover")
+ >>> (cats.pet_name(mycat), dogs.pet_name(mydog))
+ ('Fluffy', 'Rover')
+ >>> (cats.pet_name(mydog), dogs.pet_name(mycat), frogs.pet_name(mycat))
+ ('Rover', 'Fluffy', 'Fluffy')
+
+It is possible to use ``py::module_local()`` registrations in one module even
+if another module registers the same type globally: within the module with the
+module-local definition, all C++ instances will be cast to the associated bound
+Python type. In other modules any such values are converted to the global
+Python type created elsewhere.
+
+.. note::
+
+ STL bindings (as provided via the optional :file:`pybind11/stl_bind.h`
+ header) apply ``py::module_local`` by default when the bound type might
+ conflict with other modules; see :ref:`stl_bind` for details.
+
+.. note::
+
+ The localization of the bound types is actually tied to the shared object
+ or binary generated by the compiler/linker. For typical modules created
+ with ``PYBIND11_MODULE()``, this distinction is not significant. It is
+ possible, however, when :ref:`embedding` to embed multiple modules in the
+ same binary (see :ref:`embedding_modules`). In such a case, the
+ localization will apply across all embedded modules within the same binary.
+
+.. seealso::
+
+ The file :file:`tests/test_local_bindings.cpp` contains additional examples
+ that demonstrate how ``py::module_local()`` works.
+
+Binding protected member functions
+==================================
+
+It's normally not possible to expose ``protected`` member functions to Python:
+
+.. code-block:: cpp
+
+ class A {
+ protected:
+ int foo() const { return 42; }
+ };
+
+ py::class_(m, "A")
+ .def("foo", &A::foo); // error: 'foo' is a protected member of 'A'
+
+On one hand, this is good because non-``public`` members aren't meant to be
+accessed from the outside. But we may want to make use of ``protected``
+functions in derived Python classes.
+
+The following pattern makes this possible:
+
+.. code-block:: cpp
+
+ class A {
+ protected:
+ int foo() const { return 42; }
+ };
+
+ class Publicist : public A { // helper type for exposing protected functions
+ public:
+ using A::foo; // inherited with different access modifier
+ };
+
+ py::class_(m, "A") // bind the primary class
+ .def("foo", &Publicist::foo); // expose protected methods via the publicist
+
+This works because ``&Publicist::foo`` is exactly the same function as
+``&A::foo`` (same signature and address), just with a different access
+modifier. The only purpose of the ``Publicist`` helper class is to make
+the function name ``public``.
+
+If the intent is to expose ``protected`` ``virtual`` functions which can be
+overridden in Python, the publicist pattern can be combined with the previously
+described trampoline:
+
+.. code-block:: cpp
+
+ class A {
+ public:
+ virtual ~A() = default;
+
+ protected:
+ virtual int foo() const { return 42; }
+ };
+
+ class Trampoline : public A {
+ public:
+ int foo() const override { PYBIND11_OVERLOAD(int, A, foo, ); }
+ };
+
+ class Publicist : public A {
+ public:
+ using A::foo;
+ };
+
+ py::class_(m, "A") // <-- `Trampoline` here
+ .def("foo", &Publicist::foo); // <-- `Publicist` here, not `Trampoline`!
+
+.. note::
+
+ MSVC 2015 has a compiler bug (fixed in version 2017) which
+ requires a more explicit function binding in the form of
+ ``.def("foo", static_cast(&Publicist::foo));``
+ where ``int (A::*)() const`` is the type of ``A::foo``.
diff --git a/external/pybind11/docs/advanced/embedding.rst b/external/pybind11/docs/advanced/embedding.rst
new file mode 100644
index 0000000..3930316
--- /dev/null
+++ b/external/pybind11/docs/advanced/embedding.rst
@@ -0,0 +1,261 @@
+.. _embedding:
+
+Embedding the interpreter
+#########################
+
+While pybind11 is mainly focused on extending Python using C++, it's also
+possible to do the reverse: embed the Python interpreter into a C++ program.
+All of the other documentation pages still apply here, so refer to them for
+general pybind11 usage. This section will cover a few extra things required
+for embedding.
+
+Getting started
+===============
+
+A basic executable with an embedded interpreter can be created with just a few
+lines of CMake and the ``pybind11::embed`` target, as shown below. For more
+information, see :doc:`/compiling`.
+
+.. code-block:: cmake
+
+ cmake_minimum_required(VERSION 3.0)
+ project(example)
+
+ find_package(pybind11 REQUIRED) # or `add_subdirectory(pybind11)`
+
+ add_executable(example main.cpp)
+ target_link_libraries(example PRIVATE pybind11::embed)
+
+The essential structure of the ``main.cpp`` file looks like this:
+
+.. code-block:: cpp
+
+ #include // everything needed for embedding
+ namespace py = pybind11;
+
+ int main() {
+ py::scoped_interpreter guard{}; // start the interpreter and keep it alive
+
+ py::print("Hello, World!"); // use the Python API
+ }
+
+The interpreter must be initialized before using any Python API, which includes
+all the functions and classes in pybind11. The RAII guard class `scoped_interpreter`
+takes care of the interpreter lifetime. After the guard is destroyed, the interpreter
+shuts down and clears its memory. No Python functions can be called after this.
+
+Executing Python code
+=====================
+
+There are a few different ways to run Python code. One option is to use `eval`,
+`exec` or `eval_file`, as explained in :ref:`eval`. Here is a quick example in
+the context of an executable with an embedded interpreter:
+
+.. code-block:: cpp
+
+ #include
+ namespace py = pybind11;
+
+ int main() {
+ py::scoped_interpreter guard{};
+
+ py::exec(R"(
+ kwargs = dict(name="World", number=42)
+ message = "Hello, {name}! The answer is {number}".format(**kwargs)
+ print(message)
+ )");
+ }
+
+Alternatively, similar results can be achieved using pybind11's API (see
+:doc:`/advanced/pycpp/index` for more details).
+
+.. code-block:: cpp
+
+ #include
+ namespace py = pybind11;
+ using namespace py::literals;
+
+ int main() {
+ py::scoped_interpreter guard{};
+
+ auto kwargs = py::dict("name"_a="World", "number"_a=42);
+ auto message = "Hello, {name}! The answer is {number}"_s.format(**kwargs);
+ py::print(message);
+ }
+
+The two approaches can also be combined:
+
+.. code-block:: cpp
+
+ #include
+ #include
+
+ namespace py = pybind11;
+ using namespace py::literals;
+
+ int main() {
+ py::scoped_interpreter guard{};
+
+ auto locals = py::dict("name"_a="World", "number"_a=42);
+ py::exec(R"(
+ message = "Hello, {name}! The answer is {number}".format(**locals())
+ )", py::globals(), locals);
+
+ auto message = locals["message"].cast();
+ std::cout << message;
+ }
+
+Importing modules
+=================
+
+Python modules can be imported using `module::import()`:
+
+.. code-block:: cpp
+
+ py::module sys = py::module::import("sys");
+ py::print(sys.attr("path"));
+
+For convenience, the current working directory is included in ``sys.path`` when
+embedding the interpreter. This makes it easy to import local Python files:
+
+.. code-block:: python
+
+ """calc.py located in the working directory"""
+
+ def add(i, j):
+ return i + j
+
+
+.. code-block:: cpp
+
+ py::module calc = py::module::import("calc");
+ py::object result = calc.attr("add")(1, 2);
+ int n = result.cast();
+ assert(n == 3);
+
+Modules can be reloaded using `module::reload()` if the source is modified e.g.
+by an external process. This can be useful in scenarios where the application
+imports a user defined data processing script which needs to be updated after
+changes by the user. Note that this function does not reload modules recursively.
+
+.. _embedding_modules:
+
+Adding embedded modules
+=======================
+
+Embedded binary modules can be added using the `PYBIND11_EMBEDDED_MODULE` macro.
+Note that the definition must be placed at global scope. They can be imported
+like any other module.
+
+.. code-block:: cpp
+
+ #include
+ namespace py = pybind11;
+
+ PYBIND11_EMBEDDED_MODULE(fast_calc, m) {
+ // `m` is a `py::module` which is used to bind functions and classes
+ m.def("add", [](int i, int j) {
+ return i + j;
+ });
+ }
+
+ int main() {
+ py::scoped_interpreter guard{};
+
+ auto fast_calc = py::module::import("fast_calc");
+ auto result = fast_calc.attr("add")(1, 2).cast();
+ assert(result == 3);
+ }
+
+Unlike extension modules where only a single binary module can be created, on
+the embedded side an unlimited number of modules can be added using multiple
+`PYBIND11_EMBEDDED_MODULE` definitions (as long as they have unique names).
+
+These modules are added to Python's list of builtins, so they can also be
+imported in pure Python files loaded by the interpreter. Everything interacts
+naturally:
+
+.. code-block:: python
+
+ """py_module.py located in the working directory"""
+ import cpp_module
+
+ a = cpp_module.a
+ b = a + 1
+
+
+.. code-block:: cpp
+
+ #include
+ namespace py = pybind11;
+
+ PYBIND11_EMBEDDED_MODULE(cpp_module, m) {
+ m.attr("a") = 1;
+ }
+
+ int main() {
+ py::scoped_interpreter guard{};
+
+ auto py_module = py::module::import("py_module");
+
+ auto locals = py::dict("fmt"_a="{} + {} = {}", **py_module.attr("__dict__"));
+ assert(locals["a"].cast() == 1);
+ assert(locals["b"].cast() == 2);
+
+ py::exec(R"(
+ c = a + b
+ message = fmt.format(a, b, c)
+ )", py::globals(), locals);
+
+ assert(locals["c"].cast() == 3);
+ assert(locals["message"].cast() == "1 + 2 = 3");
+ }
+
+
+Interpreter lifetime
+====================
+
+The Python interpreter shuts down when `scoped_interpreter` is destroyed. After
+this, creating a new instance will restart the interpreter. Alternatively, the
+`initialize_interpreter` / `finalize_interpreter` pair of functions can be used
+to directly set the state at any time.
+
+Modules created with pybind11 can be safely re-initialized after the interpreter
+has been restarted. However, this may not apply to third-party extension modules.
+The issue is that Python itself cannot completely unload extension modules and
+there are several caveats with regard to interpreter restarting. In short, not
+all memory may be freed, either due to Python reference cycles or user-created
+global data. All the details can be found in the CPython documentation.
+
+.. warning::
+
+ Creating two concurrent `scoped_interpreter` guards is a fatal error. So is
+ calling `initialize_interpreter` for a second time after the interpreter
+ has already been initialized.
+
+ Do not use the raw CPython API functions ``Py_Initialize`` and
+ ``Py_Finalize`` as these do not properly handle the lifetime of
+ pybind11's internal data.
+
+
+Sub-interpreter support
+=======================
+
+Creating multiple copies of `scoped_interpreter` is not possible because it
+represents the main Python interpreter. Sub-interpreters are something different
+and they do permit the existence of multiple interpreters. This is an advanced
+feature of the CPython API and should be handled with care. pybind11 does not
+currently offer a C++ interface for sub-interpreters, so refer to the CPython
+documentation for all the details regarding this feature.
+
+We'll just mention a couple of caveats the sub-interpreters support in pybind11:
+
+ 1. Sub-interpreters will not receive independent copies of embedded modules.
+ Instead, these are shared and modifications in one interpreter may be
+ reflected in another.
+
+ 2. Managing multiple threads, multiple interpreters and the GIL can be
+ challenging and there are several caveats here, even within the pure
+ CPython API (please refer to the Python docs for details). As for
+ pybind11, keep in mind that `gil_scoped_release` and `gil_scoped_acquire`
+ do not take sub-interpreters into account.
diff --git a/external/pybind11/docs/advanced/exceptions.rst b/external/pybind11/docs/advanced/exceptions.rst
new file mode 100644
index 0000000..3483379
--- /dev/null
+++ b/external/pybind11/docs/advanced/exceptions.rst
@@ -0,0 +1,142 @@
+Exceptions
+##########
+
+Built-in exception translation
+==============================
+
+When C++ code invoked from Python throws an ``std::exception``, it is
+automatically converted into a Python ``Exception``. pybind11 defines multiple
+special exception classes that will map to different types of Python
+exceptions:
+
+.. tabularcolumns:: |p{0.5\textwidth}|p{0.45\textwidth}|
+
++--------------------------------------+------------------------------+
+| C++ exception type | Python exception type |
++======================================+==============================+
+| :class:`std::exception` | ``RuntimeError`` |
++--------------------------------------+------------------------------+
+| :class:`std::bad_alloc` | ``MemoryError`` |
++--------------------------------------+------------------------------+
+| :class:`std::domain_error` | ``ValueError`` |
++--------------------------------------+------------------------------+
+| :class:`std::invalid_argument` | ``ValueError`` |
++--------------------------------------+------------------------------+
+| :class:`std::length_error` | ``ValueError`` |
++--------------------------------------+------------------------------+
+| :class:`std::out_of_range` | ``ValueError`` |
++--------------------------------------+------------------------------+
+| :class:`std::range_error` | ``ValueError`` |
++--------------------------------------+------------------------------+
+| :class:`pybind11::stop_iteration` | ``StopIteration`` (used to |
+| | implement custom iterators) |
++--------------------------------------+------------------------------+
+| :class:`pybind11::index_error` | ``IndexError`` (used to |
+| | indicate out of bounds |
+| | accesses in ``__getitem__``, |
+| | ``__setitem__``, etc.) |
++--------------------------------------+------------------------------+
+| :class:`pybind11::value_error` | ``ValueError`` (used to |
+| | indicate wrong value passed |
+| | in ``container.remove(...)`` |
++--------------------------------------+------------------------------+
+| :class:`pybind11::key_error` | ``KeyError`` (used to |
+| | indicate out of bounds |
+| | accesses in ``__getitem__``, |
+| | ``__setitem__`` in dict-like |
+| | objects, etc.) |
++--------------------------------------+------------------------------+
+| :class:`pybind11::error_already_set` | Indicates that the Python |
+| | exception flag has already |
+| | been initialized |
++--------------------------------------+------------------------------+
+
+When a Python function invoked from C++ throws an exception, it is converted
+into a C++ exception of type :class:`error_already_set` whose string payload
+contains a textual summary.
+
+There is also a special exception :class:`cast_error` that is thrown by
+:func:`handle::call` when the input arguments cannot be converted to Python
+objects.
+
+Registering custom translators
+==============================
+
+If the default exception conversion policy described above is insufficient,
+pybind11 also provides support for registering custom exception translators.
+To register a simple exception conversion that translates a C++ exception into
+a new Python exception using the C++ exception's ``what()`` method, a helper
+function is available:
+
+.. code-block:: cpp
+
+ py::register_exception(module, "PyExp");
+
+This call creates a Python exception class with the name ``PyExp`` in the given
+module and automatically converts any encountered exceptions of type ``CppExp``
+into Python exceptions of type ``PyExp``.
+
+When more advanced exception translation is needed, the function
+``py::register_exception_translator(translator)`` can be used to register
+functions that can translate arbitrary exception types (and which may include
+additional logic to do so). The function takes a stateless callable (e.g. a
+function pointer or a lambda function without captured variables) with the call
+signature ``void(std::exception_ptr)``.
+
+When a C++ exception is thrown, the registered exception translators are tried
+in reverse order of registration (i.e. the last registered translator gets the
+first shot at handling the exception).
+
+Inside the translator, ``std::rethrow_exception`` should be used within
+a try block to re-throw the exception. One or more catch clauses to catch
+the appropriate exceptions should then be used with each clause using
+``PyErr_SetString`` to set a Python exception or ``ex(string)`` to set
+the python exception to a custom exception type (see below).
+
+To declare a custom Python exception type, declare a ``py::exception`` variable
+and use this in the associated exception translator (note: it is often useful
+to make this a static declaration when using it inside a lambda expression
+without requiring capturing).
+
+
+The following example demonstrates this for a hypothetical exception classes
+``MyCustomException`` and ``OtherException``: the first is translated to a
+custom python exception ``MyCustomError``, while the second is translated to a
+standard python RuntimeError:
+
+.. code-block:: cpp
+
+ static py::exception exc(m, "MyCustomError");
+ py::register_exception_translator([](std::exception_ptr p) {
+ try {
+ if (p) std::rethrow_exception(p);
+ } catch (const MyCustomException &e) {
+ exc(e.what());
+ } catch (const OtherException &e) {
+ PyErr_SetString(PyExc_RuntimeError, e.what());
+ }
+ });
+
+Multiple exceptions can be handled by a single translator, as shown in the
+example above. If the exception is not caught by the current translator, the
+previously registered one gets a chance.
+
+If none of the registered exception translators is able to handle the
+exception, it is handled by the default converter as described in the previous
+section.
+
+.. seealso::
+
+ The file :file:`tests/test_exceptions.cpp` contains examples
+ of various custom exception translators and custom exception types.
+
+.. note::
+
+ You must call either ``PyErr_SetString`` or a custom exception's call
+ operator (``exc(string)``) for every exception caught in a custom exception
+ translator. Failure to do so will cause Python to crash with ``SystemError:
+ error return without exception set``.
+
+ Exceptions that you do not plan to handle should simply not be caught, or
+ may be explicity (re-)thrown to delegate it to the other,
+ previously-declared existing exception translators.
diff --git a/external/pybind11/docs/advanced/functions.rst b/external/pybind11/docs/advanced/functions.rst
new file mode 100644
index 0000000..c7892b5
--- /dev/null
+++ b/external/pybind11/docs/advanced/functions.rst
@@ -0,0 +1,498 @@
+Functions
+#########
+
+Before proceeding with this section, make sure that you are already familiar
+with the basics of binding functions and classes, as explained in :doc:`/basics`
+and :doc:`/classes`. The following guide is applicable to both free and member
+functions, i.e. *methods* in Python.
+
+.. _return_value_policies:
+
+Return value policies
+=====================
+
+Python and C++ use fundamentally different ways of managing the memory and
+lifetime of objects managed by them. This can lead to issues when creating
+bindings for functions that return a non-trivial type. Just by looking at the
+type information, it is not clear whether Python should take charge of the
+returned value and eventually free its resources, or if this is handled on the
+C++ side. For this reason, pybind11 provides a several *return value policy*
+annotations that can be passed to the :func:`module::def` and
+:func:`class_::def` functions. The default policy is
+:enum:`return_value_policy::automatic`.
+
+Return value policies are tricky, and it's very important to get them right.
+Just to illustrate what can go wrong, consider the following simple example:
+
+.. code-block:: cpp
+
+ /* Function declaration */
+ Data *get_data() { return _data; /* (pointer to a static data structure) */ }
+ ...
+
+ /* Binding code */
+ m.def("get_data", &get_data); // <-- KABOOM, will cause crash when called from Python
+
+What's going on here? When ``get_data()`` is called from Python, the return
+value (a native C++ type) must be wrapped to turn it into a usable Python type.
+In this case, the default return value policy (:enum:`return_value_policy::automatic`)
+causes pybind11 to assume ownership of the static ``_data`` instance.
+
+When Python's garbage collector eventually deletes the Python
+wrapper, pybind11 will also attempt to delete the C++ instance (via ``operator
+delete()``) due to the implied ownership. At this point, the entire application
+will come crashing down, though errors could also be more subtle and involve
+silent data corruption.
+
+In the above example, the policy :enum:`return_value_policy::reference` should have
+been specified so that the global data instance is only *referenced* without any
+implied transfer of ownership, i.e.:
+
+.. code-block:: cpp
+
+ m.def("get_data", &get_data, return_value_policy::reference);
+
+On the other hand, this is not the right policy for many other situations,
+where ignoring ownership could lead to resource leaks.
+As a developer using pybind11, it's important to be familiar with the different
+return value policies, including which situation calls for which one of them.
+The following table provides an overview of available policies:
+
+.. tabularcolumns:: |p{0.5\textwidth}|p{0.45\textwidth}|
+
++--------------------------------------------------+----------------------------------------------------------------------------+
+| Return value policy | Description |
++==================================================+============================================================================+
+| :enum:`return_value_policy::take_ownership` | Reference an existing object (i.e. do not create a new copy) and take |
+| | ownership. Python will call the destructor and delete operator when the |
+| | object's reference count reaches zero. Undefined behavior ensues when the |
+| | C++ side does the same, or when the data was not dynamically allocated. |
++--------------------------------------------------+----------------------------------------------------------------------------+
+| :enum:`return_value_policy::copy` | Create a new copy of the returned object, which will be owned by Python. |
+| | This policy is comparably safe because the lifetimes of the two instances |
+| | are decoupled. |
++--------------------------------------------------+----------------------------------------------------------------------------+
+| :enum:`return_value_policy::move` | Use ``std::move`` to move the return value contents into a new instance |
+| | that will be owned by Python. This policy is comparably safe because the |
+| | lifetimes of the two instances (move source and destination) are decoupled.|
++--------------------------------------------------+----------------------------------------------------------------------------+
+| :enum:`return_value_policy::reference` | Reference an existing object, but do not take ownership. The C++ side is |
+| | responsible for managing the object's lifetime and deallocating it when |
+| | it is no longer used. Warning: undefined behavior will ensue when the C++ |
+| | side deletes an object that is still referenced and used by Python. |
++--------------------------------------------------+----------------------------------------------------------------------------+
+| :enum:`return_value_policy::reference_internal` | Indicates that the lifetime of the return value is tied to the lifetime |
+| | of a parent object, namely the implicit ``this``, or ``self`` argument of |
+| | the called method or property. Internally, this policy works just like |
+| | :enum:`return_value_policy::reference` but additionally applies a |
+| | ``keep_alive<0, 1>`` *call policy* (described in the next section) that |
+| | prevents the parent object from being garbage collected as long as the |
+| | return value is referenced by Python. This is the default policy for |
+| | property getters created via ``def_property``, ``def_readwrite``, etc. |
++--------------------------------------------------+----------------------------------------------------------------------------+
+| :enum:`return_value_policy::automatic` | **Default policy.** This policy falls back to the policy |
+| | :enum:`return_value_policy::take_ownership` when the return value is a |
+| | pointer. Otherwise, it uses :enum:`return_value_policy::move` or |
+| | :enum:`return_value_policy::copy` for rvalue and lvalue references, |
+| | respectively. See above for a description of what all of these different |
+| | policies do. |
++--------------------------------------------------+----------------------------------------------------------------------------+
+| :enum:`return_value_policy::automatic_reference` | As above, but use policy :enum:`return_value_policy::reference` when the |
+| | return value is a pointer. This is the default conversion policy for |
+| | function arguments when calling Python functions manually from C++ code |
+| | (i.e. via handle::operator()). You probably won't need to use this. |
++--------------------------------------------------+----------------------------------------------------------------------------+
+
+Return value policies can also be applied to properties:
+
+.. code-block:: cpp
+
+ class_(m, "MyClass")
+ .def_property("data", &MyClass::getData, &MyClass::setData,
+ py::return_value_policy::copy);
+
+Technically, the code above applies the policy to both the getter and the
+setter function, however, the setter doesn't really care about *return*
+value policies which makes this a convenient terse syntax. Alternatively,
+targeted arguments can be passed through the :class:`cpp_function` constructor:
+
+.. code-block:: cpp
+
+ class_(m, "MyClass")
+ .def_property("data"
+ py::cpp_function(&MyClass::getData, py::return_value_policy::copy),
+ py::cpp_function(&MyClass::setData)
+ );
+
+.. warning::
+
+ Code with invalid return value policies might access unitialized memory or
+ free data structures multiple times, which can lead to hard-to-debug
+ non-determinism and segmentation faults, hence it is worth spending the
+ time to understand all the different options in the table above.
+
+.. note::
+
+ One important aspect of the above policies is that they only apply to
+ instances which pybind11 has *not* seen before, in which case the policy
+ clarifies essential questions about the return value's lifetime and
+ ownership. When pybind11 knows the instance already (as identified by its
+ type and address in memory), it will return the existing Python object
+ wrapper rather than creating a new copy.
+
+.. note::
+
+ The next section on :ref:`call_policies` discusses *call policies* that can be
+ specified *in addition* to a return value policy from the list above. Call
+ policies indicate reference relationships that can involve both return values
+ and parameters of functions.
+
+.. note::
+
+ As an alternative to elaborate call policies and lifetime management logic,
+ consider using smart pointers (see the section on :ref:`smart_pointers` for
+ details). Smart pointers can tell whether an object is still referenced from
+ C++ or Python, which generally eliminates the kinds of inconsistencies that
+ can lead to crashes or undefined behavior. For functions returning smart
+ pointers, it is not necessary to specify a return value policy.
+
+.. _call_policies:
+
+Additional call policies
+========================
+
+In addition to the above return value policies, further *call policies* can be
+specified to indicate dependencies between parameters or ensure a certain state
+for the function call.
+
+Keep alive
+----------
+
+In general, this policy is required when the C++ object is any kind of container
+and another object is being added to the container. ``keep_alive``
+indicates that the argument with index ``Patient`` should be kept alive at least
+until the argument with index ``Nurse`` is freed by the garbage collector. Argument
+indices start at one, while zero refers to the return value. For methods, index
+``1`` refers to the implicit ``this`` pointer, while regular arguments begin at
+index ``2``. Arbitrarily many call policies can be specified. When a ``Nurse``
+with value ``None`` is detected at runtime, the call policy does nothing.
+
+When the nurse is not a pybind11-registered type, the implementation internally
+relies on the ability to create a *weak reference* to the nurse object. When
+the nurse object is not a pybind11-registered type and does not support weak
+references, an exception will be thrown.
+
+Consider the following example: here, the binding code for a list append
+operation ties the lifetime of the newly added element to the underlying
+container:
+
+.. code-block:: cpp
+
+ py::class_(m, "List")
+ .def("append", &List::append, py::keep_alive<1, 2>());
+
+For consistency, the argument indexing is identical for constructors. Index
+``1`` still refers to the implicit ``this`` pointer, i.e. the object which is
+being constructed. Index ``0`` refers to the return type which is presumed to
+be ``void`` when a constructor is viewed like a function. The following example
+ties the lifetime of the constructor element to the constructed object:
+
+.. code-block:: cpp
+
+ py::class_(m, "Nurse")
+ .def(py::init(), py::keep_alive<1, 2>());
+
+.. note::
+
+ ``keep_alive`` is analogous to the ``with_custodian_and_ward`` (if Nurse,
+ Patient != 0) and ``with_custodian_and_ward_postcall`` (if Nurse/Patient ==
+ 0) policies from Boost.Python.
+
+Call guard
+----------
+
+The ``call_guard`` policy allows any scope guard type ``T`` to be placed
+around the function call. For example, this definition:
+
+.. code-block:: cpp
+
+ m.def("foo", foo, py::call_guard());
+
+is equivalent to the following pseudocode:
+
+.. code-block:: cpp
+
+ m.def("foo", [](args...) {
+ T scope_guard;
+ return foo(args...); // forwarded arguments
+ });
+
+The only requirement is that ``T`` is default-constructible, but otherwise any
+scope guard will work. This is very useful in combination with `gil_scoped_release`.
+See :ref:`gil`.
+
+Multiple guards can also be specified as ``py::call_guard``. The
+constructor order is left to right and destruction happens in reverse.
+
+.. seealso::
+
+ The file :file:`tests/test_call_policies.cpp` contains a complete example
+ that demonstrates using `keep_alive` and `call_guard` in more detail.
+
+.. _python_objects_as_args:
+
+Python objects as arguments
+===========================
+
+pybind11 exposes all major Python types using thin C++ wrapper classes. These
+wrapper classes can also be used as parameters of functions in bindings, which
+makes it possible to directly work with native Python types on the C++ side.
+For instance, the following statement iterates over a Python ``dict``:
+
+.. code-block:: cpp
+
+ void print_dict(py::dict dict) {
+ /* Easily interact with Python types */
+ for (auto item : dict)
+ std::cout << "key=" << std::string(py::str(item.first)) << ", "
+ << "value=" << std::string(py::str(item.second)) << std::endl;
+ }
+
+It can be exported:
+
+.. code-block:: cpp
+
+ m.def("print_dict", &print_dict);
+
+And used in Python as usual:
+
+.. code-block:: pycon
+
+ >>> print_dict({'foo': 123, 'bar': 'hello'})
+ key=foo, value=123
+ key=bar, value=hello
+
+For more information on using Python objects in C++, see :doc:`/advanced/pycpp/index`.
+
+Accepting \*args and \*\*kwargs
+===============================
+
+Python provides a useful mechanism to define functions that accept arbitrary
+numbers of arguments and keyword arguments:
+
+.. code-block:: python
+
+ def generic(*args, **kwargs):
+ ... # do something with args and kwargs
+
+Such functions can also be created using pybind11:
+
+.. code-block:: cpp
+
+ void generic(py::args args, py::kwargs kwargs) {
+ /// .. do something with args
+ if (kwargs)
+ /// .. do something with kwargs
+ }
+
+ /// Binding code
+ m.def("generic", &generic);
+
+The class ``py::args`` derives from ``py::tuple`` and ``py::kwargs`` derives
+from ``py::dict``.
+
+You may also use just one or the other, and may combine these with other
+arguments as long as the ``py::args`` and ``py::kwargs`` arguments are the last
+arguments accepted by the function.
+
+Please refer to the other examples for details on how to iterate over these,
+and on how to cast their entries into C++ objects. A demonstration is also
+available in ``tests/test_kwargs_and_defaults.cpp``.
+
+.. note::
+
+ When combining \*args or \*\*kwargs with :ref:`keyword_args` you should
+ *not* include ``py::arg`` tags for the ``py::args`` and ``py::kwargs``
+ arguments.
+
+Default arguments revisited
+===========================
+
+The section on :ref:`default_args` previously discussed basic usage of default
+arguments using pybind11. One noteworthy aspect of their implementation is that
+default arguments are converted to Python objects right at declaration time.
+Consider the following example:
+
+.. code-block:: cpp
+
+ py::class_("MyClass")
+ .def("myFunction", py::arg("arg") = SomeType(123));
+
+In this case, pybind11 must already be set up to deal with values of the type
+``SomeType`` (via a prior instantiation of ``py::class_``), or an
+exception will be thrown.
+
+Another aspect worth highlighting is that the "preview" of the default argument
+in the function signature is generated using the object's ``__repr__`` method.
+If not available, the signature may not be very helpful, e.g.:
+
+.. code-block:: pycon
+
+ FUNCTIONS
+ ...
+ | myFunction(...)
+ | Signature : (MyClass, arg : SomeType = ) -> NoneType
+ ...
+
+The first way of addressing this is by defining ``SomeType.__repr__``.
+Alternatively, it is possible to specify the human-readable preview of the
+default argument manually using the ``arg_v`` notation:
+
+.. code-block:: cpp
+
+ py::class_("MyClass")
+ .def("myFunction", py::arg_v("arg", SomeType(123), "SomeType(123)"));
+
+Sometimes it may be necessary to pass a null pointer value as a default
+argument. In this case, remember to cast it to the underlying type in question,
+like so:
+
+.. code-block:: cpp
+
+ py::class_("MyClass")
+ .def("myFunction", py::arg("arg") = (SomeType *) nullptr);
+
+.. _nonconverting_arguments:
+
+Non-converting arguments
+========================
+
+Certain argument types may support conversion from one type to another. Some
+examples of conversions are:
+
+* :ref:`implicit_conversions` declared using ``py::implicitly_convertible()``
+* Calling a method accepting a double with an integer argument
+* Calling a ``std::complex`` argument with a non-complex python type
+ (for example, with a float). (Requires the optional ``pybind11/complex.h``
+ header).
+* Calling a function taking an Eigen matrix reference with a numpy array of the
+ wrong type or of an incompatible data layout. (Requires the optional
+ ``pybind11/eigen.h`` header).
+
+This behaviour is sometimes undesirable: the binding code may prefer to raise
+an error rather than convert the argument. This behaviour can be obtained
+through ``py::arg`` by calling the ``.noconvert()`` method of the ``py::arg``
+object, such as:
+
+.. code-block:: cpp
+
+ m.def("floats_only", [](double f) { return 0.5 * f; }, py::arg("f").noconvert());
+ m.def("floats_preferred", [](double f) { return 0.5 * f; }, py::arg("f"));
+
+Attempting the call the second function (the one without ``.noconvert()``) with
+an integer will succeed, but attempting to call the ``.noconvert()`` version
+will fail with a ``TypeError``:
+
+.. code-block:: pycon
+
+ >>> floats_preferred(4)
+ 2.0
+ >>> floats_only(4)
+ Traceback (most recent call last):
+ File "", line 1, in
+ TypeError: floats_only(): incompatible function arguments. The following argument types are supported:
+ 1. (f: float) -> float
+
+ Invoked with: 4
+
+You may, of course, combine this with the :var:`_a` shorthand notation (see
+:ref:`keyword_args`) and/or :ref:`default_args`. It is also permitted to omit
+the argument name by using the ``py::arg()`` constructor without an argument
+name, i.e. by specifying ``py::arg().noconvert()``.
+
+.. note::
+
+ When specifying ``py::arg`` options it is necessary to provide the same
+ number of options as the bound function has arguments. Thus if you want to
+ enable no-convert behaviour for just one of several arguments, you will
+ need to specify a ``py::arg()`` annotation for each argument with the
+ no-convert argument modified to ``py::arg().noconvert()``.
+
+.. _none_arguments:
+
+Allow/Prohibiting None arguments
+================================
+
+When a C++ type registered with :class:`py::class_` is passed as an argument to
+a function taking the instance as pointer or shared holder (e.g. ``shared_ptr``
+or a custom, copyable holder as described in :ref:`smart_pointers`), pybind
+allows ``None`` to be passed from Python which results in calling the C++
+function with ``nullptr`` (or an empty holder) for the argument.
+
+To explicitly enable or disable this behaviour, using the
+``.none`` method of the :class:`py::arg` object:
+
+.. code-block:: cpp
+
+ py::class_(m, "Dog").def(py::init<>());
+ py::class_(m, "Cat").def(py::init<>());
+ m.def("bark", [](Dog *dog) -> std::string {
+ if (dog) return "woof!"; /* Called with a Dog instance */
+ else return "(no dog)"; /* Called with None, d == nullptr */
+ }, py::arg("dog").none(true));
+ m.def("meow", [](Cat *cat) -> std::string {
+ // Can't be called with None argument
+ return "meow";
+ }, py::arg("cat").none(false));
+
+With the above, the Python call ``bark(None)`` will return the string ``"(no
+dog)"``, while attempting to call ``meow(None)`` will raise a ``TypeError``:
+
+.. code-block:: pycon
+
+ >>> from animals import Dog, Cat, bark, meow
+ >>> bark(Dog())
+ 'woof!'
+ >>> meow(Cat())
+ 'meow'
+ >>> bark(None)
+ '(no dog)'
+ >>> meow(None)
+ Traceback (most recent call last):
+ File "", line 1, in
+ TypeError: meow(): incompatible function arguments. The following argument types are supported:
+ 1. (cat: animals.Cat) -> str
+
+ Invoked with: None
+
+The default behaviour when the tag is unspecified is to allow ``None``.
+
+Overload resolution order
+=========================
+
+When a function or method with multiple overloads is called from Python,
+pybind11 determines which overload to call in two passes. The first pass
+attempts to call each overload without allowing argument conversion (as if
+every argument had been specified as ``py::arg().noconvert()`` as decribed
+above).
+
+If no overload succeeds in the no-conversion first pass, a second pass is
+attempted in which argument conversion is allowed (except where prohibited via
+an explicit ``py::arg().noconvert()`` attribute in the function definition).
+
+If the second pass also fails a ``TypeError`` is raised.
+
+Within each pass, overloads are tried in the order they were registered with
+pybind11.
+
+What this means in practice is that pybind11 will prefer any overload that does
+not require conversion of arguments to an overload that does, but otherwise prefers
+earlier-defined overloads to later-defined ones.
+
+.. note::
+
+ pybind11 does *not* further prioritize based on the number/pattern of
+ overloaded arguments. That is, pybind11 does not prioritize a function
+ requiring one conversion over one requiring three, but only prioritizes
+ overloads requiring no conversion at all to overloads that require
+ conversion of at least one argument.
diff --git a/external/pybind11/docs/advanced/misc.rst b/external/pybind11/docs/advanced/misc.rst
new file mode 100644
index 0000000..87481ba
--- /dev/null
+++ b/external/pybind11/docs/advanced/misc.rst
@@ -0,0 +1,272 @@
+Miscellaneous
+#############
+
+.. _macro_notes:
+
+General notes regarding convenience macros
+==========================================
+
+pybind11 provides a few convenience macros such as
+:func:`PYBIND11_MAKE_OPAQUE` and :func:`PYBIND11_DECLARE_HOLDER_TYPE`, and
+``PYBIND11_OVERLOAD_*``. Since these are "just" macros that are evaluated
+in the preprocessor (which has no concept of types), they *will* get confused
+by commas in a template argument such as ``PYBIND11_OVERLOAD(MyReturnValue, myFunc)``. In this case, the preprocessor assumes that the comma indicates
+the beginning of the next parameter. Use a ``typedef`` to bind the template to
+another name and use it in the macro to avoid this problem.
+
+.. _gil:
+
+Global Interpreter Lock (GIL)
+=============================
+
+When calling a C++ function from Python, the GIL is always held.
+The classes :class:`gil_scoped_release` and :class:`gil_scoped_acquire` can be
+used to acquire and release the global interpreter lock in the body of a C++
+function call. In this way, long-running C++ code can be parallelized using
+multiple Python threads. Taking :ref:`overriding_virtuals` as an example, this
+could be realized as follows (important changes highlighted):
+
+.. code-block:: cpp
+ :emphasize-lines: 8,9,31,32
+
+ class PyAnimal : public Animal {
+ public:
+ /* Inherit the constructors */
+ using Animal::Animal;
+
+ /* Trampoline (need one for each virtual function) */
+ std::string go(int n_times) {
+ /* Acquire GIL before calling Python code */
+ py::gil_scoped_acquire acquire;
+
+ PYBIND11_OVERLOAD_PURE(
+ std::string, /* Return type */
+ Animal, /* Parent class */
+ go, /* Name of function */
+ n_times /* Argument(s) */
+ );
+ }
+ };
+
+ PYBIND11_MODULE(example, m) {
+ py::class_ animal(m, "Animal");
+ animal
+ .def(py::init<>())
+ .def("go", &Animal::go);
+
+ py::class_(m, "Dog", animal)
+ .def(py::init<>());
+
+ m.def("call_go", [](Animal *animal) -> std::string {
+ /* Release GIL before calling into (potentially long-running) C++ code */
+ py::gil_scoped_release release;
+ return call_go(animal);
+ });
+ }
+
+The ``call_go`` wrapper can also be simplified using the `call_guard` policy
+(see :ref:`call_policies`) which yields the same result:
+
+.. code-block:: cpp
+
+ m.def("call_go", &call_go, py::call_guard());
+
+
+Binding sequence data types, iterators, the slicing protocol, etc.
+==================================================================
+
+Please refer to the supplemental example for details.
+
+.. seealso::
+
+ The file :file:`tests/test_sequences_and_iterators.cpp` contains a
+ complete example that shows how to bind a sequence data type, including
+ length queries (``__len__``), iterators (``__iter__``), the slicing
+ protocol and other kinds of useful operations.
+
+
+Partitioning code over multiple extension modules
+=================================================
+
+It's straightforward to split binding code over multiple extension modules,
+while referencing types that are declared elsewhere. Everything "just" works
+without any special precautions. One exception to this rule occurs when
+extending a type declared in another extension module. Recall the basic example
+from Section :ref:`inheritance`.
+
+.. code-block:: cpp
+
+ py::class_ pet(m, "Pet");
+ pet.def(py::init())
+ .def_readwrite("name", &Pet::name);
+
+ py::class_(m, "Dog", pet /* <- specify parent */)
+ .def(py::init())
+ .def("bark", &Dog::bark);
+
+Suppose now that ``Pet`` bindings are defined in a module named ``basic``,
+whereas the ``Dog`` bindings are defined somewhere else. The challenge is of
+course that the variable ``pet`` is not available anymore though it is needed
+to indicate the inheritance relationship to the constructor of ``class_``.
+However, it can be acquired as follows:
+
+.. code-block:: cpp
+
+ py::object pet = (py::object) py::module::import("basic").attr("Pet");
+
+ py::class_(m, "Dog", pet)
+ .def(py::init())
+ .def("bark", &Dog::bark);
+
+Alternatively, you can specify the base class as a template parameter option to
+``class_``, which performs an automated lookup of the corresponding Python
+type. Like the above code, however, this also requires invoking the ``import``
+function once to ensure that the pybind11 binding code of the module ``basic``
+has been executed:
+
+.. code-block:: cpp
+
+ py::module::import("basic");
+
+ py::class_(m, "Dog")
+ .def(py::init())
+ .def("bark", &Dog::bark);
+
+Naturally, both methods will fail when there are cyclic dependencies.
+
+Note that pybind11 code compiled with hidden-by-default symbol visibility (e.g.
+via the command line flag ``-fvisibility=hidden`` on GCC/Clang), which is
+required proper pybind11 functionality, can interfere with the ability to
+access types defined in another extension module. Working around this requires
+manually exporting types that are accessed by multiple extension modules;
+pybind11 provides a macro to do just this:
+
+.. code-block:: cpp
+
+ class PYBIND11_EXPORT Dog : public Animal {
+ ...
+ };
+
+Note also that it is possible (although would rarely be required) to share arbitrary
+C++ objects between extension modules at runtime. Internal library data is shared
+between modules using capsule machinery [#f6]_ which can be also utilized for
+storing, modifying and accessing user-defined data. Note that an extension module
+will "see" other extensions' data if and only if they were built with the same
+pybind11 version. Consider the following example:
+
+.. code-block:: cpp
+
+ auto data = (MyData *) py::get_shared_data("mydata");
+ if (!data)
+ data = (MyData *) py::set_shared_data("mydata", new MyData(42));
+
+If the above snippet was used in several separately compiled extension modules,
+the first one to be imported would create a ``MyData`` instance and associate
+a ``"mydata"`` key with a pointer to it. Extensions that are imported later
+would be then able to access the data behind the same pointer.
+
+.. [#f6] https://docs.python.org/3/extending/extending.html#using-capsules
+
+Module Destructors
+==================
+
+pybind11 does not provide an explicit mechanism to invoke cleanup code at
+module destruction time. In rare cases where such functionality is required, it
+is possible to emulate it using Python capsules or weak references with a
+destruction callback.
+
+.. code-block:: cpp
+
+ auto cleanup_callback = []() {
+ // perform cleanup here -- this function is called with the GIL held
+ };
+
+ m.add_object("_cleanup", py::capsule(cleanup_callback));
+
+This approach has the potential downside that instances of classes exposed
+within the module may still be alive when the cleanup callback is invoked
+(whether this is acceptable will generally depend on the application).
+
+Alternatively, the capsule may also be stashed within a type object, which
+ensures that it not called before all instances of that type have been
+collected:
+
+.. code-block:: cpp
+
+ auto cleanup_callback = []() { /* ... */ };
+ m.attr("BaseClass").attr("_cleanup") = py::capsule(cleanup_callback);
+
+Both approaches also expose a potentially dangerous ``_cleanup`` attribute in
+Python, which may be undesirable from an API standpoint (a premature explicit
+call from Python might lead to undefined behavior). Yet another approach that
+avoids this issue involves weak reference with a cleanup callback:
+
+.. code-block:: cpp
+
+ // Register a callback function that is invoked when the BaseClass object is colelcted
+ py::cpp_function cleanup_callback(
+ [](py::handle weakref) {
+ // perform cleanup here -- this function is called with the GIL held
+
+ weakref.dec_ref(); // release weak reference
+ }
+ );
+
+ // Create a weak reference with a cleanup callback and initially leak it
+ (void) py::weakref(m.attr("BaseClass"), cleanup_callback).release();
+
+
+Generating documentation using Sphinx
+=====================================
+
+Sphinx [#f4]_ has the ability to inspect the signatures and documentation
+strings in pybind11-based extension modules to automatically generate beautiful
+documentation in a variety formats. The python_example repository [#f5]_ contains a
+simple example repository which uses this approach.
+
+There are two potential gotchas when using this approach: first, make sure that
+the resulting strings do not contain any :kbd:`TAB` characters, which break the
+docstring parsing routines. You may want to use C++11 raw string literals,
+which are convenient for multi-line comments. Conveniently, any excess
+indentation will be automatically be removed by Sphinx. However, for this to
+work, it is important that all lines are indented consistently, i.e.:
+
+.. code-block:: cpp
+
+ // ok
+ m.def("foo", &foo, R"mydelimiter(
+ The foo function
+
+ Parameters
+ ----------
+ )mydelimiter");
+
+ // *not ok*
+ m.def("foo", &foo, R"mydelimiter(The foo function
+
+ Parameters
+ ----------
+ )mydelimiter");
+
+By default, pybind11 automatically generates and prepends a signature to the docstring of a function
+registered with ``module::def()`` and ``class_::def()``. Sometimes this
+behavior is not desirable, because you want to provide your own signature or remove
+the docstring completely to exclude the function from the Sphinx documentation.
+The class ``options`` allows you to selectively suppress auto-generated signatures:
+
+.. code-block:: cpp
+
+ PYBIND11_MODULE(example, m) {
+ py::options options;
+ options.disable_function_signatures();
+
+ m.def("add", [](int a, int b) { return a + b; }, "A function which adds two numbers");
+ }
+
+Note that changes to the settings affect only function bindings created during the
+lifetime of the ``options`` instance. When it goes out of scope at the end of the module's init function,
+the default settings are restored to prevent unwanted side effects.
+
+.. [#f4] http://www.sphinx-doc.org
+.. [#f5] http://github.com/pybind/python_example
diff --git a/external/pybind11/docs/advanced/pycpp/index.rst b/external/pybind11/docs/advanced/pycpp/index.rst
new file mode 100644
index 0000000..6885bdc
--- /dev/null
+++ b/external/pybind11/docs/advanced/pycpp/index.rst
@@ -0,0 +1,13 @@
+Python C++ interface
+####################
+
+pybind11 exposes Python types and functions using thin C++ wrappers, which
+makes it possible to conveniently call Python code from C++ without resorting
+to Python's C API.
+
+.. toctree::
+ :maxdepth: 2
+
+ object
+ numpy
+ utilities
diff --git a/external/pybind11/docs/advanced/pycpp/numpy.rst b/external/pybind11/docs/advanced/pycpp/numpy.rst
new file mode 100644
index 0000000..98b0c25
--- /dev/null
+++ b/external/pybind11/docs/advanced/pycpp/numpy.rst
@@ -0,0 +1,366 @@
+.. _numpy:
+
+NumPy
+#####
+
+Buffer protocol
+===============
+
+Python supports an extremely general and convenient approach for exchanging
+data between plugin libraries. Types can expose a buffer view [#f2]_, which
+provides fast direct access to the raw internal data representation. Suppose we
+want to bind the following simplistic Matrix class:
+
+.. code-block:: cpp
+
+ class Matrix {
+ public:
+ Matrix(size_t rows, size_t cols) : m_rows(rows), m_cols(cols) {
+ m_data = new float[rows*cols];
+ }
+ float *data() { return m_data; }
+ size_t rows() const { return m_rows; }
+ size_t cols() const { return m_cols; }
+ private:
+ size_t m_rows, m_cols;
+ float *m_data;
+ };
+
+The following binding code exposes the ``Matrix`` contents as a buffer object,
+making it possible to cast Matrices into NumPy arrays. It is even possible to
+completely avoid copy operations with Python expressions like
+``np.array(matrix_instance, copy = False)``.
+
+.. code-block:: cpp
+
+ py::class_(m, "Matrix", py::buffer_protocol())
+ .def_buffer([](Matrix &m) -> py::buffer_info {
+ return py::buffer_info(
+ m.data(), /* Pointer to buffer */
+ sizeof(float), /* Size of one scalar */
+ py::format_descriptor::format(), /* Python struct-style format descriptor */
+ 2, /* Number of dimensions */
+ { m.rows(), m.cols() }, /* Buffer dimensions */
+ { sizeof(float) * m.rows(), /* Strides (in bytes) for each index */
+ sizeof(float) }
+ );
+ });
+
+Supporting the buffer protocol in a new type involves specifying the special
+``py::buffer_protocol()`` tag in the ``py::class_`` constructor and calling the
+``def_buffer()`` method with a lambda function that creates a
+``py::buffer_info`` description record on demand describing a given matrix
+instance. The contents of ``py::buffer_info`` mirror the Python buffer protocol
+specification.
+
+.. code-block:: cpp
+
+ struct buffer_info {
+ void *ptr;
+ ssize_t itemsize;
+ std::string format;
+ ssize_t ndim;
+ std::vector shape;
+ std::vector strides;
+ };
+
+To create a C++ function that can take a Python buffer object as an argument,
+simply use the type ``py::buffer`` as one of its arguments. Buffers can exist
+in a great variety of configurations, hence some safety checks are usually
+necessary in the function body. Below, you can see an basic example on how to
+define a custom constructor for the Eigen double precision matrix
+(``Eigen::MatrixXd``) type, which supports initialization from compatible
+buffer objects (e.g. a NumPy matrix).
+
+.. code-block:: cpp
+
+ /* Bind MatrixXd (or some other Eigen type) to Python */
+ typedef Eigen::MatrixXd Matrix;
+
+ typedef Matrix::Scalar Scalar;
+ constexpr bool rowMajor = Matrix::Flags & Eigen::RowMajorBit;
+
+ py::class_(m, "Matrix", py::buffer_protocol())
+ .def("__init__", [](Matrix &m, py::buffer b) {
+ typedef Eigen::Stride Strides;
+
+ /* Request a buffer descriptor from Python */
+ py::buffer_info info = b.request();
+
+ /* Some sanity checks ... */
+ if (info.format != py::format_descriptor::format())
+ throw std::runtime_error("Incompatible format: expected a double array!");
+
+ if (info.ndim != 2)
+ throw std::runtime_error("Incompatible buffer dimension!");
+
+ auto strides = Strides(
+ info.strides[rowMajor ? 0 : 1] / (py::ssize_t)sizeof(Scalar),
+ info.strides[rowMajor ? 1 : 0] / (py::ssize_t)sizeof(Scalar));
+
+ auto map = Eigen::Map(
+ static_cast(info.ptr), info.shape[0], info.shape[1], strides);
+
+ new (&m) Matrix(map);
+ });
+
+For reference, the ``def_buffer()`` call for this Eigen data type should look
+as follows:
+
+.. code-block:: cpp
+
+ .def_buffer([](Matrix &m) -> py::buffer_info {
+ return py::buffer_info(
+ m.data(), /* Pointer to buffer */
+ sizeof(Scalar), /* Size of one scalar */
+ py::format_descriptor::format(), /* Python struct-style format descriptor */
+ 2, /* Number of dimensions */
+ { m.rows(), m.cols() }, /* Buffer dimensions */
+ { sizeof(Scalar) * (rowMajor ? m.cols() : 1),
+ sizeof(Scalar) * (rowMajor ? 1 : m.rows()) }
+ /* Strides (in bytes) for each index */
+ );
+ })
+
+For a much easier approach of binding Eigen types (although with some
+limitations), refer to the section on :doc:`/advanced/cast/eigen`.
+
+.. seealso::
+
+ The file :file:`tests/test_buffers.cpp` contains a complete example
+ that demonstrates using the buffer protocol with pybind11 in more detail.
+
+.. [#f2] http://docs.python.org/3/c-api/buffer.html
+
+Arrays
+======
+
+By exchanging ``py::buffer`` with ``py::array`` in the above snippet, we can
+restrict the function so that it only accepts NumPy arrays (rather than any
+type of Python object satisfying the buffer protocol).
+
+In many situations, we want to define a function which only accepts a NumPy
+array of a certain data type. This is possible via the ``py::array_t