1cc98d02ef4e1cd8a6d2d153318b198a877ea06642d3e1195aba2da22184a6fc

third-party/DPVO/Pangolin/components/pango_core/CMakeLists.txt

@@ -0,0 +1,74 @@
+get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME)
+
+if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+    target_compile_definitions(${COMPONENT} PUBLIC "_OSX_")
+elseif(WIN32 OR WIN64)
+    target_compile_definitions(${COMPONENT} PUBLIC "_WIN_")
+elseif(EMSCRIPTEN)
+    target_compile_definitions(${COMPONENT} PUBLIC "_EMSCRIPTEN_")
+else()
+    target_compile_definitions(${COMPONENT} PUBLIC "_LINUX_")
+endif()
+
+target_sources( ${COMPONENT}
+PRIVATE
+    ${CMAKE_CURRENT_LIST_DIR}/src/file_extension.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/file_utils.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/sigstate.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/threadedfilebuf.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/avx_math.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/uri.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/param_set.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/factory/factory_registry.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/factory/factory_help.cpp
+)
+
+if (UNIX)
+    target_sources( ${COMPONENT} PRIVATE
+        ${CMAKE_CURRENT_LIST_DIR}/src/posix/condition_variable.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/posix/semaphore.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/posix/shared_memory_buffer.cpp
+    )
+    if (NOT APPLE)
+        target_link_libraries(${COMPONENT} PUBLIC rt)
+    endif()
+endif()
+
+
+target_compile_features(${COMPONENT} PUBLIC cxx_decltype_auto )
+target_include_directories(${COMPONENT} PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
+install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/include"
+  DESTINATION ${CMAKE_INSTALL_PREFIX}
+)
+
+find_package(Threads QUIET)
+if(Threads_FOUND)
+    target_link_libraries(${COMPONENT} PUBLIC Threads::Threads)
+endif()
+
+## Generate symbol export helper header on MSVC
+IF(MSVC)
+    include(GenerateExportHeader)
+    GENERATE_EXPORT_HEADER( ${COMPONENT}
+        BASE_NAME PANGOLIN
+        EXPORT_MACRO_NAME PANGOLIN_EXPORT
+        EXPORT_FILE_NAME "${CMAKE_CURRENT_BINARY_DIR}/include/pangolin/pangolin_export.h"
+        STATIC_DEFINE PANGOLIN_BUILT_AS_STATIC
+    )
+    target_include_directories(${COMPONENT} PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    )
+    install(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/include"
+      DESTINATION ${CMAKE_INSTALL_PREFIX}
+    )
+ENDIF()
+
+if(BUILD_TESTS)
+    add_executable(test_uris ${CMAKE_CURRENT_LIST_DIR}/tests/tests_uri.cpp)
+    target_link_libraries(test_uris PRIVATE Catch2::Catch2 ${COMPONENT})
+    catch_discover_tests(test_uris)
+endif()

third-party/DPVO/Pangolin/components/pango_core/include/NaturalSort/LICENSE.md

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

third-party/DPVO/Pangolin/components/pango_core/include/NaturalSort/README.md

@@ -0,0 +1,61 @@
+# NaturalSort
+C++ Header File for Natural Comparison and Natural Sort
+
+
+##### Calling Methods 
+
+*  __For Natural Sorting__
+
+		void SI::natural::sort(Container<String>);
+		
+		void SI::natural::sort(IteratorBegin<String>,IteratorEnd<String>);
+		
+		void SI::natural::sort<String,CArraySize>(CArray<String>);
+		
+	
+*  __For Natural Comparision__
+
+		bool SI::natural::compare<String>(String lhs,String rhs);
+		bool SI::natural::compare<String>(char *const lhs,char *const rhs);
+	
+	Here we can have
+			
+			std::vector<std::string> 	as Container<String>
+			String 					as std::string
+			CArray<String>			as std::string[CArraySize]
+		
+	
+	
+		
+
+#####  Example
+
+*  __Inputs__
+
+		Hello 100
+		Hello 34
+		Hello 9
+		Hello 25
+		Hello 10
+		Hello 8
+
+*  __Normal Sort Output__
+
+		Hello 10
+		Hello 100
+		Hello 25
+		Hello 34
+		Hello 8
+		Hello 9
+
+*  __Natural Sort Output__
+
+		Hello 8
+		Hello 9
+		Hello 10
+		Hello 25
+		Hello 34
+		Hello 100
+
+
+

third-party/DPVO/Pangolin/components/pango_core/include/NaturalSort/natural_sort.hpp

@@ -0,0 +1,281 @@
+/*
+	The MIT License (MIT)
+	Copyright (c) 2016 Gagan Kumar(scopeInfinity)
+	Complete License at https://raw.githubusercontent.com/scopeInfinity/NaturalSort/master/LICENSE.md
+*/
+
+/**********************************************************************
+Calling Methods :
+
+	//For Natural Sorting
+	void SI::natural::sort(Container<String>);
+	void SI::natural::sort(IteratorBegin<String>,IteratorEnd<String>);
+	void SI::natural::sort<String,CArraySize>(CArray<String>);
+
+	//For Natural Comparision
+	bool SI::natural::compare<String>(String lhs,String rhs);
+	bool SI::natural::compare<String>(char *const lhs,char *const rhs);
+
+	Here we can have
+		std::vector<std::string> 	as Container<String>
+		String 						as std::string
+		CArray<String>				as std::string[CArraySize]
+
+***********************************************************************/
+#ifndef SI_sort_HPP
+#define SI_sort_HPP
+#include <cctype>
+#include <algorithm>
+#include <vector>
+
+
+namespace SI
+{
+namespace natural
+{
+	namespace detail
+	{
+		/********** Compare Two Character CaseInsensitive ********/
+		template<typename ElementType>
+		bool natural_less(const ElementType &lhs,const ElementType &rhs)
+		{
+			if(tolower(lhs)<tolower(rhs))
+				return true;
+			return false;
+		}
+
+		template<typename ElementType>
+		bool is_not_digit(const ElementType &x)
+		{
+			return !isdigit(x);
+		}
+
+		/********** Compare Two Iterators CaseInsensitive ********/
+		template<typename ElementType,typename Iterator>
+		struct comp_over_iterator
+		{
+			int operator()(const Iterator &lhs,const Iterator &rhs) const
+			{
+				if(natural_less<ElementType>(*lhs,*rhs))
+					return -1;
+				if(natural_less<ElementType>(*rhs,*lhs))
+					return +1;
+				return 0;
+			}
+		};
+	
+		/****************************************************
+		Comparing two SubString from (Begin,End Iterator each)
+		with only digits.
+		Usage :
+			int compare_number()(\
+			FirstNumberBeginIterator,FirstNumberEndIterator,isFirstNumberFractionalPart\
+			SecondNumberBeginIterator,SecondNumberEndIterator,isSecondNumberFractionalPart\
+			);
+
+		Returns : 
+			-1  - Number1  <   Number2
+			 0  - Number1  ==  Number2
+			 1  - Number1  >   Number2
+
+		***************************************************/
+
+
+		template<typename ValueType, typename Iterator>
+		struct compare_number
+		{
+		private:
+			//If Number is Itself fractional Part
+			int fractional(Iterator lhsBegin,Iterator lhsEnd, Iterator rhsBegin,Iterator rhsEnd)
+			{
+				while(lhsBegin<lhsEnd && rhsBegin<rhsEnd)
+				{
+					int local_compare = comp_over_iterator<ValueType, Iterator>()(lhsBegin,rhsBegin);
+					if(local_compare!=0)
+						return local_compare;
+					lhsBegin++;
+					rhsBegin++;
+				}
+				while(lhsBegin<lhsEnd && *lhsBegin=='0') lhsBegin++;
+				while(rhsBegin<rhsEnd && *rhsBegin=='0') rhsBegin++;
+				if(lhsBegin==lhsEnd && rhsBegin!=rhsEnd)
+					return -1;
+				else if(lhsBegin!=lhsEnd && rhsBegin==rhsEnd)
+					return +1;
+				else //lhsBegin==lhsEnd && rhsBegin==rhsEnd
+					return 0;		
+			}
+			int non_fractional(Iterator lhsBegin,Iterator lhsEnd, Iterator rhsBegin,Iterator rhsEnd)
+			{
+				//Skip Inital Zero's
+				while(lhsBegin<lhsEnd && *lhsBegin=='0') lhsBegin++;
+				while(rhsBegin<rhsEnd && *rhsBegin=='0') rhsBegin++; 
+		
+				//Comparing By Length of Both String
+				if(lhsEnd-lhsBegin<rhsEnd-rhsBegin)
+					return -1;
+				if(lhsEnd-lhsBegin>rhsEnd-rhsBegin)
+					return +1;
+
+				//Equal In length
+				while(lhsBegin<lhsEnd)
+				{
+					int local_compare = comp_over_iterator<ValueType, Iterator>()(lhsBegin,rhsBegin);
+					if(local_compare!=0)
+						return local_compare;
+					lhsBegin++;
+					rhsBegin++;
+				}
+				return 0;
+			}
+
+
+		public:
+			int operator()(\
+				Iterator lhsBegin,Iterator lhsEnd,bool isFractionalPart1,\
+				Iterator rhsBegin,Iterator rhsEnd,bool isFractionalPart2)
+			{
+				if(isFractionalPart1 && !isFractionalPart2)
+					return true;	//0<num1<1 && num2>=1
+				if(!isFractionalPart1 && isFractionalPart2)
+					return false;	//0<num2<1 && num1>=1
+
+				//isFractionPart1 == isFactionalPart2
+				if(isFractionalPart1)
+					return fractional(lhsBegin,lhsEnd,rhsBegin,rhsEnd);
+				else
+					return non_fractional(lhsBegin,lhsEnd,rhsBegin,rhsEnd);
+			}
+		};
+		
+
+		
+
+
+	}// namespace detail
+
+	/***********************************************************************
+	Natural Comparision of Two String using both's (Begin and End Iterator)
+
+	Returns : 
+		-1  - String1  <   String2
+		 0  - String1  ==  String2
+		 1  - String1  >   String2
+
+	Suffix 1 represents for components of 1st String
+	Suffix 2 represents for components of 2nd String
+	************************************************************************/
+
+	template<typename ElementType, typename Iterator>
+	bool _compare(\
+		const Iterator &lhsBegin,const Iterator &lhsEnd,\
+		const Iterator &rhsBegin,const Iterator &rhsEnd)
+	{
+		Iterator current1 = lhsBegin,current2 = rhsBegin;
+
+		//Flag for Space Found Check
+		bool flag_found_space1 = false,flag_found_space2 = false;
+
+
+		while(current1!=lhsEnd && current2!=rhsEnd)
+		{
+			//Ignore More than One Continous Space
+
+			/******************************************
+			For HandlingComparision Like
+				Hello   9
+				Hello  10
+				Hello 123
+			******************************************/
+			while(flag_found_space1 && current1!=lhsEnd && *current1==' ') current1++;
+			flag_found_space1=false;
+			if(*current1==' ') flag_found_space1 = true;
+			
+			while(flag_found_space2 && current2!=rhsEnd && *current2==' ') current2++;
+			flag_found_space2=false;
+			if(*current2==' ') flag_found_space2 = true;
+			
+
+			if( !isdigit(*current1 ) || !isdigit(*current2))
+			{
+				// Normal comparision if any of character is non digit character
+				if(detail::natural_less<ElementType>(*current1,*current2))
+					return true;
+				if(detail::natural_less<ElementType>(*current2,*current1))
+					return false;
+				current1++;
+				current2++;
+			}
+			else
+			{
+				/*********************************
+				Capture Numeric Part of Both String
+				and then using it to compare Both
+
+				***********************************/
+				Iterator last_nondigit1 = 	std::find_if(current1,lhsEnd,detail::is_not_digit<ElementType>);
+				Iterator last_nondigit2 = 	std::find_if(current2,rhsEnd,detail::is_not_digit<ElementType>);
+				
+				int result = detail::compare_number<ElementType, Iterator>()(\
+					current1,last_nondigit1,(current1>lhsBegin && *(current1-1)=='.'), \
+					current2,last_nondigit2,(current2>rhsBegin && *(current2-1)=='.'));
+				if(result<0)
+					return true;
+				if(result>0)
+					return false;
+				current1 = last_nondigit1;
+				current2 = last_nondigit2;
+			}
+		}
+
+		if (current1 == lhsEnd && current2 == rhsEnd) {
+			return false;
+		} else {
+			return current1 == lhsEnd;
+		}
+	}
+
+	template<typename String>
+	inline bool compare(const String &first ,const String &second)
+	{
+		return _compare<typename String::value_type,typename String::const_iterator>(first.begin(),first.end(),second.begin(),second.end());
+	}
+	template<>
+	inline bool compare(char *const &first ,char *const &second)
+	{
+		char* it1 = first;
+		while(*it1!='\0')it1++;
+		char* it2 = second;
+		while(*it2!='\0')it2++;
+		return _compare<char,char*>(first,it1,second,it2);
+	}
+
+
+	template<typename Container>
+	inline void sort(Container &container)
+	{
+		std::sort(container.begin(),container.end(),compare<typename Container::value_type>);
+	}
+
+	template<typename Iterator>
+	inline void sort(const Iterator &first,const Iterator &end)
+	{
+		std::sort(first,end,compare<typename Iterator::value_type>);
+	}
+	
+	template<typename ValueType>
+	inline void sort(ValueType* const first,ValueType* const end)
+	{
+		std::sort(first,end,compare<ValueType>);
+	}
+
+	template<typename ValueType,int N>
+	inline void sort(ValueType container[N])
+	{
+		std::sort(&container[0],&container[0]+N,compare<ValueType>);
+	}
+	
+}//namespace natural
+}//namespace SI
+
+#endif

third-party/DPVO/Pangolin/components/pango_core/include/dynalo/detail/config.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#if defined(__linux__) || defined(__linux) || defined(linux) || defined(_LINUX)
+    #define DYNALO_HAS_LINUX
+#elif defined(_WIN32) || defined(_WIN64)
+    #define DYNALO_HAS_WINDOWS
+#elif defined(__APPLE__)
+    #define DYNALO_HAS_MACOS
+#else
+    #error "dynalo/detail/config.hpp OS Not Supported"
+#endif
+
+#define DYNALO_VERSION_MAJOR 1
+#define DYNALO_VERSION_MINOR 0
+#define DYNALO_VERSION_PATCH 3
+#define DYNALO_VERSION       0x010003  /**< major minor patch*/

third-party/DPVO/Pangolin/components/pango_core/include/dynalo/detail/linux/dynalo.hpp

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <string>
+#include <stdexcept>
+
+#include <dlfcn.h>
+
+namespace dynalo { namespace detail
+{
+
+inline
+std::string last_error()
+{
+    return std::string(::dlerror());
+}
+
+namespace native
+{
+
+using handle = void*;
+
+inline handle invalid_handle() { return nullptr; }
+
+enum class resolve
+{
+    now = RTLD_NOW,
+    lazy = RTLD_LAZY,
+};
+
+namespace name
+{
+
+inline std::string prefix()    { return std::string("lib"); }
+inline std::string suffix()    { return std::string();      }
+inline std::string extension() { return std::string("so");  }
+
+}
+
+}
+
+inline
+native::handle open(const std::string& dyn_lib_path, native::resolve symbol_resolution)
+{
+    native::handle lib_handle = ::dlopen(dyn_lib_path.c_str(), static_cast<int>(symbol_resolution));
+    if (lib_handle == nullptr)
+    {
+        throw std::runtime_error(std::string("Failed to open [dyn_lib_path:") + dyn_lib_path + "]: " + last_error());
+    }
+
+    return lib_handle;
+}
+
+inline
+void close(native::handle lib_handle)
+{
+    const int rc = ::dlclose(lib_handle);
+    if (rc != 0)
+    {
+        throw std::runtime_error(std::string("Failed to close the dynamic library: ") + last_error());
+    }
+}
+
+template <typename FunctionSignature>
+inline
+FunctionSignature* get_function(native::handle lib_handle, const std::string& func_name)
+{
+    void* func_ptr = ::dlsym(lib_handle, func_name.c_str());
+    if (func_ptr == nullptr)
+    {
+        throw std::runtime_error(std::string("Failed to get [func_name:") + func_name + "]: " + last_error());
+    }
+
+    return reinterpret_cast<FunctionSignature*>(func_ptr);
+}
+
+}}

third-party/DPVO/Pangolin/components/pango_core/include/dynalo/detail/macos/dynalo.hpp

@@ -0,0 +1,76 @@
+#pragma once
+
+#include <string>
+#include <stdexcept>
+
+#include <dlfcn.h>
+
+namespace dynalo { namespace detail
+{
+
+inline
+std::string last_error()
+{
+	return std::string(::dlerror());
+}
+
+namespace native
+{
+
+using handle = void*;
+
+inline handle invalid_handle() { return nullptr; }
+
+enum class resolve
+{
+    now = RTLD_NOW,
+    lazy = RTLD_LAZY,
+};
+
+namespace name
+{
+
+inline std::string prefix()    { return std::string("lib"); }
+inline std::string suffix()    { return std::string();      }
+inline std::string extension() { return std::string("dylib");  }
+
+}
+
+}
+
+inline
+native::handle open(const std::string& dyn_lib_path, native::resolve symbol_resolution)
+{
+    native::handle lib_handle = ::dlopen(dyn_lib_path.c_str(), static_cast<int>(symbol_resolution) );
+	if (lib_handle == nullptr)
+	{
+		throw std::runtime_error(std::string("Failed to open [dyn_lib_path:") + dyn_lib_path + "]: " + last_error());
+	}
+
+	return lib_handle;
+}
+
+inline
+void close(native::handle lib_handle)
+{
+	const int rc = ::dlclose(lib_handle);
+	if (rc != 0)
+	{
+		throw std::runtime_error(std::string("Failed to close the dynamic library: ") + last_error());
+	}
+}
+
+template <typename FunctionSignature>
+inline
+FunctionSignature* get_function(native::handle lib_handle, const std::string& func_name)
+{
+	void* func_ptr = ::dlsym(lib_handle, func_name.c_str());
+	if (func_ptr == nullptr)
+	{
+		throw std::runtime_error(std::string("Failed to get [func_name:") + func_name + "]: " + last_error());
+	}
+
+	return reinterpret_cast<FunctionSignature*>(func_ptr);
+}
+
+}}

third-party/DPVO/Pangolin/components/pango_core/include/dynalo/detail/windows/dynalo.hpp

@@ -0,0 +1,107 @@
+#pragma once
+
+#include <string>
+#include <stdexcept>
+
+#include <Windows.h>
+#include <strsafe.h>
+
+namespace dynalo { namespace detail
+{
+inline
+std::string last_error()
+{
+    // https://msdn.microsoft.com/en-us/library/ms680582%28VS.85%29.aspx
+    LPVOID lpMsgBuf;
+    DWORD dw = ::GetLastError();
+
+    ::FormatMessage(
+        FORMAT_MESSAGE_ALLOCATE_BUFFER |
+        FORMAT_MESSAGE_FROM_SYSTEM |
+        FORMAT_MESSAGE_IGNORE_INSERTS,
+        NULL,
+        dw,
+        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        (LPTSTR) &lpMsgBuf,
+        0, NULL );
+
+    LPVOID lpDisplayBuf = (LPVOID)::LocalAlloc(LMEM_ZEROINIT,
+        (::lstrlen((LPCTSTR)lpMsgBuf) + 40) * sizeof(TCHAR));
+
+    ::StringCchPrintf((LPTSTR)lpDisplayBuf,
+        ::LocalSize(lpDisplayBuf) / sizeof(TCHAR),
+        TEXT("Failed with error %d: %s"),
+        dw, lpMsgBuf);
+
+    std::string err_str((LPCTSTR)lpDisplayBuf);
+
+    ::LocalFree(lpMsgBuf);
+    ::LocalFree(lpDisplayBuf);
+
+    return err_str;
+}
+
+
+namespace native
+{
+
+using handle = HMODULE;
+
+inline handle invalid_handle() { return nullptr; }
+
+// Windows LoadLibrary does not offer flexibility to choose.
+// These values are ignored.
+enum class resolve
+{
+    now,
+    lazy,
+};
+
+namespace name
+{
+
+inline std::string prefix()    { return std::string();      }
+inline std::string suffix()    { return std::string();      }
+inline std::string extension() { return std::string("dll"); }
+
+}
+
+}
+
+inline
+native::handle open(const std::string& dyn_lib_path, native::resolve /*symbol_resolution*/)
+{
+    // Windows LoadLibrary behaviour is most similar to RTLD_NOW
+    native::handle lib_handle = ::LoadLibrary(dyn_lib_path.c_str());
+    if (lib_handle == nullptr)
+    {
+        throw std::runtime_error(std::string("Failed to open [dyn_lib_path:") + dyn_lib_path + "]: " + last_error());
+    }
+
+    return lib_handle;
+}
+
+inline
+void close(native::handle lib_handle)
+{
+    const BOOL rc = ::FreeLibrary(lib_handle);
+    if (rc == 0)  // https://msdn.microsoft.com/en-us/library/windows/desktop/ms683152(v=vs.85).aspx
+    {
+        throw std::runtime_error(std::string("Failed to close the dynamic library: ") + last_error());
+    }
+}
+
+template <typename FunctionSignature>
+inline
+FunctionSignature* get_function(native::handle lib_handle, const std::string& func_name)
+{
+    FARPROC func_ptr = ::GetProcAddress(lib_handle, func_name.c_str());
+    if (func_ptr == nullptr)
+    {
+        throw std::runtime_error(std::string("Failed to get [func_name:") + func_name + "]: " + last_error());
+    }
+
+    return reinterpret_cast<FunctionSignature*>(func_ptr);
+}
+
+}}

third-party/DPVO/Pangolin/components/pango_core/include/dynalo/dynalo.hpp

@@ -0,0 +1,184 @@
+#pragma once
+
+#include "detail/config.hpp"
+
+#if defined(DYNALO_HAS_LINUX)
+    #include "detail/linux/dynalo.hpp"
+#elif defined(DYNALO_HAS_WINDOWS)
+    #include "detail/windows/dynalo.hpp"
+#elif defined(DYNALO_HAS_MACOS)
+    #include "detail/macos/dynalo.hpp"
+#endif
+
+/// DYNAmic LOading of shared libraries and access to their exported functions
+namespace dynalo
+{
+
+namespace native
+{
+
+/// Native handle (usuall a pointer) on the loaded shared library
+using handle = detail::native::handle;
+
+/// Symbol resolution options
+using resolve = detail::native::resolve;
+
+/// @return An invalid library handle
+inline
+handle invalid_handle()
+{
+    return detail::native::invalid_handle();
+}
+
+namespace name
+{
+
+/// @return The name prefix of a shared library on the current system
+inline
+std::string prefix()
+{
+    return detail::native::name::prefix();
+}
+
+/// @return The name suffix of a shared library on the current system
+inline
+std::string suffix()
+{
+    return detail::native::name::suffix();
+}
+
+/// @return The file extension of a shared library on the current system
+inline
+std::string extension()
+{
+    return detail::native::name::extension();
+}
+
+}
+
+}
+
+/// @param lib_name Name of the library without neither the lib prefix, suffix nor file extension
+///
+/// @return The native name of the shared library.
+///         e.g. If @p lib_name is `awesome`,
+///         then this function will return `libawesome.so` in Linux and `awesome.dll` in Windows
+inline
+std::string to_native_name(const std::string& lib_name)
+{
+    using namespace native::name;
+    if (!extension().empty())
+    {
+        return prefix() + lib_name + suffix() + std::string(".") + extension();
+    }
+    else
+    {
+        return prefix() + lib_name + suffix();
+    }
+}
+
+/// Loads a shared library
+///
+/// @param dyn_lib_path Path to the shared library file to be loaded
+/// @param resolution Option for how to treat symbol resolution during library opening.
+///
+/// @return The handle of the loaded shared library
+///
+/// @throw std::runtime_error If it fails to load the library
+inline
+native::handle open(const std::string& dyn_lib_path, native::resolve resolution = native::resolve::lazy)
+{
+    return detail::open(dyn_lib_path, resolution);
+}
+
+/// Unloads the shared library which handle is @p lib_handle
+///
+/// @param lib_handle The handle of the library to be unloaded
+///
+/// @throw std::runtime_error If it fails to unload the shared library
+inline
+void close(native::handle lib_handle)
+{
+    detail::close(lib_handle);
+}
+
+/// Looks up a function in the shared library and returns pointer to it
+///
+/// @tparam FunctionSignature The signature of the function to be looked up.
+///                           i.e. `return_type(param_types...)`
+///                           e.g. `void(const char*)`, `bool(int, int)`
+///
+/// @param lib_handle The handle of the library that contains the function
+/// @param func_name  The name of the function to find
+///
+/// @return A pointer to the @p func_name function
+///
+/// @throw std::runtime_error If it fails to find the @p func_name function
+template <typename FunctionSignature>
+inline
+FunctionSignature* get_function(native::handle lib_handle, const std::string& func_name)
+{
+    return detail::get_function<FunctionSignature>(lib_handle, func_name);
+}
+
+
+/// A shared library
+///
+/// This class wraps the open/close/get_function functions of the dynalo namespace:
+/// <ul>
+///     <li>The shared library is loaded in the class' constructor</li>
+///     <li>You can get pointer to a functio using library::get_function</li>
+///     <li>The shared library is automatically unloaed in the destructor</li>
+/// </ul>
+class library
+{
+private:
+    native::handle m_handle;
+
+public:
+    library()                          = delete;
+    library(const library&)            = delete;
+    library& operator=(const library&) = delete;
+
+    library(library&& other)
+    : m_handle(other.m_handle)
+    {
+        other.m_handle = native::invalid_handle();
+    }
+
+    library& operator=(library&& other)
+    {
+        m_handle       = other.m_handle;
+        other.m_handle = native::invalid_handle();
+        return *this;
+    }
+
+    /// Unloads the shared library using dynalo::close
+    ~library()
+    {
+        if (m_handle != native::invalid_handle())
+        {
+            dynalo::close(m_handle);
+        }
+    }
+
+    /// Loads a shared library using dynalo::open
+    explicit library(const std::string& dyn_lib_path)
+    : m_handle(dynalo::open(dyn_lib_path))
+    {}
+
+    /// Returns a pointer to the @p func_name function using dynalo::get_function
+    template <typename FunctionSignature>
+    FunctionSignature* get_function(const std::string& func_name)
+    {
+        return dynalo::get_function<FunctionSignature>(m_handle, func_name);
+    }
+
+    /// Returns the native handle of the loaded shared library
+    native::handle get_native_handle()
+    {
+        return m_handle;
+    }
+};
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/dynalo/symbol_helper.hpp

@@ -0,0 +1,72 @@
+
+// This header can be included multiple times
+// It should come in handy for switching betwee, exporting and importing symbols
+//
+// USAGE
+//
+//  DYNALO_EXPORT <return type> DYNALO_CALL <function name>(<function argument types...>)
+//
+// EXAMPLE
+//
+//  EXPORTING FUNCTIONS
+//
+//      #define DYNALO_EXPORT_SYMBOLS
+//      #include <dynalo/symbol_helper.hpp>
+//
+//      DYNALO_EXPORT int32_t DYNALO_CALL add_integers(const int32_t a, const int32_t b);
+//      DYNALO_EXPORT void DYNALO_CALL print_message(const char* message);
+//
+//  IMPORTING FUNCTIONS
+//
+//      #define DYNALO_IMPORT_SYMBOLS
+//      #include <dynalo/symbol_helper.hpp>
+//
+//      DYNALO_EXPORT int32_t DYNALO_CALL add_integers(const int32_t a, const int32_t b);
+//      DYNALO_EXPORT void DYNALO_CALL print_message(const char* message);
+//
+
+#if !defined(DYNALO_DEMANGLE)
+    #if defined(__cplusplus)
+        #define DYNALO_DEMANGLE extern "C"
+    #else
+        #define DYNALO_DEMANGLE
+    #endif
+#endif
+
+#if defined(DYNALO_EXPORT_SYMBOLS)
+    #undef DYNALO_EXPORT_SYMBOLS
+
+    #if defined(DYNALO_EXPORT)
+        #undef DYNALO_EXPORT
+    #endif
+
+    #ifdef WIN32
+        #define DYNALO_EXPORT DYNALO_DEMANGLE __declspec(dllexport)
+    #else
+        #define DYNALO_EXPORT DYNALO_DEMANGLE
+    #endif
+
+#elif defined(DYNALO_IMPORT_SYMBOLS)
+    #undef DYNALO_IMPORT_SYMBOLS
+
+    #if defined(DYNALO_EXPORT)
+        #undef DYNALO_EXPORT
+    #endif
+
+    #ifdef WIN32
+        #define DYNALO_EXPORT DYNALO_DEMANGLE __declspec(dllimport)
+    #else
+        #define DYNALO_EXPORT DYNALO_DEMANGLE extern
+    #endif
+
+#else
+    #error "dynalo/symbol_helper.hpp Define either DYNALO_EXPORT_SYMBOLS or DYNALO_IMPORT_SYMBOLS"
+#endif
+
+#if !defined(DYNALO_CALL)
+    #ifdef _MSC_VER
+        #define DYNALO_CALL __cdecl
+    #else
+        #define DYNALO_CALL
+    #endif
+#endif

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/compat/glutbitmap.h

@@ -0,0 +1,92 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/gl/glplatform.h>
+#include <pangolin/gl/glfont.h>
+
+#ifdef HAVE_GLES
+GLfloat g_raster_pos[4];
+
+inline void glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
+{
+    // find object point (x,y,z)' in pixel coords
+    GLdouble projection[16];
+    GLdouble modelview[16];
+    GLint    view[4];
+    
+#ifdef HAVE_GLES_2
+    std::copy(pangolin::glEngine().projection.top().m, pangolin::glEngine().projection.top().m+16, projection);
+    std::copy(pangolin::glEngine().modelview.top().m, pangolin::glEngine().modelview.top().m+16, modelview);
+#else
+    glGetDoublev(GL_PROJECTION_MATRIX, projection );
+    glGetDoublev(GL_MODELVIEW_MATRIX, modelview );
+#endif
+    glGetIntegerv(GL_VIEWPORT, view );
+    
+    pangolin::glProject(x, y, z, modelview, projection, view,
+        g_raster_pos, g_raster_pos + 1, g_raster_pos + 2);
+}
+
+inline void glRasterPos2f(GLfloat x, GLfloat y)
+{
+    glRasterPos3f(x,y,1.0f);
+}
+
+inline void glRasterPos2i(GLint x, GLint y)
+{
+    glRasterPos3f((GLfloat)x, (GLfloat)y, 1.0f );
+}
+
+inline void glRasterPos3fv(const GLfloat *v){
+    glRasterPos3f(v[0],v[1],v[2]);
+}
+
+inline void glRasterPos2fv(const GLfloat *v){
+    glRasterPos3f(v[0],v[1],1.0f);
+}
+#endif // HAVE_GLES
+
+inline void glutBitmapString(void * /*font*/, const unsigned char *str)
+{
+#ifndef HAVE_GLES
+    float g_raster_pos[4];
+    glGetFloatv(GL_CURRENT_RASTER_POSITION, g_raster_pos);
+#endif
+    
+    pangolin::GlFont::I().Text( (const char *)str ).DrawWindow(
+        g_raster_pos[0], g_raster_pos[1], g_raster_pos[2]
+    );
+}
+
+inline int glutBitmapLength(void * /*font*/, const unsigned char *str)
+{
+    return (int)(pangolin::GlFont::I().Text((const char *)str).Width());
+}
+
+#define GLUT_BITMAP_HELVETICA_12 0;

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/compat/type_traits.h

@@ -0,0 +1,49 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/platform.h>
+
+#include <typeinfo>
+
+#include <type_traits>
+
+// enable_if From Boost
+namespace pangolin
+{
+    template <bool B, class T = void>
+    struct enable_if_c {
+      typedef T type;
+    };
+
+    template <class T>
+    struct enable_if_c<false, T> {};
+
+    template <class Cond, class T = void>
+    struct enable_if : public enable_if_c<Cond::value, T> {};
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/factory/factory.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <memory>
+#include <map>
+#include <pangolin/utils/param_set.h>
+
+namespace pangolin
+{
+
+class FactoryInterface {
+public:
+    using Name = std::string;
+    using Precedence = int32_t;
+
+    virtual ~FactoryInterface(){};
+
+    virtual std::map<Name,Precedence> Schemes() const = 0;
+
+    virtual const char* Description() const = 0;
+
+    virtual ParamSet Params() const = 0;
+};
+
+template<typename T>
+class TypedFactoryInterface : public FactoryInterface
+{
+public:
+    virtual std::unique_ptr<T> Open(const Uri& uri) = 0;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/factory/factory_help.h

@@ -0,0 +1,31 @@
+#include <iostream>
+
+#include <pangolin/factory/factory_registry.h>
+
+namespace pangolin {
+
+/// The level of detail to use when printing
+enum HelpVerbosity{
+    SUMMARY = 0, // Short description
+    SYNOPSIS,    // + examples, aliases
+    PARAMS       // + list all arguments
+};
+
+/// Print to \p out general guidance on how to use Pangolin factory URL's
+/// \p out the stream to stream the help message to
+/// \p color whether ANSI Color codes should be used for formatting
+void PrintSchemeHelp(std::ostream& out = std::cout, bool color = true);
+
+/// Print to \p out Factories registered to \p registry that match \p scheme_filter.
+/// \p out the stream to stream the help message to
+/// \p registry the registy to use
+/// \p factory_type the typeid(T) of the FactoryInterface T to list
+/// \p scheme_filter a constraint on schemes to print, or empty if all should be listed
+/// \p level the level of detail to use when printing (see enum above)
+/// \p color whether ANSI Color codes should be used for formatting
+void PrintFactoryRegistryDetails(
+    std::ostream& out, const pangolin::FactoryRegistry& registry, std::type_index factory_type,
+    const std::string& scheme_filter = "", HelpVerbosity level = HelpVerbosity::SYNOPSIS, bool color = true
+);
+
+} 

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/factory/factory_registry.h

@@ -0,0 +1,218 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011-2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <vector>
+#include <map>
+#include <unordered_set>
+#include <algorithm>
+#include <typeindex>
+#include <regex>
+#include <exception>
+
+#include <pangolin/factory/factory.h>
+
+namespace pangolin
+{
+
+/// Registry class for managing FactoryInterface instances.
+/// Use Factory instantiation to decouple implementation and use
+/// of interface types and easy configure construction through
+/// a URI-like syntax.
+class FactoryRegistry
+{
+public:
+    using TypeRegistry = std::vector<std::shared_ptr<FactoryInterface>>;
+
+    /// Singleton instance of FactoryRegistry
+    static std::shared_ptr<FactoryRegistry> I();
+
+    ~FactoryRegistry() {}
+
+    /// Register a new TypedFactoryInterface with the registry
+    template<typename T>
+    bool RegisterFactory( const std::shared_ptr<TypedFactoryInterface<T>>& factory )
+    {
+        TypeRegistry& registry = type_registries[typeid(T)];
+        registry.push_back(factory);
+        return true;
+    }
+
+    /// Unregister an existing factory.
+    /// Do nothing if factory isn't registered.
+    template<typename T>
+    void UnregisterFactory(TypedFactoryInterface<T>* factory)
+    {
+        TypeRegistry& registry = type_registries[typeid(T)];
+
+        registry.erase(
+           std::remove_if( registry.begin(), registry.end(),
+              [&](auto& i){ return i.factory.get() == factory;}),
+           registry.end());
+    }
+
+    /// Remove all Factories from all types
+    void UnregisterAllFactories()
+    {
+        type_registries.clear();
+    }
+
+    /// Attempt to Construct an instance of \tparam T using the highest precedence
+    /// \class FactoryInterface which acceps \param uri
+    /// \throws FactoryRegistry::Exception
+    template<typename T>
+    std::unique_ptr<T> Construct(const Uri& uri)
+    {
+        TypeRegistry& registry = type_registries[typeid(T)];
+
+        TypeRegistry candidates;
+        std::copy_if(registry.begin(), registry.end(), std::back_inserter(candidates), [&](auto& factory){
+            const auto schemes = factory->Schemes();
+            return schemes.find(uri.scheme) != schemes.end();
+        });
+
+        if(candidates.size() == 0) {
+            throw NoMatchingSchemeException( uri);
+        }
+
+        // Order candidates by precedence.
+        std::sort(candidates.begin(), candidates.end(), [&](auto& lhs, auto& rhs){
+            // We know that all candidates contain scheme
+            return lhs->Schemes()[uri.scheme] < rhs->Schemes()[uri.scheme];
+        });
+
+        // Try candidates in order
+        for(auto& factory : candidates) {
+            std::unordered_set<std::string> orphan_params = ParamReader( factory->Params(), uri ).FindUnrecognizedUriParams();
+            if( orphan_params.size() == 0 )
+            {
+                TypedFactoryInterface<T>* factoryT = dynamic_cast<TypedFactoryInterface<T>*>(factory.get());
+                if(factoryT) {
+                    std::unique_ptr<T> video = factoryT->Open(uri);
+                    if(video) return video;
+                }
+            }else{
+                throw ParameterMismatchException(uri, orphan_params);
+            }
+        }
+
+        throw NoFactorySucceededException(uri);
+    }
+
+    const TypeRegistry& GetFactories(std::type_index type) const
+    {
+        const auto& ifac = type_registries.find(type);
+        if(ifac != type_registries.end()) {
+            return ifac->second;
+        }else{
+            throw std::runtime_error("No factories for this type.");
+        }
+    }
+
+    template<typename T>
+    const TypeRegistry& GetFactories() const {
+        return GetFactories(typeid(T));
+    }
+
+    /// Base class for FactoryRegistry Exceptions
+    class Exception : public std::exception {
+    public:
+        Exception(const Uri& uri) : uri(uri) {
+            err = "Unable to open URI";
+            err += "\n  full_uri: " + uri.full_uri;
+            err += "\n  scheme: " + uri.scheme;
+            err += "\n  params:\n";
+            for(const auto& p : uri.params) {
+                err += "    " + p.first + " = " + p.second + "\n";
+            }
+        }
+        virtual const char* what() const throw() override {
+            return err.c_str();
+        }
+        const Uri uri;
+        std::string err;
+    };
+
+    class NoMatchingSchemeException : public Exception {
+    public:
+        NoMatchingSchemeException(const Uri& uri) : Exception(uri) {
+            err += " No matching scheme.";
+        }
+    };
+
+    class NoFactorySucceededException : public Exception {
+    public:
+        NoFactorySucceededException(const Uri& uri) : Exception(uri) {
+            err += " No factory succeeded.";
+        }
+    };
+
+    class ParameterMismatchException : public Exception {
+    public:
+        ParameterMismatchException(const Uri& uri, const std::unordered_set<std::string>& unrecognized_params) :
+            Exception(uri), unrecognized_params(unrecognized_params) {
+            std::stringstream ss;
+            for(const auto& p : unrecognized_params ) ss << p << ",";
+            err += " Unrecognized options for scheme (" + ss.str() + ")";
+        }
+        const std::unordered_set<std::string> unrecognized_params;
+    };
+
+private:
+    std::map<std::type_index, TypeRegistry> type_registries;
+};
+
+/// Macro to define factory entry point. Add a corresponding line in your cmake:
+///    `PangolinRegisterFactory(MyInterfaceType MyFactoryType)`
+/// in order to have the method added to an initialization method for MyInterfaceType
+///
+/// \tparam x is the factory interface class (such as WindowInterface, VideoInterface, etc)
+/// \return true iff registration was successful.
+#define PANGOLIN_REGISTER_FACTORY(x) \
+    bool Register ## x ## Factory()
+//  {
+//    return FactoryRegistry::I()->RegisterFactory<x>(std::make_shared<MyFactoryClass>());
+//  }
+
+/// Macro to define factory entry point with automatic static initialization.
+/// Use this instead of the macro above to automatically register a factory when the compilation
+/// unit is loaded, and you can guarentee the symbols will remain.
+/// e.g. within a dynamic library which you will explicitly load, or within the same
+/// compilation unit as your main().
+///
+/// \tparam x is the factory interface class (such as WindowInterface, VideoInterface, etc)
+/// \return true iff registration was successful.
+// Forward declaration; static load variable; definition
+#define PANGOLIN_REGISTER_FACTORY_WITH_STATIC_INITIALIZER(x) \
+    bool Register ## x ## Factory(); \
+    static const bool Load ## x ## Success = Register ## x ## Factory(); \
+    bool Register ## x ## Factory()
+//  {
+//    return FactoryRegistry::I()->RegisterFactory<x>(std::make_shared<MyFactoryClass>());
+//  }
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/pangolin.h

@@ -0,0 +1,59 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+// This header is here for compatibility when building
+// all of Pangolin. You are recommended to include only
+// what you need, especially when building without a
+// particular feature, such as GUI for Video, otherwise
+// you'll receive errors.
+
+#include <pangolin/platform.h>
+
+#include <pangolin/display/display.h>
+#include <pangolin/display/view.h>
+#include <pangolin/display/widgets.h>
+#include <pangolin/gl/colour.h>
+#include <pangolin/gl/gl.h>
+#include <pangolin/gl/gldraw.h>
+#include <pangolin/gl/glstate.h>
+#include <pangolin/gl/glvbo.h>
+#include <pangolin/handler/handler.h>
+#include <pangolin/image/image_io.h>
+#include <pangolin/plot/plotter.h>
+#include <pangolin/var/varextra.h>
+#include <pangolin/video/video.h>
+#include <pangolin/video/video_input.h>
+#include <pangolin/video/video_output.h>
+
+#ifdef _ANDROID_
+#  include <pangolin/display/device/display_android.h>
+#endif
+
+// Let other libraries headers know about Pangolin
+#define HAVE_PANGOLIN

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/platform.h

@@ -0,0 +1,66 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+// Include portable printf-style format macros
+#define __STDC_FORMAT_MACROS
+
+#define PANGOLIN_UNUSED(x) (void)(x)
+
+#ifdef __GNUC__
+#  define PANGOLIN_DEPRECATED(x) __attribute__((deprecated(x)))
+#elif defined(_MSC_VER)
+#  define PANGOLIN_DEPRECATED(x) __declspec(deprecated(x))
+#else
+#  define PANGOLIN_DEPRECATED(x)
+#endif
+
+#ifdef _MSC_VER
+#   define __thread __declspec(thread)
+#   include <pangolin/pangolin_export.h>
+#else
+#   define PANGOLIN_EXPORT
+#endif //_MSVC_
+
+// HOST / DEVICE Annotations
+#ifdef __CUDACC__
+#  include <cuda_runtime.h>
+#  define PANGO_HOST_DEVICE __host__ __device__
+#else
+#  define PANGO_HOST_DEVICE
+#endif
+
+// Workaround for Apple-Clangs lack of thread_local support
+#if defined(__clang__)
+#  if !__has_feature(cxx_thread_local)
+#    define PANGO_NO_THREADLOCAL
+#  endif
+#endif
+
+#include <pangolin/utils/assert.h>
+#include <pangolin/utils/log.h>

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/argagg.hpp

@@ -0,0 +1,1548 @@
+/*
+ * @file
+ * @brief
+ * Defines a very simple command line argument parser.
+ *
+ * @copyright
+ * Copyright (c) 2017 Viet The Nguyen
+ *
+ * @copyright
+ * 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:
+ *
+ * @copyright
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * @copyright
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+#pragma once
+#ifndef ARGAGG_ARGAGG_ARGAGG_HPP
+#define ARGAGG_ARGAGG_ARGAGG_HPP
+
+#ifdef __unix__
+#include <stdio.h>
+#include <unistd.h>
+#endif // #ifdef __unix__
+
+#include <algorithm>
+#include <array>
+#include <cstdlib>
+#include <cstring>
+#include <cctype>
+#include <iterator>
+#include <ostream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+
+/**
+ * @brief
+ * There are only two hard things in Computer Science: cache invalidation and
+ * naming things (Phil Karlton).
+ *
+ * The names of types have to be succint and clear. This has turned out to be a
+ * more difficult thing than I expected. Here you'll find a quick overview of
+ * the type names you'll find in this namespace (and thus "library").
+ *
+ * When a program is invoked it is passed a number of "command line arguments".
+ * Each of these "arguments" is a string (C-string to be more precise). An
+ * "option" is a command line argument that has special meaning. This library
+ * recognizes a command line argument as a potential option if it starts with a
+ * dash ('-') or double-dash ('--').
+ *
+ * A "parser" is a set of "definitions" (not a literal std::set but rather a
+ * std::vector). A parser is represented by the argagg::parser struct.
+ *
+ * A "definition" is a structure with four components that define what
+ * "options" are recognized. The four components are the name of the option,
+ * the strings that represent the option, the option's help text, and how many
+ * arguments the option should expect. "Flags" are the individual strings that
+ * represent the option ("-v" and "--verbose" are flags for the "verbose"
+ * option). A definition is represented by the argagg::definition struct.
+ *
+ * Note at this point that the word "option" can be used interchangeably to
+ * mean the notion of an option and the actual instance of an option given a
+ * set of command line arguments. To be unambiguous we use a "definition" to
+ * represent the notion of an option and an "option result" to represent an
+ * actual option parsed from a set of command line arguments. An "option
+ * result" is represented by the argagg::option_result struct.
+ *
+ * There's one more wrinkle to this: an option can show up multiple times in a
+ * given set of command line arguments. For example, "-n 1 -n 2 -n 3". This
+ * will parse into three distinct argagg::option_result instances, but all of
+ * them correspond to the same argagg::definition. We aggregate these into the
+ * argagg::option_results struct which represents "all parser results for a
+ * given option definition". This argagg::option_results is basically a
+ * std::vector of argagg::option_result.
+ *
+ * Options aren't the only thing parsed though. Positional arguments are also
+ * parsed. Thus a parser produces a result that contains both option results
+ * and positional arguments. The parser results are represented by the
+ * argagg::parser_results struct. All option results are stored in a mapping
+ * from option name to the argagg::option_results. All positional arguments are
+ * simply stored in a vector of C-strings.
+ */
+namespace argagg {
+
+
+/**
+ * @brief
+ * This exception is thrown when a long option is parsed and is given an
+ * argument using the "=" syntax but the option doesn't expect an argument.
+ */
+struct unexpected_argument_error
+: public std::runtime_error {
+  using std::runtime_error::runtime_error;
+};
+
+
+/**
+ * @brief
+ * This exception is thrown when an option is parsed unexpectedly such as when
+ * an argument was expected for a previous option or if an option was found
+ * that has not been defined.
+ */
+struct unexpected_option_error
+: public std::runtime_error {
+  using std::runtime_error::runtime_error;
+};
+
+
+/**
+ * @brief
+ * This exception is thrown when an option requires an argument but is not
+ * provided one. This can happen if another flag was found after the option or
+ * if we simply reach the end of the command line arguments.
+ */
+struct option_lacks_argument_error
+: public std::runtime_error {
+  using std::runtime_error::runtime_error;
+};
+
+
+/**
+ * @brief
+ * This exception is thrown when an option's flag is invalid. This can be the
+ * case if the flag is not prefixed by one or two hyphens or contains non
+ * alpha-numeric characters after the hypens. See is_valid_flag_definition()
+ * for more details.
+ */
+struct invalid_flag
+: public std::runtime_error {
+  using std::runtime_error::runtime_error;
+};
+
+
+/**
+ * @brief
+ * The set of template instantiations that convert C-strings to other types for
+ * the option_result::as(), option_results::as(), parser_results::as(), and
+ * parser_results::all_as() methods are placed in this namespace.
+ */
+namespace convert {
+
+  /**
+   * @brief
+   * Explicit instantiations of this function are used to convert arguments to
+   * types.
+   */
+  template <typename T>
+  T arg(const char* arg);
+
+}
+
+
+/**
+ * @brief
+ * Represents a single option parse result.
+ *
+ * You can check if this has an argument by using the implicit boolean
+ * conversion.
+ */
+struct option_result {
+
+  /**
+   * @brief
+   * Argument parsed for this single option. If no argument was parsed this
+   * will be set to nullptr.
+   */
+  const char* arg;
+
+  /**
+   * @brief
+   * Converts the argument parsed for this single option instance into the
+   * given type using the type matched conversion function
+   * argagg::convert::arg(). If there was not an argument parsed for this
+   * single option instance then a argagg::option_lacks_argument_error
+   * exception is thrown. The specific conversion function may throw other
+   * exceptions.
+   */
+  template <typename T>
+  T as() const;
+
+  /**
+   * @brief
+   * Converts the argument parsed for this single option instance into the
+   * given type using the type matched conversion function
+   * argagg::convert::arg(). If there was not an argument parsed for this
+   * single option instance then the provided default value is returned
+   * instead. If the conversion function throws an exception then it is ignored
+   * and the default value is returned.
+   */
+  template <typename T>
+  T as(const T& t) const;
+
+  /**
+   * @brief
+   * Since we have the argagg::option_result::as() API we might as well alias
+   * it as an implicit conversion operator. This performs implicit conversion
+   * using the argagg::option_result::as() method.
+   *
+   * @note
+   * An implicit boolean conversion specialization exists which returns false
+   * if there is no argument for this single option instance and true
+   * otherwise. This specialization DOES NOT convert the argument to a bool. If
+   * you need to convert the argument to a bool then use the as() API.
+   */
+  template <typename T>
+  operator T () const;
+
+};
+
+
+/**
+ * @brief
+ * Represents multiple option parse results for a single option. If treated as
+ * a single parse result it defaults to the last parse result. Note that an
+ * instance of this struct is always created even if no option results are
+ * parsed for a given definition. In that case it will simply be empty.
+ *
+ * To check if the associated option showed up at all simply use the implicit
+ * boolean conversion or check if count() is greater than zero.
+ */
+struct option_results {
+
+  /**
+   * @brief
+   * All option parse results for this option.
+   */
+  std::vector<option_result> all;
+
+  /**
+   * @brief
+   * Gets the number of times the option shows up.
+   */
+  std::size_t count() const;
+
+  /**
+   * @brief
+   * Gets a single option parse result by index.
+   */
+  option_result& operator [] (std::size_t index);
+
+  /**
+   * @brief
+   * Gets a single option result by index.
+   */
+  const option_result& operator [] (std::size_t index) const;
+
+  /**
+   * @brief
+   * Converts the argument parsed for the LAST option parse result for the
+   * parent definition to the provided type. For example, if this was for "-f 1
+   * -f 2 -f 3" then calling this method for an integer type will return 3. If
+   * there are no option parse results then a std::out_of_range exception is
+   * thrown. Any exceptions thrown by option_result::as() are not
+   * handled.
+   */
+  template <typename T>
+  T as() const;
+
+  /**
+   * @brief
+   * Converts the argument parsed for the LAST option parse result for the
+   * parent definition to the provided type. For example, if this was for "-f 1
+   * -f 2 -f 3" then calling this method for an integer type will return 3. If
+   * there are no option parse results then the provided default value is
+   * returned instead.
+   */
+  template <typename T>
+  T as(const T& t) const;
+
+  /**
+   * @brief
+   * Since we have the option_results::as() API we might as well alias
+   * it as an implicit conversion operator. This performs implicit conversion
+   * using the option_results::as() method.
+   *
+   * @note
+   * An implicit boolean conversion specialization exists which returns false
+   * if there is no argument for this single option instance and true
+   * otherwise. This specialization DOES NOT convert the argument to a bool. If
+   * you need to convert the argument to a bool then use the as() API.
+   */
+  template <typename T>
+  operator T () const;
+
+};
+
+
+/**
+ * @brief
+ * Represents all results of the parser including options and positional
+ * arguments.
+ */
+struct parser_results {
+
+  /**
+   * @brief
+   * Returns the name of the program from the original arguments list. This is
+   * always the first argument.
+   */
+  const char* program;
+
+  /**
+   * @brief
+   * Maps from definition name to the structure which contains the parser
+   * results for that definition.
+   */
+  std::unordered_map<std::string, option_results> options;
+
+  /**
+   * @brief
+   * Vector of positional arguments.
+   */
+  std::vector<const char*> pos;
+
+  /**
+   * @brief
+   * Used to check if an option was specified at all.
+   */
+  bool has_option(const std::string& name) const;
+
+  /**
+   * @brief
+   * Get the parser results for the given definition. If the definition never
+   * showed up then the exception from the unordered_map access will bubble
+   * through so check if the flag exists in the first place with has_option().
+   */
+  option_results& operator [] (const std::string& name);
+
+  /**
+   * @brief
+   * Get the parser results for the given definition. If the definition never
+   * showed up then the exception from the unordered_map access will bubble
+   * through so check if the flag exists in the first place with has_option().
+   */
+  const option_results& operator [] (const std::string& name) const;
+
+  /**
+   * @brief
+   * Gets the number of positional arguments.
+   */
+  std::size_t count() const;
+
+  /**
+   * @brief
+   * Gets a positional argument by index.
+   */
+  const char* operator [] (std::size_t index) const;
+
+  /**
+   * @brief
+   * Gets a positional argument converted to the given type.
+   */
+  template <typename T>
+  T as(std::size_t i = 0) const;
+
+  /**
+   * @brief
+   * Gets all positional arguments converted to the given type.
+   */
+  template <typename T>
+  std::vector<T> all_as() const;
+
+};
+
+
+/**
+ * @brief
+ * An option definition which essentially represents what an option is.
+ */
+struct definition {
+
+  /**
+   * @brief
+   * Name of the option. Option parser results are keyed by this name.
+   */
+  const std::string name;
+
+  /**
+   * @brief
+   * List of strings to match that correspond to this option. Should be fully
+   * specified with hyphens (e.g. "-v" or "--verbose").
+   */
+  std::vector<std::string> flags;
+
+  /**
+   * @brief
+   * Help string for this option.
+   */
+  std::string help;
+
+  /**
+   * @brief
+   * Number of arguments this option requires. Must be 0 or 1. All other values
+   * have undefined behavior. Okay, the code actually works with positive
+   * values in general, but it's unorthodox command line behavior.
+   */
+  unsigned int num_args;
+
+  /**
+   * @brief
+   * Returns true if this option does not want any arguments.
+   */
+  bool wants_no_arguments() const;
+
+  /**
+   * @brief
+   * Returns true if this option requires arguments.
+   */
+  bool requires_arguments() const;
+
+};
+
+
+/**
+ * @brief
+ * Checks whether or not a command line argument should be processed as an
+ * option flag. This is very similar to is_valid_flag_definition() but must
+ * allow for short flag groups (e.g. "-abc") and equal-assigned long flag
+ * arguments (e.g. "--output=foo.txt").
+ */
+bool cmd_line_arg_is_option_flag(
+  const char* s);
+
+
+/**
+ * @brief
+ * Checks whether a flag in an option definition is valid. I suggest reading
+ * through the function source to understand what dictates a valid.
+ */
+bool is_valid_flag_definition(
+  const char* s);
+
+
+/**
+ * @brief
+ * Tests whether or not a valid flag is short. Assumes the provided cstring is
+ * already a valid flag.
+ */
+bool flag_is_short(
+  const char* s);
+
+
+/**
+ * @brief
+ * Contains two maps which aid in option parsing. The first map, @ref
+ * short_map, maps from a short flag (just a character) to a pointer to the
+ * original @ref definition that the flag represents. The second map, @ref
+ * long_map, maps from a long flag (an std::string) to a pointer to the
+ * original @ref definition that the flag represents.
+ *
+ * This object is usually a temporary that only exists during the parsing
+ * operation. It is typically constructed using @ref validate_definitions().
+ */
+struct parser_map {
+
+  /**
+   * @brief
+   * Maps from a short flag (just a character) to a pointer to the original
+   * @ref definition that the flag represents.
+   */
+  std::array<const definition*, 256> short_map;
+
+  /**
+   * @brief
+   * Maps from a long flag (an std::string) to a pointer to the original @ref
+   * definition that the flag represents.
+   */
+  std::unordered_map<std::string, const definition*> long_map;
+
+  /**
+   * @brief
+   * Returns true if the provided short flag exists in the map object.
+   */
+  bool known_short_flag(
+    const char flag) const;
+
+  /**
+   * @brief
+   * If the short flag exists in the map object then it is returned by this
+   * method. If it doesn't then nullptr will be returned.
+   */
+  const definition* get_definition_for_short_flag(
+    const char flag) const;
+
+  /**
+   * @brief
+   * Returns true if the provided long flag exists in the map object.
+   */
+  bool known_long_flag(
+    const std::string& flag) const;
+
+  /**
+   * @brief
+   * If the long flag exists in the map object then it is returned by this
+   * method. If it doesn't then nullptr will be returned.
+   */
+  const definition* get_definition_for_long_flag(
+    const std::string& flag) const;
+
+};
+
+
+/**
+ * @brief
+ * Validates a collection (specifically an std::vector) of @ref definition
+ * objects by checking if the contained flags are valid. If the set of @ref
+ * definition objects is not valid then an exception is thrown. Upon successful
+ * validation a @ref parser_map object is returned.
+ */
+parser_map validate_definitions(
+  const std::vector<definition>& definitions);
+
+
+/**
+ * @brief
+ * A list of option definitions used to inform how to parse arguments.
+ */
+struct parser {
+
+  /**
+   * @brief
+   * Vector of the option definitions which inform this parser how to parse
+   * the command line arguments.
+   */
+  std::vector<definition> definitions;
+
+  /**
+   * @brief
+   * Parses the provided command line arguments and returns the results as
+   * @ref parser_results.
+   *
+   * @note
+   * This method is not thread-safe and assumes that no modifications are made
+   * to the definitions member field during the extent of this method call.
+   */
+  parser_results parse(int argc, const char** argv) const;
+
+  /**
+   * @brief
+   * Through strict interpretation of pointer casting rules, despite this being
+   * a safe operation, C++ doesn't allow implicit casts from <tt>char**</tt> to
+   * <tt>const char**</tt> so here's an overload that performs a const_cast,
+   * which is typically frowned upon but is safe here.
+   */
+  parser_results parse(int argc, char** argv) const;
+
+};
+
+
+/**
+ * @brief
+ * A convenience output stream that will accumulate what is streamed to it and
+ * then, on destruction, format the accumulated string using the fmt program
+ * (via the argagg::fmt_string() function) to the provided std::ostream.
+ *
+ * Example use:
+ *
+ * @code
+ * {
+ *   argagg::fmt_ostream f(std::cerr);
+ *   f << "Usage: " << really_long_string << std::endl;
+ * } // on destruction here the formatted string will be streamed to std::cerr
+ * @endcode
+ *
+ * @note
+ * This only has formatting behavior if the <tt>__unix__</tt> preprocessor
+ * definition is defined since formatting relies on the POSIX API for forking,
+ * executing a process, and reading/writing to/from file descriptors. If that
+ * preprocessor definition is not defined then this class has the same overall
+ * behavior except the output string is not formatted (basically streams
+ * whatever the accumulated string is). See arggg::fmt_string().
+ */
+struct fmt_ostream : public std::ostringstream {
+
+  /**
+   * @brief
+   * Reference to the final output stream that the formatted string will be
+   * streamed to.
+   */
+  std::ostream& output;
+
+  /**
+   * @brief
+   * Construct to output to the provided output stream when this object is
+   * destroyed.
+   */
+  fmt_ostream(std::ostream& output);
+
+  /**
+   * @brief
+   * Special destructor that will format the accumulated string using fmt (via
+   * the argagg::fmt_string() function) and stream it to the std::ostream
+   * stored.
+   */
+  ~fmt_ostream();
+
+};
+
+
+/**
+ * @brief
+ * Processes the provided string using the fmt util and returns the resulting
+ * output as a string. Not the most efficient (in time or space) but gets the
+ * job done.
+ *
+ * This function is cowardly so if there are any errors encountered such as a
+ * syscall returning -1 then the input string is returned.
+ *
+ * @note
+ * This only has formatting behavior if the <tt>__unix__</tt> preprocessor
+ * definition is defined since it relies on the POSIX API for forking,
+ * executing a process, reading/writing to/from file descriptors, and the
+ * existence of the fmt util.
+ */
+std::string fmt_string(const std::string& s);
+
+
+} // namespace argagg
+
+
+/**
+ * @brief
+ * Writes the option help to the given stream.
+ */
+std::ostream& operator << (std::ostream& os, const argagg::parser& x);
+
+
+// ---- end of declarations, header-only implementations follow ----
+
+
+namespace argagg {
+
+
+template <typename T>
+T option_result::as() const
+{
+  if (this->arg) {
+    return convert::arg<T>(this->arg);
+  } else {
+    throw option_lacks_argument_error("option has no argument");
+  }
+}
+
+
+template <typename T>
+T option_result::as(const T& t) const
+{
+  if (this->arg) {
+    try {
+      return convert::arg<T>(this->arg);
+    } catch (...) {
+      return t;
+    }
+  } else {
+    // I actually think this will never happen. To call this method you have
+    // to access a specific option_result for an option. If there's a
+    // specific option_result then the option was found. If the option
+    // requires an argument then it will definitely have an argument
+    // otherwise the parser would have complained.
+    return t;
+  }
+}
+
+
+template <typename T>
+option_result::operator T () const
+{
+  return this->as<T>();
+}
+
+
+template <> inline
+option_result::operator bool () const
+{
+  return this->arg != nullptr;
+}
+
+
+inline
+std::size_t option_results::count() const
+{
+  return this->all.size();
+}
+
+
+inline
+option_result& option_results::operator [] (std::size_t index)
+{
+  return this->all[index];
+}
+
+
+inline
+const option_result& option_results::operator [] (std::size_t index) const
+{
+  return this->all[index];
+}
+
+
+template <typename T>
+T option_results::as() const
+{
+  if (this->all.size() == 0) {
+    throw std::out_of_range("no option arguments to convert");
+  }
+  return this->all.back().as<T>();
+}
+
+
+template <typename T>
+T option_results::as(const T& t) const
+{
+  if (this->all.size() == 0) {
+    return t;
+  }
+  return this->all.back().as<T>(t);
+}
+
+
+template <typename T>
+option_results::operator T () const
+{
+  return this->as<T>();
+}
+
+
+template <> inline
+option_results::operator bool () const
+{
+  return this->all.size() > 0;
+}
+
+
+inline
+bool parser_results::has_option(const std::string& name) const
+{
+  const auto it = this->options.find(name);
+  return ( it != this->options.end()) && it->second.all.size() > 0;
+}
+
+
+inline
+option_results& parser_results::operator [] (const std::string& name)
+{
+  return this->options.at(name);
+}
+
+
+inline
+const option_results&
+parser_results::operator [] (const std::string& name) const
+{
+  return this->options.at(name);
+}
+
+
+inline
+std::size_t parser_results::count() const
+{
+  return this->pos.size();
+}
+
+
+inline
+const char* parser_results::operator [] (std::size_t index) const
+{
+  return this->pos[index];
+}
+
+
+template <typename T>
+T parser_results::as(std::size_t i) const
+{
+  return convert::arg<T>(this->pos[i]);
+}
+
+
+template <typename T>
+std::vector<T> parser_results::all_as() const
+{
+  std::vector<T> v(this->pos.size());
+  std::transform(
+    this->pos.begin(), this->pos.end(), v.begin(),
+    [](const char* arg) {
+      return convert::arg<T>(arg);
+    });
+  return v;
+}
+
+
+inline
+bool definition::wants_no_arguments() const
+{
+  return this->num_args == 0;
+}
+
+
+inline
+bool definition::requires_arguments() const
+{
+  return this->num_args > 0;
+}
+
+
+inline
+bool cmd_line_arg_is_option_flag(
+  const char* s)
+{
+  auto len = std::strlen(s);
+
+  // The shortest possible flag has two characters: a hyphen and an
+  // alpha-numeric character.
+  if (len < 2) {
+    return false;
+  }
+
+  // All flags must start with a hyphen.
+  if (s[0] != '-') {
+    return false;
+  }
+
+  // Shift the name forward by a character to account for the initial hyphen.
+  // This means if s was originally "-v" then name will be "v".
+  const char* name = s + 1;
+
+  // Check if we're dealing with a long flag.
+  bool is_long = false;
+  if (s[1] == '-') {
+    is_long = true;
+
+    // Just -- is not a valid flag.
+    if (len == 2) {
+      return false;
+    }
+
+    // Shift the name forward to account for the extra hyphen. This means if s
+    // was originally "--output" then name will be "output".
+    name = s + 2;
+  }
+
+  // The first character of the flag name must be alpha-numeric. This is to
+  // prevent things like "---a" from being valid flags.
+  len = std::strlen(name);
+  if (!std::isalnum(name[0])) {
+    return false;
+  }
+
+  // At this point in is_valid_flag_definition() we would check if the short
+  // flag has only one character. At command line specification you can group
+  // short flags together or even add an argument to a short flag without a
+  // space delimiter. Thus we don't check if this has only one character
+  // because it might not.
+
+  // If this is a long flag then we expect all characters *up to* an equal sign
+  // to be alpha-numeric or a hyphen. After the equal sign you are specify the
+  // argument to a long flag which can be basically anything.
+  if (is_long) {
+    bool encountered_equal = false;
+    return std::all_of(name, name + len, [&](const char& c) {
+        if (encountered_equal) {
+          return true;
+        } else {
+          if (c == '=') {
+            encountered_equal = true;
+            return true;
+          }
+          return std::isalnum(c) || c == '-';
+        }
+      });
+  }
+
+  // At this point we are not dealing with a long flag. We already checked that
+  // the first character is alpha-numeric so we've got the case of a single
+  // short flag covered. This might be a short flag group though and we might
+  // be tempted to check that each character of the short flag group is
+  // alpha-numeric. However, you can specify the argument for a short flag
+  // without a space delimiter (e.g. "-I/usr/local/include") so you can't tell
+  // if the rest of a short flag group is part of the argument or not unless
+  // you know what is a defined flag or not. We leave that kind of processing
+  // to the parser.
+  return true;
+}
+
+
+inline
+bool is_valid_flag_definition(
+  const char* s)
+{
+  auto len = std::strlen(s);
+
+  // The shortest possible flag has two characters: a hyphen and an
+  // alpha-numeric character.
+  if (len < 2) {
+    return false;
+  }
+
+  // All flags must start with a hyphen.
+  if (s[0] != '-') {
+    return false;
+  }
+
+  // Shift the name forward by a character to account for the initial hyphen.
+  // This means if s was originally "-v" then name will be "v".
+  const char* name = s + 1;
+
+  // Check if we're dealing with a long flag.
+  bool is_long = false;
+  if (s[1] == '-') {
+    is_long = true;
+
+    // Just -- is not a valid flag.
+    if (len == 2) {
+      return false;
+    }
+
+    // Shift the name forward to account for the extra hyphen. This means if s
+    // was originally "--output" then name will be "output".
+    name = s + 2;
+  }
+
+  // The first character of the flag name must be alpha-numeric. This is to
+  // prevent things like "---a" from being valid flags.
+  len = std::strlen(name);
+  if (!std::isalnum(name[0])) {
+    return false;
+  }
+
+  // If this is a short flag then it must only have one character.
+  if (!is_long && len > 1) {
+    return false;
+  }
+
+  // The rest of the characters must be alpha-numeric, but long flags are
+  // allowed to have hyphens too.
+  return std::all_of(name + 1, name + len, [&](const char& c) {
+      return std::isalnum(c) || (c == '-' && is_long);
+    });
+}
+
+
+inline
+bool flag_is_short(
+  const char* s)
+{
+  return s[0] == '-' && std::isalnum(s[1]);
+}
+
+
+inline
+bool parser_map::known_short_flag(
+  const char flag) const
+{
+  return this->short_map[flag] != nullptr;
+}
+
+
+inline
+const definition* parser_map::get_definition_for_short_flag(
+  const char flag) const
+{
+  return this->short_map[flag];
+}
+
+
+inline
+bool parser_map::known_long_flag(
+  const std::string& flag) const
+{
+  const auto existing_long_flag = this->long_map.find(flag);
+  return existing_long_flag != long_map.end();
+}
+
+
+inline
+const definition* parser_map::get_definition_for_long_flag(
+  const std::string& flag) const
+{
+  const auto existing_long_flag = this->long_map.find(flag);
+  if (existing_long_flag == long_map.end()) {
+    return nullptr;
+  }
+  return existing_long_flag->second;
+}
+
+
+inline
+parser_map validate_definitions(
+  const std::vector<definition>& definitions)
+{
+  std::unordered_map<std::string, const definition*> long_map;
+  parser_map map {{{nullptr}}, std::move(long_map)};
+
+  for (auto& defn : definitions) {
+
+    if (defn.flags.size() == 0) {
+      std::ostringstream msg;
+      msg << "option \"" << defn.name << "\" has no flag definitions";
+      throw invalid_flag(msg.str());
+    }
+
+    for (auto& flag : defn.flags) {
+
+      if (!is_valid_flag_definition(flag.data())) {
+        std::ostringstream msg;
+        msg << "flag \"" << flag << "\" specified for option \"" << defn.name
+            << "\" is invalid";
+        throw invalid_flag(msg.str());
+      }
+
+      if (flag_is_short(flag.data())) {
+        const int short_flag_letter = flag[1];
+        const auto existing_short_flag = map.short_map[short_flag_letter];
+        bool short_flag_already_exists = (existing_short_flag != nullptr);
+        if (short_flag_already_exists) {
+          std::ostringstream msg;
+          msg << "duplicate short flag \"" << flag
+              << "\" found, specified by both option  \"" << defn.name
+              << "\" and option \"" << existing_short_flag->name;
+          throw invalid_flag(msg.str());
+        }
+        map.short_map[short_flag_letter] = &defn;
+        continue;
+      }
+
+      // If we're here then this is a valid, long-style flag.
+      if (map.known_long_flag(flag)) {
+        const auto existing_long_flag = map.get_definition_for_long_flag(flag);
+        std::ostringstream msg;
+        msg << "duplicate long flag \"" << flag
+            << "\" found, specified by both option  \"" << defn.name
+            << "\" and option \"" << existing_long_flag->name;
+        throw invalid_flag(msg.str());
+      }
+      map.long_map.insert(std::make_pair(flag, &defn));
+    }
+  }
+
+  return map;
+}
+
+
+inline
+parser_results parser::parse(int argc, const char** argv) const
+{
+  // Inspect each definition to see if its valid. You may wonder "why don't
+  // you do this validation on construction?" I had thought about it but
+  // realized that since I've made the parser an aggregate type (granted it
+  // just "aggregates" a single vector) I would need to track any changes to
+  // the definitions vector and re-run the validity check in order to
+  // maintain this expected "validity invariant" on the object. That would
+  // then require hiding the definitions vector as a private entry and then
+  // turning the parser into a thin interface (by re-exposing setters and
+  // getters) to the vector methods just so that I can catch when the
+  // definition has been modified. It seems much simpler to just enforce the
+  // validity when you actually want to parser because it's at the moment of
+  // parsing that you know the definitions are complete.
+  parser_map map = validate_definitions(this->definitions);
+
+  // Initialize the parser results that we'll be returning. Store the program
+  // name (assumed to be the first command line argument) and initialize
+  // everything else as empty.
+  std::unordered_map<std::string, option_results> options {};
+  std::vector<const char*> pos;
+  parser_results results {argv[0], std::move(options), std::move(pos)};
+
+  // Add an empty option result for each definition.
+  for (const auto& defn : this->definitions) {
+    option_results opt_results {{}};
+    results.options.insert(
+      std::make_pair(defn.name, opt_results));
+  }
+
+  // Don't start off ignoring flags. We only ignore flags after a -- shows up
+  // in the command line arguments.
+  bool ignore_flags = false;
+
+  // Keep track of any options that are expecting arguments.
+  const char* last_flag_expecting_args = nullptr;
+  option_result* last_option_expecting_args = nullptr;
+  unsigned int num_option_args_to_consume = 0;
+
+  // Get pointers to pointers so we can treat the raw pointer array as an
+  // iterator for standard library algorithms. This isn't used yet but can be
+  // used to template this function to work on iterators over strings or
+  // C-strings.
+  const char** arg_i = argv + 1;
+  const char** arg_end = argv + argc;
+
+  while (arg_i != arg_end) {
+    auto arg_i_cstr = *arg_i;
+    auto arg_i_len = std::strlen(arg_i_cstr);
+
+    // Some behavior to note: if the previous option is expecting an argument
+    // then the next entry will be treated as a positional argument even if
+    // it looks like a flag.
+    bool treat_as_positional_argument = (
+        ignore_flags
+        || num_option_args_to_consume > 0
+        || !cmd_line_arg_is_option_flag(arg_i_cstr)
+      );
+    if (treat_as_positional_argument) {
+
+      // If last option is expecting some specific positive number of
+      // arguments then give this argument to that option, *regardless of
+      // whether or not the argument looks like a flag or is the special "--"
+      // argument*.
+      if (num_option_args_to_consume > 0) {
+        last_option_expecting_args->arg = arg_i_cstr;
+        --num_option_args_to_consume;
+        ++arg_i;
+        continue;
+      }
+
+      // Now we check if this is just "--" which is a special argument that
+      // causes all following arguments to be treated as non-options and is
+      // itselve discarded.
+      if (std::strncmp(arg_i_cstr, "--", 2) == 0 && arg_i_len == 2) {
+        ignore_flags = true;
+        ++arg_i;
+        continue;
+      }
+
+      // If there are no expectations for option arguments then simply use
+      // this argument as a positional argument.
+      results.pos.push_back(arg_i_cstr);
+      ++arg_i;
+      continue;
+    }
+
+    // Reset the "expecting argument" state.
+    last_flag_expecting_args = nullptr;
+    last_option_expecting_args = nullptr;
+    num_option_args_to_consume = 0;
+
+    // If we're at this point then we're definitely dealing with something
+    // that is flag-like and has hyphen as the first character and has a
+    // length of at least two characters. How we handle this potential flag
+    // depends on whether or not it is a long-option so we check that first.
+    bool is_long_flag = (arg_i_cstr[1] == '-');
+
+    if (is_long_flag) {
+
+      // Long flags have a complication: their arguments can be specified
+      // using an '=' character right inside the argument. That means an
+      // argument like "--output=foobar.txt" is actually an option with flag
+      // "--output" and argument "foobar.txt". So we look for the first
+      // instance of the '=' character and keep it in long_flag_arg. If
+      // long_flag_arg is nullptr then we didn't find '='. We need the
+      // flag_len to construct long_flag_str below.
+      auto long_flag_arg = std::strchr(arg_i_cstr, '=');
+      std::size_t flag_len = arg_i_len;
+      if (long_flag_arg != nullptr) {
+        flag_len = long_flag_arg - arg_i_cstr;
+      }
+      std::string long_flag_str(arg_i_cstr, flag_len);
+
+      if (!map.known_long_flag(long_flag_str)) {
+        std::ostringstream msg;
+        msg << "found unexpected flag: " << long_flag_str;
+        throw unexpected_option_error(msg.str());
+      }
+
+      const auto defn = map.get_definition_for_long_flag(long_flag_str);
+
+      if (long_flag_arg != nullptr && defn->num_args == 0) {
+        std::ostringstream msg;
+        msg << "found argument for option not expecting an argument: "
+            << arg_i_cstr;
+        throw unexpected_argument_error(msg.str());
+      }
+
+      // We've got a legitimate, known long flag option so we add an option
+      // result. This option result initially has an arg of nullptr, but that
+      // might change in the following block.
+      auto& opt_results = results.options[defn->name];
+      option_result opt_result {nullptr};
+      opt_results.all.push_back(std::move(opt_result));
+
+      if (defn->requires_arguments()) {
+        bool there_is_an_equal_delimited_arg = (long_flag_arg != nullptr);
+        if (there_is_an_equal_delimited_arg) {
+          // long_flag_arg would be "=foo" in the "--output=foo" case so we
+          // increment by 1 to get rid of the equal sign.
+          opt_results.all.back().arg = long_flag_arg + 1;
+        } else {
+          last_flag_expecting_args = arg_i_cstr;
+          last_option_expecting_args = &(opt_results.all.back());
+          num_option_args_to_consume = defn->num_args;
+        }
+      }
+
+      ++arg_i;
+      continue;
+    }
+
+    // If we've made it here then we're looking at either a short flag or a
+    // group of short flags. Short flags can be grouped together so long as
+    // they don't require any arguments unless the option that does is the
+    // last in the group ("-o x -v" is okay, "-vo x" is okay, "-ov x" is
+    // not). So starting after the dash we're going to process each character
+    // as if it were a separate flag. Note "sf_idx" stands for "short flag
+    // index".
+    for (std::size_t sf_idx = 1; sf_idx < arg_i_len; ++sf_idx) {
+      const auto short_flag = arg_i_cstr[sf_idx];
+
+      if (!std::isalnum(short_flag)) {
+        std::ostringstream msg;
+        msg << "found non-alphanumeric character '" << arg_i_cstr[sf_idx]
+            << "' in flag group '" << arg_i_cstr << "'";
+        throw std::domain_error(msg.str());
+      }
+
+      if (!map.known_short_flag(short_flag)) {
+        std::ostringstream msg;
+        msg << "found unexpected flag '" << arg_i_cstr[sf_idx]
+            << "' in flag group '" << arg_i_cstr << "'";
+        throw unexpected_option_error(msg.str());
+      }
+
+      auto defn = map.get_definition_for_short_flag(short_flag);
+      auto& opt_results = results.options[defn->name];
+
+      // Create an option result with an empty argument (for now) and add it
+      // to this option's results.
+      option_result opt_result {nullptr};
+      opt_results.all.push_back(std::move(opt_result));
+
+      if (defn->requires_arguments()) {
+
+        // If this short flag's option requires an argument and we're the
+        // last flag in the short flag group then just put the parser into
+        // "expecting argument for last option" state and move onto the next
+        // command line argument.
+        bool is_last_short_flag_in_group = (sf_idx == arg_i_len - 1);
+        if (is_last_short_flag_in_group) {
+          last_flag_expecting_args = arg_i_cstr;
+          last_option_expecting_args = &(opt_results.all.back());
+          num_option_args_to_consume = defn->num_args;
+          break;
+        }
+
+        // If this short flag's option requires an argument and we're NOT the
+        // last flag in the short flag group then we automatically consume
+        // the rest of the short flag group as the argument for this flag.
+        // This is how we get the POSIX behavior of being able to specify a
+        // flag's arguments without a white space delimiter (e.g.
+        // "-I/usr/local/include").
+        opt_results.all.back().arg = arg_i_cstr + sf_idx + 1;
+        break;
+      }
+    }
+
+    ++arg_i;
+    continue;
+  }
+
+  // If we're done with all of the arguments but are still expecting
+  // arguments for a previous option then we haven't satisfied that option.
+  // This is an error.
+  if (num_option_args_to_consume > 0) {
+    std::ostringstream msg;
+    msg << "last option \"" << last_flag_expecting_args
+        << "\" expects an argument but the parser ran out of command line "
+        << "arguments to parse";
+    throw option_lacks_argument_error(msg.str());
+  }
+
+  return results;
+}
+
+
+inline
+parser_results parser::parse(int argc, char** argv) const
+{
+  return parse(argc, const_cast<const char**>(argv));
+}
+
+
+namespace convert {
+
+
+  /**
+   * @brief
+   * Templated function for conversion to T using the @ref std::strtol()
+   * function.  This is used for anything long length or shorter (long, int,
+   * short, char).
+   */
+  template <typename T> inline
+  T long_(const char* arg)
+  {
+    char* endptr = nullptr;
+    errno = 0;
+    T ret = static_cast<T>(std::strtol(arg, &endptr, 0));
+    if (endptr == arg) {
+      std::ostringstream msg;
+      msg << "unable to convert argument to integer: \"" << arg << "\"";
+      throw std::invalid_argument(msg.str());
+    }
+    if (errno == ERANGE) {
+      throw std::out_of_range("argument numeric value out of range");
+    }
+    return ret;
+  }
+
+
+  /**
+   * @brief
+   * Templated function for conversion to T using the @ref std::strtoll()
+   * function.  This is used for anything long long length or shorter (long
+   * long).
+   */
+  template <typename T> inline
+  T long_long_(const char* arg)
+  {
+    char* endptr = nullptr;
+    errno = 0;
+    T ret = static_cast<T>(std::strtoll(arg, &endptr, 0));
+    if (endptr == arg) {
+      std::ostringstream msg;
+      msg << "unable to convert argument to integer: \"" << arg << "\"";
+      throw std::invalid_argument(msg.str());
+    }
+    if (errno == ERANGE) {
+      throw std::out_of_range("argument numeric value out of range");
+    }
+    return ret;
+  }
+
+
+#define DEFINE_CONVERSION_FROM_LONG_(TYPE) \
+  template <> inline \
+  TYPE arg(const char* arg) \
+  { \
+    return long_<TYPE>(arg); \
+  }
+
+  DEFINE_CONVERSION_FROM_LONG_(char)
+  DEFINE_CONVERSION_FROM_LONG_(unsigned char)
+  DEFINE_CONVERSION_FROM_LONG_(signed char)
+  DEFINE_CONVERSION_FROM_LONG_(short)
+  DEFINE_CONVERSION_FROM_LONG_(unsigned short)
+  DEFINE_CONVERSION_FROM_LONG_(int)
+  DEFINE_CONVERSION_FROM_LONG_(unsigned int)
+  DEFINE_CONVERSION_FROM_LONG_(long)
+  DEFINE_CONVERSION_FROM_LONG_(unsigned long)
+
+#undef DEFINE_CONVERSION_FROM_LONG_
+
+
+#define DEFINE_CONVERSION_FROM_LONG_LONG_(TYPE) \
+  template <> inline \
+  TYPE arg(const char* arg) \
+  { \
+    return long_long_<TYPE>(arg); \
+  }
+
+  DEFINE_CONVERSION_FROM_LONG_LONG_(long long)
+  DEFINE_CONVERSION_FROM_LONG_LONG_(unsigned long long)
+
+#undef DEFINE_CONVERSION_FROM_LONG_LONG_
+
+
+  template <> inline
+  bool arg(const char* arg)
+  {
+    return argagg::convert::arg<int>(arg) != 0;
+  }
+
+
+  template <> inline
+  float arg(const char* arg)
+  {
+    char* endptr = nullptr;
+    errno = 0;
+    float ret = std::strtof(arg, &endptr);
+    if (endptr == arg) {
+      std::ostringstream msg;
+      msg << "unable to convert argument to integer: \"" << arg << "\"";
+      throw std::invalid_argument(msg.str());
+    }
+    if (errno == ERANGE) {
+      throw std::out_of_range("argument numeric value out of range");
+    }
+    return ret;
+  }
+
+
+  template <> inline
+  double arg(const char* arg)
+  {
+    char* endptr = nullptr;
+    errno = 0;
+    double ret = std::strtod(arg, &endptr);
+    if (endptr == arg) {
+      std::ostringstream msg;
+      msg << "unable to convert argument to integer: \"" << arg << "\"";
+      throw std::invalid_argument(msg.str());
+    }
+    if (errno == ERANGE) {
+      throw std::out_of_range("argument numeric value out of range");
+    }
+    return ret;
+  }
+
+
+  template <> inline
+  const char* arg(const char* arg)
+  {
+    return arg;
+  }
+
+
+  template <> inline
+  std::string arg(const char* arg)
+  {
+    return std::string(arg);
+  }
+
+}
+
+
+inline
+fmt_ostream::fmt_ostream(std::ostream& output)
+: std::ostringstream(), output(output)
+{
+}
+
+
+inline
+fmt_ostream::~fmt_ostream()
+{
+  output << fmt_string(this->str());
+}
+
+
+#ifdef __unix__
+
+
+inline
+std::string fmt_string(const std::string& s)
+{
+  constexpr int read_end = 0;
+  constexpr int write_end = 1;
+
+  // TODO (vnguyen): This function overall needs to handle possible error
+  // returns from the various syscalls.
+
+  int read_pipe[2];
+  int write_pipe[2];
+  if (pipe(read_pipe) == -1) {
+    return s;
+  }
+  if (pipe(write_pipe) == -1) {
+    return s;
+  }
+
+  auto parent_pid = fork();
+  bool is_fmt_proc = (parent_pid == 0);
+  if (is_fmt_proc) {
+    dup2(write_pipe[read_end], STDIN_FILENO);
+    dup2(read_pipe[write_end], STDOUT_FILENO);
+    close(write_pipe[read_end]);
+    close(write_pipe[write_end]);
+    close(read_pipe[read_end]);
+    close(read_pipe[write_end]);
+    const char* argv[] = {"fmt", NULL};
+    execvp(const_cast<char*>(argv[0]), const_cast<char**>(argv));
+  }
+
+  close(write_pipe[read_end]);
+  close(read_pipe[write_end]);
+  auto fmt_write_fd = write_pipe[write_end];
+  auto write_result = write(fmt_write_fd, s.c_str(), s.length());
+  if (write_result != static_cast<ssize_t>(s.length())) {
+    return s;
+  }
+  close(fmt_write_fd);
+
+  auto fmt_read_fd = read_pipe[read_end];
+  std::ostringstream os;
+  char buf[64];
+  while (true) {
+    auto read_count = read(
+      fmt_read_fd, reinterpret_cast<void*>(buf), sizeof(buf));
+    if (read_count <= 0) {
+      break;
+    }
+    os.write(buf, static_cast<std::streamsize>(read_count));
+  }
+  close(fmt_read_fd);
+
+  return os.str();
+}
+
+
+#else // #ifdef __unix__
+
+
+inline
+std::string fmt_string(const std::string& s)
+{
+  return s;
+}
+
+
+#endif // #ifdef __unix__
+
+
+} // namespace argagg
+
+
+inline
+std::ostream& operator << (std::ostream& os, const argagg::parser& x)
+{
+  for (auto& definition : x.definitions) {
+    os << "    ";
+    for (auto& flag : definition.flags) {
+      os << flag;
+      if (flag != definition.flags.back()) {
+        os << ", ";
+      }
+    }
+    os << std::endl;
+    os << "        " << definition.help << std::endl;
+  }
+  return os;
+}
+
+
+#endif // ARGAGG_ARGAGG_ARGAGG_HPP

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/assert.h

@@ -0,0 +1,72 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Hauke Strasdat, Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/platform.h>
+#include <pangolin/utils/format_string.h>
+#include <iostream>
+
+#ifdef __GNUC__
+#  define PANGO_FUNCTION __PRETTY_FUNCTION__
+#elif (_MSC_VER >= 1310)
+#  define PANGO_FUNCTION __FUNCTION__
+#else
+#  define PANGO_FUNCTION "unknown"
+#endif
+
+namespace pangolin {
+
+template <typename... Args> PANGO_HOST_DEVICE
+void abort(const char* function, const char* file, int line, Args&&... args)
+{
+  std::fprintf(stderr, "pangolin::abort() in function '%s', file '%s', line %d.\n", function, file, line);
+#ifndef __CUDACC__
+  std::cerr << FormatString(std::forward<Args>(args)...) << std::endl;
+  std::abort();
+#endif
+}
+
+template <typename... Args> PANGO_HOST_DEVICE
+void warning(const char* expr, const char* function, const char* file, int line, Args&&... args)
+{
+  std::fprintf(stderr, "pangolin::warning() in function '%s', file '%s', line %d:\n\t%s\n", function, file, line, expr);
+#ifndef __CUDACC__
+  std::cerr << FormatString(std::forward<Args>(args)...) << std::endl;
+#endif
+}
+
+}
+
+// Always check, even in debug
+#define PANGO_ENSURE(expr, ...) ((expr) ? ((void)0) : pangolin::abort(PANGO_FUNCTION, __FILE__, __LINE__, ##__VA_ARGS__))
+
+// May be disabled for optimisation
+#define PANGO_ASSERT(expr, ...) ((expr) ? ((void)0) : pangolin::abort(PANGO_FUNCTION, __FILE__, __LINE__, ##__VA_ARGS__))
+
+#define PANGO_WARNING(expr, ...) ((expr) ? ((void)0) : pangolin::warning(#expr, PANGO_FUNCTION, __FILE__, __LINE__, ##__VA_ARGS__))
+

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/avx_math.h

@@ -0,0 +1,38 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Hauke Strasdat, Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+#ifdef __AVX2__
+#include <immintrin.h>
+#endif
+
+namespace pangolin
+{
+#ifdef __AVX2__
+__m256 pow256_ps(__m256 x, __m256 y);
+#endif
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/bitmask.h

@@ -0,0 +1,73 @@
+// Modified version of https://gpfault.net/posts/typesafe-bitmasks.txt.html (public domain)
+
+#include <type_traits>
+
+namespace pangolin {
+
+template <class option_type,
+          bool already_pow2,
+          // The line below ensures that bitmask can only be used with enums.
+          typename = typename std::enable_if<std::is_enum<option_type>::value>::type>
+class bitmask {
+  // The type we'll use for storing the value of our bitmask should be the same
+  // as the enum's underlying type.
+  using underlying_type = typename std::underlying_type<option_type>::type;
+
+  // This method helps us avoid having to explicitly set enum values to powers
+  // of two.
+  static constexpr underlying_type mask_value(option_type o) {
+
+    return already_pow2 ? o : 1 << static_cast<underlying_type>(o);
+  }
+
+  // Private ctor to be used internally.
+  explicit constexpr bitmask(underlying_type o) : mask_(o) {}
+
+public:
+  // Default ctor creates a bitmask with no options selected.
+  constexpr bitmask() : mask_(0) {}
+
+  // Creates a bitmask with just one bit set.
+  // This ctor is intentionally non-explicit, to allow for stuff like:
+  // FunctionExpectingBitmask(Options::Opt1)
+  constexpr bitmask(option_type o) : mask_(mask_value(o)) {}
+
+  // Set the bit corresponding to the given option.
+  constexpr bitmask operator|(option_type t) {
+    return bitmask(mask_ | (mask_value(t)));
+  }
+
+  // Set the bit corresponding to the given option.
+  void operator|=(option_type t) {
+    mask_ |= mask_value(t);
+  }
+
+  // Get the value of the bit corresponding to the given option.
+  constexpr bool operator&(option_type t) {
+    return mask_ & mask_value(t);
+  }
+
+  // Set the bit corresponding to the given option.
+  void operator&=(option_type t) {
+    mask_ &= mask_value(t);
+  }
+
+  underlying_type mask()
+  {
+      return mask_;
+  }
+
+  void set(option_type t, bool on)
+  {
+      if(on) {
+          mask_ |= mask_value(t);
+      }else{
+          mask_ &= ~mask_value(t);
+      }
+  }
+
+private:
+    underlying_type mask_ = 0;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/compontent_cast.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <pangolin/platform.h>
+
+#ifdef HAVE_EIGEN
+#  include <Eigen/Core>
+#endif
+
+namespace pangolin
+{
+
+// Scalar / Vector agnostic static_cast-like thing
+//
+// e.g. Promote float to double:
+//   ComponentCast<double,float>::cast(0.14f);
+//
+// e.g. Promote Eigen::Vector2f to Eigen::Vector2d:
+//   ComponentCast<Eigen::Vector2d,Eigen::Vector2f>::cast(Eigen::Vector2f(0.1,0.2);
+
+template <typename To, typename From>
+struct ComponentCast
+{
+    PANGO_HOST_DEVICE
+    static To cast(const From& val)
+    {
+        return static_cast<To>(val);
+    }
+};
+
+#ifdef HAVE_EIGEN
+template <typename To, typename FromDerived>
+struct ComponentCast<To, Eigen::MatrixBase<FromDerived> >
+{
+    PANGO_HOST_DEVICE
+    static To cast(const Eigen::MatrixBase<FromDerived>& val)
+    {
+        return val.template cast<typename To::Scalar>();
+    }
+};
+#endif
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/file_extension.h

@@ -0,0 +1,77 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/platform.h>
+#include <string>
+
+namespace pangolin
+{
+
+enum ImageFileType
+{
+    ImageFileTypePpm,
+    ImageFileTypeTga,
+    ImageFileTypePng,
+    ImageFileTypeJpg,
+    ImageFileTypeTiff,
+    ImageFileTypeGif,
+    ImageFileTypeExr,
+    ImageFileTypeBmp,
+    ImageFileTypePango,
+    ImageFileTypePvn,
+    ImageFileTypeVrs,
+    ImageFileTypeZstd,
+    ImageFileTypeLz4,
+    ImageFileTypeP12b,
+    ImageFileTypePly,
+    ImageFileTypeObj,
+    ImageFileTypeArw,
+    ImageFileTypeUnknown
+};
+
+
+PANGOLIN_EXPORT
+std::string ImageFileTypeToName(ImageFileType);
+
+PANGOLIN_EXPORT
+ImageFileType NameToImageFileType(const std::string&);
+
+PANGOLIN_EXPORT
+std::string FileLowercaseExtention(const std::string& filename);
+
+PANGOLIN_EXPORT
+ImageFileType FileTypeMagic(const unsigned char data[], size_t bytes);
+
+PANGOLIN_EXPORT
+ImageFileType FileTypeExtension(const std::string& ext);
+
+PANGOLIN_EXPORT
+ImageFileType FileType(const std::string& filename);
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/file_utils.h

@@ -0,0 +1,161 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/platform.h>
+
+#include <string>
+#include <vector>
+#include <algorithm>
+
+namespace pangolin
+{
+
+PANGOLIN_EXPORT
+std::vector<std::string>& Split(const std::string& s, char delim, std::vector<std::string>& elements);
+
+PANGOLIN_EXPORT
+std::vector<std::string> Split(const std::string &s, char delim);
+
+PANGOLIN_EXPORT
+std::vector<std::string> Expand(const std::string &s, char open='[', char close=']', char delim=',');
+
+PANGOLIN_EXPORT
+std::string SanitizePath(const std::string& path);
+
+PANGOLIN_EXPORT
+std::string PathParent(const std::string& path, int levels = 1);
+
+PANGOLIN_EXPORT
+bool FileExists(const std::string& filename);
+
+PANGOLIN_EXPORT
+std::string FindPath(const std::string& child_path, const std::string& signature_path);
+
+PANGOLIN_EXPORT
+std::string PathExpand(const std::string& sPath);
+
+PANGOLIN_EXPORT
+bool MatchesWildcard(const std::string& str, const std::string& wildcard);
+
+PANGOLIN_EXPORT
+std::string GetFileContents(const std::string& filename);
+
+
+enum class SortMethod {
+  STANDARD,
+  NATURAL 
+};
+
+// Fill 'file_vec' with the files that match the glob-like 'wildcard_file_path'
+// ? can be used to match any single charector
+// * can be used to match any sequence of charectors in a directory
+// ** can be used to match any directories across any number of levels
+//   e.g. FilesMatchingWildcard("~/*/code/*.h", vec);
+//   e.g. FilesMatchingWildcard("~/**/*.png", vec);
+// sort the file_vec according to the specified sorting method.
+PANGOLIN_EXPORT
+bool FilesMatchingWildcard(const std::string& wildcard_file_path, std::vector<std::string>& file_vec, SortMethod sort_method = SortMethod::STANDARD);
+
+PANGOLIN_EXPORT
+std::string MakeUniqueFilename(const std::string& filename);
+
+PANGOLIN_EXPORT
+bool IsPipe(const std::string& file);
+
+PANGOLIN_EXPORT
+bool IsPipe(int fd);
+
+PANGOLIN_EXPORT
+int WritablePipeFileDescriptor(const std::string& file);
+
+/**
+ * Open the file for reading. Note that it is opened with O_NONBLOCK.  The pipe
+ * open is done in two stages so that the producer knows a reader is waiting
+ * (but not blocked). The reader then checks PipeHasDataToRead() until it
+ * returns true. The file can then be opened. Note that the file descriptor
+ * should be closed after the read stream has been created so that the write
+ * side of the pipe does not get signaled.
+ */
+PANGOLIN_EXPORT
+int ReadablePipeFileDescriptor(const std::string& file);
+
+PANGOLIN_EXPORT
+bool PipeHasDataToRead(int fd);
+
+PANGOLIN_EXPORT
+void FlushPipe(const std::string& file);
+
+// TODO: Tidy these inlines up / move them
+
+inline bool StartsWith(const std::string& str, const std::string& prefix)
+{
+    return !str.compare(0, prefix.size(), prefix);
+}
+
+inline bool EndsWith(const std::string& str, const std::string& prefix)
+{
+    return !str.compare(str.size() - prefix.size(), prefix.size(), prefix);
+}
+
+inline std::string Trim(const std::string& str, const std::string& delimiters = " \f\n\r\t\v" )
+{
+    const size_t f = str.find_first_not_of( delimiters );
+    return f == std::string::npos ?
+                "" :
+                str.substr( f, str.find_last_not_of( delimiters ) + 1 );
+}
+
+inline void ToUpper( std::string& str )
+{
+    std::transform(str.begin(), str.end(), str.begin(), ::toupper);
+}
+
+inline void ToLower( std::string& str )
+{
+    std::transform(str.begin(), str.end(), str.begin(), ::tolower);
+}
+
+inline std::string ToUpperCopy( const std::string& str )
+{
+    std::string out;
+    out.resize(str.size());
+    std::transform(str.begin(), str.end(), out.begin(), ::toupper);
+    return out;
+}
+
+inline std::string ToLowerCopy( const std::string& str )
+{
+    std::string out;
+    out.resize(str.size());
+    std::transform(str.begin(), str.end(), out.begin(), ::tolower);
+    return out;
+}
+
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/fix_size_buffer_queue.h

@@ -0,0 +1,152 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <condition_variable>
+#include <list>
+#include <mutex>
+#include <thread>
+
+namespace pangolin
+{
+
+template<typename BufPType>
+class FixSizeBuffersQueue
+{
+
+public:
+    FixSizeBuffersQueue() {}
+
+    ~FixSizeBuffersQueue() {
+    }
+
+    BufPType getNewest() {
+        std::lock_guard<std::mutex> vlock(vMtx);
+        std::lock_guard<std::mutex> elock(eMtx);
+        if(validBuffers.size() == 0) {
+            // Empty queue.
+            return 0;
+        } else {
+            // Requeue all but newest buffers.
+            while(validBuffers.size() > 1) {
+                emptyBuffers.push_back(std::move(validBuffers.front()));
+                validBuffers.pop_front();
+            }
+            // Return newest buffer.
+            BufPType bp = std::move(validBuffers.front());
+            validBuffers.pop_front();
+            return bp;
+        }
+    }
+
+    BufPType getNext() {
+        std::lock_guard<std::mutex> vlock(vMtx);
+        if(validBuffers.size() == 0) {
+            // Empty queue.
+            return 0;
+        } else {
+            // Return oldest buffer.
+            BufPType bp = std::move(validBuffers.front());
+            validBuffers.pop_front();
+            return bp;
+        }
+    }
+
+    BufPType getFreeBuffer() {
+        std::lock_guard<std::mutex> vlock(vMtx);
+        std::lock_guard<std::mutex> elock(eMtx);
+        if(emptyBuffers.size() > 0) {
+            // Simply get a free buffer from the free buffers list.
+            BufPType bp = std::move(emptyBuffers.front());
+            emptyBuffers.pop_front();
+            return bp;
+        } else {
+            if(validBuffers.size() == 0) {
+                // Queue not yet initialized.
+                throw std::runtime_error("Queue not yet initialised.");
+            } else {
+                std::cerr << "Out of free buffers." << std::endl;
+                // No free buffers return oldest among the valid buffers.
+                BufPType bp = std::move(validBuffers.front());
+                validBuffers.pop_front();
+                return bp;
+            }
+        }
+    }
+
+    void addValidBuffer(BufPType bp) {
+        // Add buffer to valid buffers queue.
+        std::lock_guard<std::mutex> vlock(vMtx);
+        validBuffers.push_back(std::move(bp));
+    }
+
+    void returnOrAddUsedBuffer(BufPType bp) {
+        // Add buffer back to empty buffers queue.
+        std::lock_guard<std::mutex> elock(eMtx);
+        emptyBuffers.push_back(std::move(bp));
+    }
+
+    size_t AvailableFrames() const {
+        std::lock_guard<std::mutex> vlock(vMtx);
+        return validBuffers.size();
+    }
+
+    size_t EmptyBuffers() const {
+        std::lock_guard<std::mutex> elock(eMtx);
+        return emptyBuffers.size();
+    }
+
+    bool DropNFrames(size_t n) {
+        std::lock_guard<std::mutex> vlock(vMtx);
+        if(validBuffers.size() < n) {
+            return false;
+        } else {
+            std::lock_guard<std::mutex> elock(eMtx);
+            // Requeue all but newest buffers.
+            for(unsigned int i=0; i<n; ++i) {
+                emptyBuffers.push_back(std::move(validBuffers.front()));
+                validBuffers.pop_front();
+            }
+            return true;
+        }
+    }
+
+//    unsigned int BufferSizeBytes(){
+//        return bufferSizeBytes;
+//    }
+
+private:
+    std::list<BufPType> validBuffers;
+    std::list<BufPType> emptyBuffers;
+    mutable std::mutex vMtx;
+    mutable std::mutex eMtx;
+//    unsigned int maxNumBuffers;
+//    unsigned int bufferSizeBytes;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/format_string.h

@@ -0,0 +1,87 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Hauke Strasdat, Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <sstream>
+
+namespace pangolin {
+namespace details {
+
+// Following: http://stackoverflow.com/a/22759544
+template <typename T>
+class IsStreamable {
+private:
+    template <typename TT>
+    static auto test(int) -> decltype( (std::declval<std::stringstream&>() << std::declval<TT>(), std::true_type()) );
+
+    template <typename>
+    static auto test(...) -> std::false_type;
+
+public:
+    static const bool value = decltype(test<T>(0))::value;
+};
+
+inline void FormatStream(std::stringstream& stream, const char* text)
+{
+    stream << text;
+}
+
+// Following: http://en.cppreference.com/w/cpp/language/parameter_pack
+template <typename T, typename... Args>
+void FormatStream(std::stringstream& stream, const char* text, T arg, Args... args)
+{
+    static_assert(IsStreamable<T>::value,
+                  "One of the args has not an ostream overload!");
+    for (; *text != '\0'; ++text) {
+        if (*text == '%') {
+            stream << arg;
+            FormatStream(stream, text + 1, args...);
+            return;
+        }
+        stream << *text;
+    }
+    stream << "\nFormat-Warning: There are " << sizeof...(Args) + 1
+           << " args unused.";
+}
+
+}  // namespace details
+
+template <typename... Args>
+std::string FormatString(const char* text, Args... args)
+{
+    std::stringstream stream;
+    details::FormatStream(stream, text, args...);
+    return stream.str();
+}
+
+inline std::string FormatString()
+{
+    return std::string();
+}
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/is_streamable.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <type_traits>
+#include <utility>
+#include <iostream>
+#include <sstream>
+
+namespace pangolin {
+
+// Provide SFINAE test for if type T is streamable into S
+// Example usage:
+//    template <typename S>
+//    typename std::enable_if<is_streamable<S>::value, S>::type
+//    Example(const S& src) noexcept
+//    {
+//        std::cout << src;
+//        return src;
+//    }
+template<typename T, typename S = std::ostream>
+class is_streamable
+{
+    template<typename SS, typename TT>
+    static auto test(int)
+    -> decltype( std::declval<SS&>() << std::declval<TT>(), std::true_type() );
+
+    template<typename, typename>
+    static auto test(...) -> std::false_type;
+
+public:
+    static const bool value = decltype(test<S,T>(0))::value;
+};
+
+
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/log.h

@@ -0,0 +1,44 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+// TODO: Something a bit more useful here, probably using format_string.h
+
+#pragma once
+
+#ifndef _ANDROID_
+#   include <cstdio>
+#   define pango_print_debug(...) printf(__VA_ARGS__)
+#   define pango_print_info(...)  printf(__VA_ARGS__)
+#   define pango_print_error(...) fprintf(stderr, __VA_ARGS__)
+#   define pango_print_warn(...)  fprintf(stderr, __VA_ARGS__)
+#else
+#   include <android/log.h>
+#   define pango_print_debug(...) __android_log_print(ANDROID_LOG_DEBUG, "pango", __VA_ARGS__ );
+#   define pango_print_info(...)  __android_log_print(ANDROID_LOG_INFO,  "pango", __VA_ARGS__ );
+#   define pango_print_error(...) __android_log_print(ANDROID_LOG_ERROR, "pango", __VA_ARGS__ );
+#   define pango_print_warn(...)  __android_log_print(ANDROID_LOG_ERROR, "pango", __VA_ARGS__ );
+#endif

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/memstreambuf.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <streambuf>
+#include <vector>
+
+namespace pangolin {
+
+// A simple streambuf wrapper around std::vector for memory buffer use
+struct memstreambuf : public std::streambuf
+{
+public:
+    memstreambuf(size_t initial_buffer_size)
+    {
+        buffer.reserve(initial_buffer_size);
+    }
+
+    // Avoiding use of std::streambuf's move constructor, since it is missing for old GCC
+    memstreambuf(memstreambuf&& o)
+        : buffer(std::move(o.buffer))
+    {
+        pubseekpos(o.pubseekoff(0, std::ios_base::cur));
+    }
+
+    size_t size() const
+    {
+        return buffer.size();
+    }
+
+    const unsigned char* data() const
+    {
+        return buffer.data();
+    }
+
+    void clear()
+    {
+        buffer.clear();
+    }
+
+    std::vector<unsigned char> buffer;
+
+protected:
+    std::streamsize xsputn(const char_type* __s, std::streamsize __n) override
+    {
+        buffer.insert(buffer.end(), __s, __s + __n);
+        return __n;
+    }
+
+    int_type overflow(int_type __c) override
+    {
+        buffer.push_back( static_cast<unsigned char>(__c) );
+        return __c;
+    }
+};
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/param_set.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <unordered_set>
+#include <regex>
+
+#include <pangolin/utils/uri.h>
+
+namespace pangolin
+{
+
+struct PANGOLIN_EXPORT ParamSet {
+    struct PANGOLIN_EXPORT Param {
+        std::string name_regex;
+        std::string default_value;
+        std::string description;
+    };
+
+    std::vector<Param> params;
+    std::string str() const;
+};
+
+class PANGOLIN_EXPORT ParamReader {
+public:
+    class ParamReaderException : public std::exception {
+    public:
+        ParamReaderException( const std::string &param_name )
+        {
+            error_message_ = param_name + " was not found in the parameter set";
+        }
+        virtual const char* what() const noexcept override {
+            return error_message_.c_str();
+        }
+    private:
+        std::string error_message_;
+    };
+
+    ParamReader( const ParamSet& param_set, const Uri& uri )
+        : param_set_(param_set), uri_(uri)
+    {}
+
+    template<typename T>
+    T Get( const std::string& param_name ) const
+    {
+        const ParamSet::Param* param = GetMatchingParamFromParamSet( param_name );
+        if( param ){
+            return GetHelper(param_name, Convert<T,std::string>::Do(param->default_value));
+        }
+        throw ParamReaderException( param_name );
+    }
+
+    template<typename T>
+    T Get( const std::string& param_name, const T& default_value ) const
+    {
+        const ParamSet::Param* param = GetMatchingParamFromParamSet( param_name );
+        if( param ){
+            return GetHelper(param_name, default_value);
+        }
+        throw ParamReaderException( param_name );
+    }
+
+    bool Contains( const std::string& param_name );
+
+    std::unordered_set<std::string> FindUnrecognizedUriParams();
+
+private:
+    template<typename T>
+    T GetHelper( const std::string& param_name, const T& default_value ) const
+    {
+        return uri_.Get(param_name, default_value);
+    }
+
+    const ParamSet::Param* GetMatchingParamFromParamSet( const std::string& param_name ) const;
+
+private:
+    const ParamSet param_set_;
+    const Uri uri_;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/params.h

@@ -0,0 +1,97 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/platform.h>
+#include <pangolin/utils/type_convert.h>
+
+#include <string>
+#include <vector>
+#include <algorithm>
+
+namespace pangolin
+{
+
+struct PANGOLIN_EXPORT Params
+{
+    // Why not an actual map here?
+    // Well, in some drivers (notably USB3Vision based drivers) order
+    // matters, sometimes with duplicate keys.
+    typedef std::pair<std::string,std::string> KeyValue;
+    typedef std::vector<KeyValue> ParamMap;
+
+    Params()
+    {
+    }
+
+    Params(std::initializer_list<std::pair<std::string,std::string>> l)
+        : params(l)
+    {
+    }
+
+    // \returns true iff any entry has the key \param key
+    bool Contains(const std::string& key) const
+    {
+        for(ParamMap::const_iterator it = params.begin(); it!=params.end(); ++it) {
+            if(it->first == key) return true;
+        }
+        return false;
+    }
+
+    // \returns the value of the last entry with key \param key
+    //          or \param default_val if no such entry exists
+    template<typename T>
+    T Get(const std::string& key, T default_val) const
+    {
+        // Return last value passed to the key.
+        for(ParamMap::const_reverse_iterator it = params.rbegin(); it!=params.rend(); ++it) {
+            if(it->first == key) return Convert<T, std::string>::Do(it->second);
+        }
+        return default_val;
+    }
+
+    // Adds a new entry with key \param key and value \param val to the end of the parameters list
+    // note: Any existing entry with key \param key will remain, but be overriden users with map-semantics.
+    template<typename T>
+    void Set(const std::string& key, const T& val)
+    {
+        params.push_back(std::pair<std::string,std::string>(key,Convert<std::string,T>::Do(val)));
+    }
+
+    // Remove all entries with key \param key
+    void Remove(const std::string& key)
+    {
+        params.erase(std::remove_if(params.begin(), params.end(), [&key](const KeyValue& kv){
+            return kv.first == key;
+        }), params.end());
+    }
+
+    ParamMap params;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/parse.h

@@ -0,0 +1,108 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef PANGOLIN_PARSE_H
+#define PANGOLIN_PARSE_H
+
+#include <string>
+#include <cctype>
+
+namespace pangolin
+{
+
+const unsigned int parse_max_token_size = 1024;
+
+inline void ConsumeWhitespace(std::istream& is)
+{
+    while(is.good() && std::isspace(is.peek()) ) {
+        is.get();
+    }
+}
+
+inline bool ConsumeToNewline(std::istream& is)
+{
+    while(is.good()) {
+        if(is.get() == '\n') {
+            return true;
+        }
+    }
+    return false;
+}
+
+template<size_t buffer_size> inline
+size_t ReadToken(std::istream& is, char buffer[buffer_size])
+{
+    size_t r = 0;
+    while(is.good() && r < buffer_size-1) {
+        int c = is.peek();
+        if( std::isgraph(c) ) {
+            buffer[r++] = (char)is.get();
+        }else{
+            break;
+        }
+    }
+    buffer[r] = '\0';
+    return r;
+}
+
+inline std::string ReadToken(std::istream &is)
+{
+    char str_token[parse_max_token_size];
+    ReadToken<parse_max_token_size>(is, str_token);
+    return std::string(str_token);
+}
+
+template<size_t buffer_size> inline
+size_t ConsumeWhitespaceReadToken(std::istream& is, char buffer[buffer_size])
+{
+    ConsumeWhitespace(is);
+    return ReadToken<buffer_size>(is, buffer);
+}
+
+inline int ParseToken(const char* token, const char* token_list[], size_t token_list_size)
+{
+    for(size_t i=0; i < token_list_size; ++i) {
+        if( strcmp(token, token_list[i]) == 0 ) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+#define PANGOLIN_DEFINE_PARSE_TOKEN(x) \
+    inline x ParseToken##x(const char* token) { \
+        return (x)ParseToken(token, x##String, x##Size); \
+    } \
+    inline x ParseToken##x(std::istream& is) { \
+        char str_token[parse_max_token_size]; \
+        ReadToken<parse_max_token_size>(is, str_token); \
+        return ParseToken##x( str_token ); \
+    }
+
+}
+
+#endif // PANGOLIN_PARSE_H

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/picojson.h

@@ -0,0 +1,1416 @@
+/* This is a (butchered) derivative of picojson, incorporated into the
+ * Pangolin Project (http://github.com/stevenlovegrove/Pangolin)
+ *
+ * Modifications Copyright (c) 2014 Steven Lovegrove,
+ * Original licence applies (below), https://github.com/kazuho/picojson
+ */
+
+/*
+ * Copyright 2009-2010 Cybozu Labs, Inc.
+ * Copyright 2011-2014 Kazuho Oku
+ * 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.
+ *
+ * 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.
+ */
+#ifndef picojson_h
+#define picojson_h
+
+#include <algorithm>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include <pangolin/compat/type_traits.h>
+
+// Enable INT64 support
+#define PICOJSON_USE_INT64
+
+// for isnan/isinf
+#if __cplusplus>=201103L
+# include <cmath>
+#else
+extern "C" {
+# ifdef _MSC_VER
+#  include <float.h>
+# elif defined(__INTEL_COMPILER)
+#  include <mathimf.h>
+# else
+#  include <math.h>
+# endif
+}
+#endif
+
+// experimental support for int64_t (see README.mkdn for detail)
+#ifdef PICOJSON_USE_INT64
+# ifndef __STDC_FORMAT_MACROS
+#  define __STDC_FORMAT_MACROS
+# endif
+# include <errno.h>
+# include <inttypes.h>
+#endif // PICOJSON_USE_INT64
+
+// to disable the use of localeconv(3), set PICOJSON_USE_LOCALE to 0
+#ifndef PICOJSON_USE_LOCALE
+# define PICOJSON_USE_LOCALE 1
+#endif // PICOJSON_USE_LOCALE
+
+#if PICOJSON_USE_LOCALE
+extern "C" {
+# include <locale.h>
+}
+#endif // PICOJSON_USE_LOCALE
+
+#ifndef PICOJSON_ASSERT
+# define PICOJSON_ASSERT(e) do { if (! (e)) throw std::runtime_error(#e); } while (0)
+#endif
+
+#ifdef _MSC_VER
+#define SNPRINTF _snprintf_s
+#pragma warning(push)
+#pragma warning(disable : 4244) // conversion from int to char
+#else
+#define SNPRINTF snprintf
+#endif
+
+#ifdef _MSC_VER
+#define PICOJSON_FALSE_TEMPLATE_TYPE nullptr
+#else
+#define PICOJSON_FALSE_TEMPLATE_TYPE ((void*)0)
+#endif
+
+namespace picojson {
+
+enum {
+    null_type,
+    boolean_type,
+    number_type,
+    string_type,
+    array_type,
+    object_type
+#ifdef PICOJSON_USE_INT64
+    , int64_type
+#endif
+};
+
+enum {
+    INDENT_WIDTH = 2
+};
+
+struct null {};
+
+class value {
+public:
+    typedef std::vector<value> array;
+    typedef std::map<std::string, value> object;
+
+    union _storage {
+        bool boolean_;
+        double number_;
+#ifdef PICOJSON_USE_INT64
+        int64_t int64_;
+#endif
+        std::string* string_;
+        array* array_;
+        object* object_;
+    };
+protected:
+    int type_;
+    _storage u_;
+public:
+
+
+    /////////////////////////////
+    // Constructors / Destructor
+    /////////////////////////////
+
+    ~value();
+    value();
+    value(int type, bool);
+
+    /////////////////////////////
+    // Implicit type constructors
+    /////////////////////////////
+
+    value(bool b) : type_(boolean_type) {
+        u_.boolean_ = b;
+    }
+
+#ifdef PICOJSON_USE_INT64
+    value(short v) : type_(int64_type) {
+        u_.int64_ = static_cast<int64_t>(v);
+    }
+    value(unsigned short v) : type_(int64_type) {
+        u_.int64_ = static_cast<int64_t>(v);
+    }
+    value(int v) : type_(int64_type) {
+        u_.int64_ = static_cast<int64_t>(v);
+    }
+    value(unsigned int v) : type_(int64_type) {
+        u_.int64_ = static_cast<int64_t>(v);
+    }
+    value(long v) : type_(int64_type) {
+        u_.int64_ = static_cast<int64_t>(v);
+    }
+    value(unsigned long v) : type_(int64_type) {
+        u_.int64_ = static_cast<int64_t>(v);
+    }
+    value(long long v) : type_(int64_type) {
+        u_.int64_ = static_cast<int64_t>(v);
+    }
+    value(unsigned long long v) : type_(int64_type) {
+        u_.int64_ = static_cast<int64_t>(v);
+    }
+#endif
+
+    value(float n) : type_(number_type) {
+        if (
+            #ifdef _MSC_VER
+                ! _finite(n)
+            #elif __cplusplus>=201103L || !(defined(isnan) && defined(isinf))
+                std::isnan(n) || std::isinf(n)
+            #else
+                isnan(n) || isinf(n)
+            #endif
+                ) {
+            throw std::overflow_error("");
+        }
+        u_.number_ = static_cast<double>(n);
+    }
+
+    value(double n) : type_(number_type) {
+        if (
+            #ifdef _MSC_VER
+                ! _finite(n)
+            #elif __cplusplus>=201103L || !(defined(isnan) && defined(isinf))
+                std::isnan(n) || std::isinf(n)
+            #else
+                isnan(n) || isinf(n)
+            #endif
+                ) {
+            throw std::overflow_error("");
+        }
+        u_.number_ = n;
+    }
+
+    value(const array& a);
+    value(const object& o);
+
+    value(const std::string& s);
+    value(const char* s);
+    value(const char* s, size_t len);
+
+    value(const value& x);
+    value& operator=(const value& x);
+
+    /////////////////////////////
+    // Query / get type
+    /////////////////////////////
+
+    void swap(value& x);
+    template <typename T> bool is() const;
+    template <typename T> const T& get() const;
+    template <typename T> T& get();
+    bool evaluate_as_boolean() const;
+    size_t size() const;
+
+    /////////////////////////////
+    // Usage as array
+    /////////////////////////////
+
+    value& operator[](size_t idx);
+    const value& operator[](size_t idx) const;
+    bool contains(size_t idx) const;
+    value& push_back(const value& = value() );
+
+    /////////////////////////////
+    // Usage as object
+    /////////////////////////////
+
+    value& operator[](const std::string& key);
+    const value& operator[](const std::string& key) const;
+    bool contains(const std::string& key) const;
+
+    template <typename T>
+    T get_value(const std::string& key, T default_value) const;
+
+    /////////////////////////////
+    // Serialization
+    /////////////////////////////
+
+    std::string to_str() const;
+    template <typename Iter> void serialize(Iter os, bool prettify = false) const;
+    std::string serialize(bool prettify = false) const;
+private:
+    template <typename T> value(const T*); // intentionally defined to block implicit conversion of pointer to bool
+    template <typename Iter> static void _indent(Iter os, int indent);
+    template <typename Iter> void serialize_(Iter os, int indent) const;
+    std::string serialize_(int indent) const;
+};
+
+typedef value::array array;
+typedef value::object object;
+
+inline value::value() : type_(null_type), u_({false}) {}
+
+inline value::value(int type, bool) : type_(type) {
+    switch (type) {
+#define INIT(p, v) case p##type: u_.p = v; break
+    INIT(boolean_, false);
+    INIT(number_, 0.0);
+#ifdef PICOJSON_USE_INT64
+    INIT(int64_, 0);
+#endif
+    INIT(string_, new std::string());
+    INIT(array_, new array());
+    INIT(object_, new object());
+#undef INIT
+    default: break;
+    }
+}
+
+inline value::value(const std::string& s) : type_(string_type) {
+    u_.string_ = new std::string(s);
+}
+
+inline value::value(const array& a) : type_(array_type) {
+    u_.array_ = new array(a);
+}
+
+inline value::value(const object& o) : type_(object_type) {
+    u_.object_ = new object(o);
+}
+
+inline value::value(const char* s) : type_(string_type) {
+    u_.string_ = new std::string(s);
+}
+
+inline value::value(const char* s, size_t len) : type_(string_type) {
+    u_.string_ = new std::string(s, len);
+}
+
+inline value::~value() {
+    switch (type_) {
+#define DEINIT(p) case p##type: delete u_.p; break
+    DEINIT(string_);
+    DEINIT(array_);
+    DEINIT(object_);
+#undef DEINIT
+    default: break;
+    }
+}
+
+inline value::value(const value& x) : type_(x.type_) {
+    switch (type_) {
+#define INIT(p, v) case p##type: u_.p = v; break
+    INIT(string_, new std::string(*x.u_.string_));
+    INIT(array_, new array(*x.u_.array_));
+    INIT(object_, new object(*x.u_.object_));
+#undef INIT
+    default:
+        u_ = x.u_;
+        break;
+    }
+}
+
+inline value& value::operator=(const value& x) {
+    if (this != &x) {
+        this->~value();
+        new (this) value(x);
+    }
+    return *this;
+}
+
+inline void value::swap(value& x) {
+    std::swap(type_, x.type_);
+    std::swap(u_, x.u_);
+}
+
+#define IS(ctype, jtype)			     \
+    template <> inline bool value::is<ctype>() const { \
+    return type_ == jtype##_type;		     \
+}
+IS(null, null)
+IS(bool, boolean)
+#ifdef PICOJSON_USE_INT64
+IS(int64_t, int64)
+#endif
+IS(std::string, string)
+IS(array, array)
+IS(object, object)
+#undef IS
+template <> inline bool value::is<double>() const {
+    return type_ == number_type
+        #ifdef PICOJSON_USE_INT64
+            || type_ == int64_type
+        #endif
+            ;
+}
+
+#define GET(ctype, var)						\
+    template <> inline const ctype& value::get<ctype>() const {	\
+    PICOJSON_ASSERT("type mismatch! call is<type>() before get<type>()" \
+    && is<ctype>());				        \
+    return var;							\
+}								\
+    template <> inline ctype& value::get<ctype>() {		\
+    PICOJSON_ASSERT("type mismatch! call is<type>() before get<type>()"	\
+    && is<ctype>());					\
+    return var;							\
+}
+GET(bool, u_.boolean_)
+GET(std::string, *u_.string_)
+GET(array, *u_.array_)
+GET(object, *u_.object_)
+#ifdef PICOJSON_USE_INT64
+GET(double, (type_ == int64_type && (const_cast<value*>(this)->type_ = number_type, const_cast<value*>(this)->u_.number_ = u_.int64_), u_.number_))
+GET(int64_t, u_.int64_)
+#else
+GET(double, u_.number_)
+#endif
+#undef GET
+
+inline bool value::evaluate_as_boolean() const {
+    switch (type_) {
+    case null_type:
+        return false;
+    case boolean_type:
+        return u_.boolean_;
+    case number_type:
+        return u_.number_ != 0;
+    case string_type:
+        return ! u_.string_->empty();
+    default:
+        return true;
+    }
+}
+
+inline size_t value::size() const
+{
+    PICOJSON_ASSERT("Type mismatch! Not array." && is<array>());
+    return u_.array_->size();
+}
+
+inline const value& value::operator[](size_t idx) const {
+    PICOJSON_ASSERT("Type mismatch! Not array." && is<array>());
+    PICOJSON_ASSERT("Out of bounds." && idx < u_.array_->size() );
+    return (*u_.array_)[idx];
+}
+
+inline value& value::operator[](size_t idx) {
+    if( type_ == null_type ) {
+        // instantiate as array
+        type_ = array_type;
+        u_.array_ = new array();
+    }
+
+    PICOJSON_ASSERT("Type mismatch! Not array." && is<array>());
+    PICOJSON_ASSERT("Out of bounds." && idx < u_.array_->size() );
+    return (*u_.array_)[idx];
+}
+
+inline bool value::contains(size_t idx) const {
+    if( type_ == array_type) {
+        return idx < u_.array_->size();
+    }else{
+        return false;
+    }
+}
+
+inline value& value::push_back(const value& val)
+{
+    if( type_ == null_type ) {
+        // instantiate as array
+        type_ = array_type;
+        u_.array_ = new array();
+    }
+    PICOJSON_ASSERT("Type mismatch! Not array." && is<array>());
+    u_.array_->push_back( val );
+    return u_.array_->back();
+}
+
+inline const value& value::operator[](const std::string& key) const {
+    PICOJSON_ASSERT("Type mismatch! Not object." && is<object>() );
+    object::const_iterator i = u_.object_->find(key);
+    PICOJSON_ASSERT("Key not found." && i != u_.object_->end() );
+    return i->second;
+}
+
+inline value& value::operator[](const std::string& key) {
+    if( type_ == null_type ) {
+        // instantiate as object
+        type_ = object_type;
+        u_.object_ = new object();
+    }
+    PICOJSON_ASSERT("Type mismatch! Not object." && is<object>());
+    return u_.object_->operator [](key);
+}
+
+inline bool value::contains(const std::string& key) const {
+    if( type_ == object_type) {
+        object::const_iterator i = u_.object_->find(key);
+        return i != u_.object_->end();
+    }else{
+        return false;
+    }
+}
+
+template <typename T>
+inline T value::get_value(const std::string& key, T default_value) const {
+    if(contains(key)) {
+        return (*this)[key].get<T>();
+    }else{
+        return default_value;
+    }
+}
+
+inline std::string value::to_str() const {
+    switch (type_) {
+    case null_type:      return "null";
+    case boolean_type:   return u_.boolean_ ? "true" : "false";
+#ifdef PICOJSON_USE_INT64
+    case int64_type: {
+        char buf[sizeof("-9223372036854775808")];
+        SNPRINTF(buf, sizeof(buf), "%" PRId64, u_.int64_);
+        return buf;
+    }
+#endif
+    case number_type:    {
+        char buf[256];
+        double tmp;
+        SNPRINTF(buf, sizeof(buf), fabs(u_.number_) < (1ULL << 53) && modf(u_.number_, &tmp) == 0 ? "%.f" : "%.17g", u_.number_);
+#if PICOJSON_USE_LOCALE
+        char *decimal_point = localeconv()->decimal_point;
+        if (strcmp(decimal_point, ".") != 0) {
+            size_t decimal_point_len = strlen(decimal_point);
+            for (char *p = buf; *p != '\0'; ++p) {
+                if (strncmp(p, decimal_point, decimal_point_len) == 0) {
+                    return std::string(buf, p) + "." + (p + decimal_point_len);
+                }
+            }
+        }
+#endif
+        return buf;
+    }
+    case string_type:    return *u_.string_;
+    case array_type:     return "array";
+    case object_type:    return "object";
+    default:             PICOJSON_ASSERT("value::to_str() assert failed." && 0);
+#ifdef _MSC_VER
+        __assume(0);
+#endif
+    }
+}
+
+template <typename Iter> void copy(const std::string& s, Iter oi) {
+    std::copy(s.begin(), s.end(), oi);
+}
+
+template <typename Iter> void serialize_str(const std::string& s, Iter oi) {
+    *oi++ = '"';
+    for (std::string::const_iterator i = s.begin(); i != s.end(); ++i) {
+        switch (*i) {
+#define MAP(val, sym) case val: copy(sym, oi); break
+        MAP('"', "\\\"");
+        MAP('\\', "\\\\");
+        MAP('/', "\\/");
+        MAP('\b', "\\b");
+        MAP('\f', "\\f");
+        MAP('\n', "\\n");
+        MAP('\r', "\\r");
+        MAP('\t', "\\t");
+#undef MAP
+        default:
+            if (static_cast<unsigned char>(*i) < 0x20 || *i == 0x7f) {
+                char buf[7];
+                SNPRINTF(buf, sizeof(buf), "\\u%04x", *i & 0xff);
+                copy(buf, buf + 6, oi);
+            } else {
+                *oi++ = *i;
+            }
+            break;
+        }
+    }
+    *oi++ = '"';
+}
+
+template <typename Iter> void value::serialize(Iter oi, bool prettify) const {
+    return serialize_(oi, prettify ? 0 : -1);
+}
+
+inline std::string value::serialize(bool prettify) const {
+    return serialize_(prettify ? 0 : -1);
+}
+
+template <typename Iter> void value::_indent(Iter oi, int indent) {
+    *oi++ = '\n';
+    for (int i = 0; i < indent * INDENT_WIDTH; ++i) {
+        *oi++ = ' ';
+    }
+}
+
+template <typename Iter> void value::serialize_(Iter oi, int indent) const {
+    switch (type_) {
+    case string_type:
+        serialize_str(*u_.string_, oi);
+        break;
+    case array_type: {
+        *oi++ = '[';
+        if (indent != -1) {
+            ++indent;
+        }
+        for (array::const_iterator i = u_.array_->begin();
+             i != u_.array_->end();
+             ++i) {
+            if (i != u_.array_->begin()) {
+                *oi++ = ',';
+            }
+            if (indent != -1) {
+                _indent(oi, indent);
+            }
+            i->serialize_(oi, indent);
+        }
+        if (indent != -1) {
+            --indent;
+            if (! u_.array_->empty()) {
+                _indent(oi, indent);
+            }
+        }
+        *oi++ = ']';
+        break;
+    }
+    case object_type: {
+        *oi++ = '{';
+        if (indent != -1) {
+            ++indent;
+        }
+        for (object::const_iterator i = u_.object_->begin();
+             i != u_.object_->end();
+             ++i) {
+            if (i != u_.object_->begin()) {
+                *oi++ = ',';
+            }
+            if (indent != -1) {
+                _indent(oi, indent);
+            }
+            serialize_str(i->first, oi);
+            *oi++ = ':';
+            if (indent != -1) {
+                *oi++ = ' ';
+            }
+            i->second.serialize_(oi, indent);
+        }
+        if (indent != -1) {
+            --indent;
+            if (! u_.object_->empty()) {
+                _indent(oi, indent);
+            }
+        }
+        *oi++ = '}';
+        break;
+    }
+    default:
+        copy(to_str(), oi);
+        break;
+    }
+    if (indent == 0) {
+        *oi++ = '\n';
+    }
+}
+
+inline std::string value::serialize_(int indent) const {
+    std::string s;
+    serialize_(std::back_inserter(s), indent);
+    return s;
+}
+
+template <typename Iter> class input {
+protected:
+    Iter cur_, end_;
+    int last_ch_;
+    bool ungot_;
+    int line_;
+public:
+    input(const Iter& first, const Iter& last) : cur_(first), end_(last), last_ch_(-1), ungot_(false), line_(1) {}
+    int getc() {
+        if (ungot_) {
+            ungot_ = false;
+            return last_ch_;
+        }
+        if (cur_ == end_) {
+            last_ch_ = -1;
+            return -1;
+        }
+        if (last_ch_ == '\n') {
+            line_++;
+        }
+        last_ch_ = *cur_ & 0xff;
+        ++cur_;
+        return last_ch_;
+    }
+    void ungetc() {
+        if (last_ch_ != -1) {
+            PICOJSON_ASSERT(! ungot_);
+            ungot_ = true;
+        }
+    }
+    Iter cur() const { return cur_; }
+    int line() const { return line_; }
+    void skip_ws() {
+        while (1) {
+            int ch = getc();
+            if (! (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r')) {
+                ungetc();
+                break;
+            }
+        }
+    }
+    bool expect(int expect) {
+        skip_ws();
+        if (getc() != expect) {
+            ungetc();
+            return false;
+        }
+        return true;
+    }
+    bool match(const std::string& pattern) {
+        for (std::string::const_iterator pi(pattern.begin());
+             pi != pattern.end();
+             ++pi) {
+            if (getc() != *pi) {
+                ungetc();
+                return false;
+            }
+        }
+        return true;
+    }
+};
+
+template<typename Iter> inline int _parse_quadhex(input<Iter> &in) {
+    int uni_ch = 0, hex;
+    for (int i = 0; i < 4; i++) {
+        if ((hex = in.getc()) == -1) {
+            return -1;
+        }
+        if ('0' <= hex && hex <= '9') {
+            hex -= '0';
+        } else if ('A' <= hex && hex <= 'F') {
+            hex -= 'A' - 0xa;
+        } else if ('a' <= hex && hex <= 'f') {
+            hex -= 'a' - 0xa;
+        } else {
+            in.ungetc();
+            return -1;
+        }
+        uni_ch = uni_ch * 16 + hex;
+    }
+    return uni_ch;
+}
+
+template<typename String, typename Iter> inline bool _parse_codepoint(String& out, input<Iter>& in) {
+    int uni_ch;
+    if ((uni_ch = _parse_quadhex(in)) == -1) {
+        return false;
+    }
+    if (0xd800 <= uni_ch && uni_ch <= 0xdfff) {
+        if (0xdc00 <= uni_ch) {
+            // a second 16-bit of a surrogate pair appeared
+            return false;
+        }
+        // first 16-bit of surrogate pair, get the next one
+        if (in.getc() != '\\' || in.getc() != 'u') {
+            in.ungetc();
+            return false;
+        }
+        int second = _parse_quadhex(in);
+        if (! (0xdc00 <= second && second <= 0xdfff)) {
+            return false;
+        }
+        uni_ch = ((uni_ch - 0xd800) << 10) | ((second - 0xdc00) & 0x3ff);
+        uni_ch += 0x10000;
+    }
+    if (uni_ch < 0x80) {
+        out.push_back(uni_ch);
+    } else {
+        if (uni_ch < 0x800) {
+            out.push_back(0xc0 | (uni_ch >> 6));
+        } else {
+            if (uni_ch < 0x10000) {
+                out.push_back(0xe0 | (uni_ch >> 12));
+            } else {
+                out.push_back(0xf0 | (uni_ch >> 18));
+                out.push_back(0x80 | ((uni_ch >> 12) & 0x3f));
+            }
+            out.push_back(0x80 | ((uni_ch >> 6) & 0x3f));
+        }
+        out.push_back(0x80 | (uni_ch & 0x3f));
+    }
+    return true;
+}
+
+template<typename String, typename Iter> inline bool _parse_string(String& out, input<Iter>& in, int delim='"') {
+    while (1) {
+        int ch = in.getc();
+        if (ch < ' ') {
+            in.ungetc();
+            return false;
+        } else if (ch == delim) {
+            return true;
+        } else if (ch == '\\') {
+            if ((ch = in.getc()) == -1) {
+                return false;
+            }
+            switch (ch) {
+#define MAP(sym, val) case sym: out.push_back(val); break
+            MAP('"', '\"');
+            MAP('\\', '\\');
+            MAP('/', '/');
+            MAP('b', '\b');
+            MAP('f', '\f');
+            MAP('n', '\n');
+            MAP('r', '\r');
+            MAP('t', '\t');
+#undef MAP
+            case 'u':
+                if (! _parse_codepoint(out, in)) {
+                    return false;
+                }
+                break;
+            default:
+                return false;
+            }
+        } else {
+            out.push_back(ch);
+        }
+    }
+}
+
+template <typename Context, typename Iter> inline bool _parse_array(Context& ctx, input<Iter>& in) {
+    if (! ctx.parse_array_start()) {
+        return false;
+    }
+    size_t idx = 0;
+    if (in.expect(']')) {
+        return ctx.parse_array_stop(idx);
+    }
+    do {
+        if (! ctx.parse_array_item(in, idx)) {
+            return false;
+        }
+        idx++;
+    } while (in.expect(','));
+    return in.expect(']') && ctx.parse_array_stop(idx);
+}
+
+template <typename Context, typename Iter> inline bool _parse_object(Context& ctx, input<Iter>& in) {
+    if (! ctx.parse_object_start()) {
+        return false;
+    }
+    if (in.expect('}')) {
+        return true;
+    }
+    do {
+        std::string key;
+        // Support " and ' delimited strings
+        if( in.expect('"') ) {
+            if( !_parse_string(key, in, '"') )
+                return false;
+        }else if (!in.expect('\'') || !_parse_string(key, in,'\'')  ) {
+            return false;
+        }
+        if (!in.expect(':') || !ctx.parse_object_item(in, key)) {
+            return false;
+        }
+    } while (in.expect(','));
+    return in.expect('}');
+}
+
+template <typename Iter> inline std::string _parse_number(input<Iter>& in) {
+    std::string num_str;
+    while (1) {
+        int ch = in.getc();
+        if (('0' <= ch && ch <= '9') || ch == '+' || ch == '-'
+                || ch == 'e' || ch == 'E') {
+            num_str.push_back(ch);
+        } else if (ch == '.') {
+#if PICOJSON_USE_LOCALE
+            num_str += localeconv()->decimal_point;
+#else
+            num_str.push_back('.');
+#endif
+        } else {
+            in.ungetc();
+            break;
+        }
+    }
+    return num_str;
+}
+
+template <typename Context, typename Iter> inline bool _parse(Context& ctx, input<Iter>& in) {
+    in.skip_ws();
+    int ch = in.getc();
+    switch (ch) {
+#define IS(ch, text, op) case ch: \
+    if (in.match(text) && op) { \
+    return true; \
+    } else { \
+    return false; \
+    }
+    IS('n', "ull", ctx.set_null());
+    IS('f', "alse", ctx.set_bool(false));
+    IS('t', "rue", ctx.set_bool(true));
+#undef IS
+    case '"':
+        return ctx.parse_string(in);
+    case '[':
+        return _parse_array(ctx, in);
+    case '{':
+        return _parse_object(ctx, in);
+    default:
+        if (('0' <= ch && ch <= '9') || ch == '-') {
+            double f;
+            char *endp;
+            in.ungetc();
+            std::string num_str = _parse_number(in);
+            if (num_str.empty()) {
+                return false;
+            }
+#ifdef PICOJSON_USE_INT64
+            {
+                errno = 0;
+                intmax_t ival = strtoimax(num_str.c_str(), &endp, 10);
+                if (errno == 0
+                        && std::numeric_limits<int64_t>::min() <= ival
+                        && ival <= std::numeric_limits<int64_t>::max()
+                        && endp == num_str.c_str() + num_str.size()) {
+                    ctx.set_int64(ival);
+                    return true;
+                }
+            }
+#endif
+            f = strtod(num_str.c_str(), &endp);
+            if (endp == num_str.c_str() + num_str.size()) {
+                ctx.set_number(f);
+                return true;
+            }
+            return false;
+        }
+        break;
+    }
+    in.ungetc();
+    return false;
+}
+
+class deny_parse_context {
+public:
+    bool set_null() { return false; }
+    bool set_bool(bool) { return false; }
+#ifdef PICOJSON_USE_INT64
+    bool set_int64(int64_t) { return false; }
+#endif
+    bool set_number(double) { return false; }
+    template <typename Iter> bool parse_string(input<Iter>&) { return false; }
+    bool parse_array_start() { return false; }
+    template <typename Iter> bool parse_array_item(input<Iter>&, size_t) {
+        return false;
+    }
+    bool parse_array_stop(size_t) { return false; }
+    bool parse_object_start() { return false; }
+    template <typename Iter> bool parse_object_item(input<Iter>&, const std::string&) {
+        return false;
+    }
+};
+
+class default_parse_context {
+protected:
+    value* out_;
+public:
+    default_parse_context(value* out) : out_(out) {}
+    bool set_null() {
+        *out_ = value();
+        return true;
+    }
+    bool set_bool(bool b) {
+        *out_ = value(b);
+        return true;
+    }
+#ifdef PICOJSON_USE_INT64
+    bool set_int64(int64_t i) {
+        *out_ = value(i);
+        return true;
+    }
+#endif
+    bool set_number(double f) {
+        *out_ = value(f);
+        return true;
+    }
+    template<typename Iter> bool parse_string(input<Iter>& in) {
+        *out_ = value(string_type, false);
+        return _parse_string(out_->get<std::string>(), in);
+    }
+    bool parse_array_start() {
+        *out_ = value(array_type, false);
+        return true;
+    }
+    template <typename Iter> bool parse_array_item(input<Iter>& in, size_t) {
+        array& a = out_->get<array>();
+        a.push_back(value());
+        default_parse_context ctx(&a.back());
+        return _parse(ctx, in);
+    }
+    bool parse_array_stop(size_t) { return true; }
+    bool parse_object_start() {
+        *out_ = value(object_type, false);
+        return true;
+    }
+    template <typename Iter> bool parse_object_item(input<Iter>& in, const std::string& key) {
+        object& o = out_->get<object>();
+        default_parse_context ctx(&o[key]);
+        return _parse(ctx, in);
+    }
+private:
+    default_parse_context(const default_parse_context&);
+    default_parse_context& operator=(const default_parse_context&);
+};
+
+class null_parse_context {
+public:
+    struct dummy_str {
+        void push_back(int) {}
+    };
+public:
+    null_parse_context() {}
+    bool set_null() { return true; }
+    bool set_bool(bool) { return true; }
+#ifdef PICOJSON_USE_INT64
+    bool set_int64(int64_t) { return true; }
+#endif
+    bool set_number(double) { return true; }
+    template <typename Iter> bool parse_string(input<Iter>& in) {
+        dummy_str s;
+        return _parse_string(s, in);
+    }
+    bool parse_array_start() { return true; }
+    template <typename Iter> bool parse_array_item(input<Iter>& in, size_t) {
+        return _parse(*this, in);
+    }
+    bool parse_array_stop(size_t) { return true; }
+    bool parse_object_start() { return true; }
+    template <typename Iter> bool parse_object_item(input<Iter>& in, const std::string&) {
+        return _parse(*this, in);
+    }
+private:
+    null_parse_context(const null_parse_context&);
+    null_parse_context& operator=(const null_parse_context&);
+};
+
+// obsolete, use the version below
+template <typename Iter> inline std::string parse(value& out, Iter& pos, const Iter& last) {
+    std::string err;
+    pos = parse(out, pos, last, &err);
+    return err;
+}
+
+template <typename Context, typename Iter> inline Iter _parse(Context& ctx, const Iter& first, const Iter& last, std::string* err) {
+    input<Iter> in(first, last);
+    if (! _parse(ctx, in) && err != NULL) {
+        char buf[64];
+        SNPRINTF(buf, sizeof(buf), "syntax error at line %d near: ", in.line());
+        *err = buf;
+        while (1) {
+            int ch = in.getc();
+            if (ch == -1 || ch == '\n') {
+                break;
+            } else if (ch >= ' ') {
+                err->push_back(ch);
+            }
+        }
+    }
+    return in.cur();
+}
+
+template <typename Iter> inline Iter parse(value& out, const Iter& first, const Iter& last, std::string* err) {
+    default_parse_context ctx(&out);
+    return _parse(ctx, first, last, err);
+}
+
+inline std::string parse(value &out, const std::string &s) {
+  std::string err;
+  parse(out, s.begin(), s.end(), &err);
+  return err;
+}
+
+inline std::string parse(value& out, std::istream& is) {
+    std::string err;
+    parse(out, std::istreambuf_iterator<char>(is.rdbuf()),
+          std::istreambuf_iterator<char>(), &err);
+    return err;
+}
+
+template <typename T> struct last_error_t {
+    static std::string s;
+};
+template <typename T> std::string last_error_t<T>::s;
+
+inline void set_last_error(const std::string& s) {
+    last_error_t<bool>::s = s;
+}
+
+inline const std::string& get_last_error() {
+    return last_error_t<bool>::s;
+}
+
+inline bool operator==(const value& x, const value& y) {
+    if (x.is<null>())
+        return y.is<null>();
+#define PICOJSON_CMP(type)					\
+    if (x.is<type>())						\
+    return y.is<type>() && x.get<type>() == y.get<type>()
+    PICOJSON_CMP(bool);
+    PICOJSON_CMP(double);
+    PICOJSON_CMP(std::string);
+    PICOJSON_CMP(array);
+    PICOJSON_CMP(object);
+#undef PICOJSON_CMP
+    PICOJSON_ASSERT(0);
+#ifdef _MSC_VER
+    __assume(0);
+#endif
+}
+
+inline bool operator!=(const value& x, const value& y) {
+    return ! (x == y);
+}
+
+} // namespace json
+
+inline std::istream& operator>>(std::istream& is, picojson::value& x)
+{
+    picojson::set_last_error(std::string());
+    std::string err = picojson::parse(x, is);
+    if (! err.empty()) {
+        picojson::set_last_error(err);
+        is.setstate(std::ios::failbit);
+    }
+    return is;
+}
+
+inline std::ostream& operator<<(std::ostream& os, const picojson::value& x)
+{
+    x.serialize(std::ostream_iterator<char>(os));
+    return os;
+}
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif // _MSC_VER
+
+#endif // picojson_h
+
+
+
+
+#ifdef TEST_PICOJSON
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4127) // conditional expression is constant
+#endif // _MSC_VER
+
+using namespace std;
+
+static bool success = true;
+static int test_num = 0;
+
+static void ok(bool b, const char* name = "")
+{
+    if (! b)
+        success = false;
+    printf("%s %d - %s\n", b ? "ok" : "ng", ++test_num, name);
+}
+
+static void done_testing()
+{
+    printf("1..%d\n", test_num);
+}
+
+template <typename T> void is(const T& x, const T& y, const char* name = "")
+{
+    if (x == y) {
+        ok(true, name);
+    } else {
+        ok(false, name);
+    }
+}
+
+#include <algorithm>
+#include <sstream>
+#include <float.h>
+#include <limits.h>
+
+int main(void)
+{
+#if PICOJSON_USE_LOCALE
+    setlocale(LC_ALL, "");
+#endif // PICOJSON_USE_LOCALE
+
+    // constructors
+#define TEST(expr, expected) \
+    is(picojson::value expr .serialize(), string(expected), "picojson::value" #expr)
+
+    TEST( (true),  "true");
+    TEST( (false), "false");
+    TEST( (42.0),   "42");
+    TEST( (string("hello")), "\"hello\"");
+    TEST( ("hello"), "\"hello\"");
+    TEST( ("hello", 4), "\"hell\"");
+
+    {
+        double a = 1;
+        for (int i = 0; i < 1024; i++) {
+            picojson::value vi(a);
+            std::stringstream ss;
+            ss << vi;
+            picojson::value vo;
+            ss >> vo;
+            double b = vo.get<double>();
+            if ((i < 53 && a != b) || fabs(a - b) / b > 1e-8) {
+                printf("ng i=%d a=%.18e b=%.18e\n", i, a, b);
+            }
+            a *= 2;
+        }
+    }
+
+#undef TEST
+
+#define TEST(in, type, cmp, serialize_test) {				\
+    picojson::value v;							\
+    const char* s = in;							\
+    string err = picojson::parse(v, s, s + strlen(s));			\
+    ok(err.empty(), in " no error");					\
+    ok(v.is<type>(), in " check type");					\
+    is<type>(v.get<type>(), cmp, in " correct output");			\
+    is(*s, '\0', in " read to eof");					\
+    if (serialize_test) {						\
+    is(v.serialize(), string(in), in " serialize");			\
+}									\
+}
+    TEST("false", bool, false, true);
+    TEST("true", bool, true, true);
+    TEST("90.5", double, 90.5, false);
+    TEST("1.7976931348623157e+308", double, DBL_MAX, false);
+    TEST("\"hello\"", string, string("hello"), true);
+    TEST("\"\\\"\\\\\\/\\b\\f\\n\\r\\t\"", string, string("\"\\/\b\f\n\r\t"),
+         true);
+    TEST("\"\\u0061\\u30af\\u30ea\\u30b9\"", string,
+         string("a\xe3\x82\xaf\xe3\x83\xaa\xe3\x82\xb9"), false);
+    TEST("\"\\ud840\\udc0b\"", string, string("\xf0\xa0\x80\x8b"), false);
+#ifdef PICOJSON_USE_INT64
+    TEST("0", int64_t, 0, true);
+    TEST("-9223372036854775808", int64_t, std::numeric_limits<int64_t>::min(), true);
+    TEST("9223372036854775807", int64_t, std::numeric_limits<int64_t>::max(), true);
+#endif // PICOJSON_USE_INT64
+
+#undef TEST
+
+#define TEST(type, expr) {					       \
+    picojson::value v;						       \
+    const char *s = expr;					       \
+    string err = picojson::parse(v, s, s + strlen(s));		       \
+    ok(err.empty(), "empty " #type " no error");		       \
+    ok(v.is<picojson::type>(), "empty " #type " check type");	       \
+    ok(v.get<picojson::type>().empty(), "check " #type " array size"); \
+}
+    TEST(array, "[]");
+    TEST(object, "{}");
+#undef TEST
+
+    {
+        picojson::value v;
+        const char *s = "[1,true,\"hello\"]";
+        string err = picojson::parse(v, s, s + strlen(s));
+        ok(err.empty(), "array no error");
+        ok(v.is<picojson::array>(), "array check type");
+        is(v.get<picojson::array>().size(), size_t(3), "check array size");
+        ok(v.contains(0), "check contains array[0]");
+        ok(v.get(0).is<double>(), "check array[0] type");
+        is(v.get(0).get<double>(), 1.0, "check array[0] value");
+        ok(v.contains(1), "check contains array[1]");
+        ok(v.get(1).is<bool>(), "check array[1] type");
+        ok(v.get(1).get<bool>(), "check array[1] value");
+        ok(v.contains(2), "check contains array[2]");
+        ok(v.get(2).is<string>(), "check array[2] type");
+        is(v.get(2).get<string>(), string("hello"), "check array[2] value");
+        ok(!v.contains(3), "check not contains array[3]");
+    }
+
+    {
+        picojson::value v;
+        const char *s = "{ \"a\": true }";
+        string err = picojson::parse(v, s, s + strlen(s));
+        ok(err.empty(), "object no error");
+        ok(v.is<picojson::object>(), "object check type");
+        is(v.get<picojson::object>().size(), size_t(1), "check object size");
+        ok(v.contains("a"), "check contains property");
+        ok(v.get("a").is<bool>(), "check bool property exists");
+        is(v.get("a").get<bool>(), true, "check bool property value");
+        is(v.serialize(), string("{\"a\":true}"), "serialize object");
+        ok(!v.contains("z"), "check not contains property");
+    }
+
+#define TEST(json, msg) do {				\
+    picojson::value v;					\
+    const char *s = json;				\
+    string err = picojson::parse(v, s, s + strlen(s));	\
+    is(err, string("syntax error at line " msg), msg);	\
+} while (0)
+    TEST("falsoa", "1 near: oa");
+    TEST("{]", "1 near: ]");
+    TEST("\n\bbell", "2 near: bell");
+    TEST("\"abc\nd\"", "1 near: ");
+#undef TEST
+
+    {
+        picojson::value v1, v2;
+        const char *s;
+        string err;
+        s = "{ \"b\": true, \"a\": [1,2,\"three\"], \"d\": 2 }";
+        err = picojson::parse(v1, s, s + strlen(s));
+        s = "{ \"d\": 2.0, \"b\": true, \"a\": [1,2,\"three\"] }";
+        err = picojson::parse(v2, s, s + strlen(s));
+        ok((v1 == v2), "check == operator in deep comparison");
+    }
+
+    {
+        picojson::value v1, v2;
+        const char *s;
+        string err;
+        s = "{ \"b\": true, \"a\": [1,2,\"three\"], \"d\": 2 }";
+        err = picojson::parse(v1, s, s + strlen(s));
+        s = "{ \"d\": 2.0, \"a\": [1,\"three\"], \"b\": true }";
+        err = picojson::parse(v2, s, s + strlen(s));
+        ok((v1 != v2), "check != operator for array in deep comparison");
+    }
+
+    {
+        picojson::value v1, v2;
+        const char *s;
+        string err;
+        s = "{ \"b\": true, \"a\": [1,2,\"three\"], \"d\": 2 }";
+        err = picojson::parse(v1, s, s + strlen(s));
+        s = "{ \"d\": 2.0, \"a\": [1,2,\"three\"], \"b\": false }";
+        err = picojson::parse(v2, s, s + strlen(s));
+        ok((v1 != v2), "check != operator for object in deep comparison");
+    }
+
+    {
+        picojson::value v1, v2;
+        const char *s;
+        string err;
+        s = "{ \"b\": true, \"a\": [1,2,\"three\"], \"d\": 2 }";
+        err = picojson::parse(v1, s, s + strlen(s));
+        picojson::object& o = v1.get<picojson::object>();
+        o.erase("b");
+        picojson::array& a = o["a"].get<picojson::array>();
+        picojson::array::iterator i;
+        i = std::remove(a.begin(), a.end(), picojson::value(std::string("three")));
+        a.erase(i, a.end());
+        s = "{ \"a\": [1,2], \"d\": 2 }";
+        err = picojson::parse(v2, s, s + strlen(s));
+        ok((v1 == v2), "check erase()");
+    }
+
+    ok(picojson::value(3.0).serialize() == "3",
+       "integral number should be serialized as a integer");
+
+    {
+        const char* s = "{ \"a\": [1,2], \"d\": 2 }";
+        picojson::null_parse_context ctx;
+        string err;
+        picojson::_parse(ctx, s, s + strlen(s), &err);
+        ok(err.empty(), "null_parse_context");
+    }
+
+    {
+        picojson::value v;
+        const char *s = "{ \"a\": 1, \"b\": [ 2, { \"b1\": \"abc\" } ], \"c\": {}, \"d\": [] }";
+        string err;
+        err = picojson::parse(v, s, s + strlen(s));
+        ok(err.empty(), "parse test data for prettifying output");
+        ok(v.serialize() == "{\"a\":1,\"b\":[2,{\"b1\":\"abc\"}],\"c\":{},\"d\":[]}", "non-prettifying output");
+        ok(v.serialize(true) == "{\n  \"a\": 1,\n  \"b\": [\n    2,\n    {\n      \"b1\": \"abc\"\n    }\n  ],\n  \"c\": {},\n  \"d\": []\n}\n", "prettifying output");
+    }
+
+    try {
+        picojson::value v(std::numeric_limits<double>::quiet_NaN());
+        ok(false, "should not accept NaN");
+    } catch (std::overflow_error e) {
+        ok(true, "should not accept NaN");
+    }
+
+    try {
+        picojson::value v(std::numeric_limits<double>::infinity());
+        ok(false, "should not accept infinity");
+    } catch (std::overflow_error e) {
+        ok(true, "should not accept infinity");
+    }
+
+    try {
+        picojson::value v(123.);
+        ok(! v.is<bool>(), "is<wrong_type>() should return false");
+        v.get<bool>();
+        ok(false, "get<wrong_type>() should raise an error");
+    } catch (std::runtime_error e) {
+        ok(true, "get<wrong_type>() should raise an error");
+    }
+
+#ifdef PICOJSON_USE_INT64
+    {
+        picojson::value v1((int64_t)123);
+        ok(v1.is<int64_t>(), "is int64_t");
+        ok(v1.is<double>(), "is double as well");
+        ok(v1.serialize() == "123", "serialize the value");
+        ok(v1.get<int64_t>() == 123, "value is correct as int64_t");
+        ok(v1.get<double>(), "value is correct as double");
+
+        ok(! v1.is<int64_t>(), "is no more int64_type once get<double>() is called");
+        ok(v1.is<double>(), "and is still a double");
+
+        const char *s = "-9223372036854775809";
+        ok(picojson::parse(v1, s, s + strlen(s)).empty(), "parse underflowing int64_t");
+        ok(! v1.is<int64_t>(), "underflowing int is not int64_t");
+        ok(v1.is<double>(), "underflowing int is double");
+        ok(v1.get<double>() + 9.22337203685478e+18 < 65536, "double value is somewhat correct");
+    }
+#endif // PICOJSON_USE_INT64
+
+    done_testing();
+
+    return success ? 0 : 1;
+}
+
+#endif // TEST_PICOJSON

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/posix/condition_variable.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <pangolin/utils/timer.h>
+
+#include <memory>
+
+namespace pangolin
+{
+
+class ConditionVariableInterface
+{
+public:
+  virtual ~ConditionVariableInterface()
+  {
+  }
+
+  virtual void wait() = 0;
+  virtual bool wait(timespec t) = 0;
+  virtual void signal() = 0;
+  virtual void broadcast() = 0;
+};
+
+std::shared_ptr<ConditionVariableInterface> create_named_condition_variable(const
+  std::string& name);
+std::shared_ptr<ConditionVariableInterface> open_named_condition_variable(const
+  std::string& name);
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/posix/semaphore.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <memory>
+
+#include <string>
+
+namespace pangolin
+{
+
+  class SemaphoreInterface
+  {
+  public:
+
+    virtual ~SemaphoreInterface() {
+    }
+
+    virtual bool tryAcquire() = 0;
+    virtual void acquire() = 0;
+    virtual void release() = 0;
+  };
+
+  std::shared_ptr<SemaphoreInterface> create_named_semaphore(const std::string& name,
+    unsigned int value);
+  std::shared_ptr<SemaphoreInterface> open_named_semaphore(const std::string& name);
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/posix/shared_memory_buffer.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <memory>
+
+#include <string>
+
+namespace pangolin
+{
+  class SharedMemoryBufferInterface
+  {
+  public:
+    virtual ~SharedMemoryBufferInterface() {
+    }
+    virtual bool tryLock() = 0;
+    virtual void lock() = 0;
+    virtual void unlock() = 0;
+    virtual unsigned char *ptr() = 0;
+    virtual std::string name() = 0;
+  };
+
+  std::shared_ptr<SharedMemoryBufferInterface> create_named_shared_memory_buffer(const
+    std::string& name, size_t size);
+  std::shared_ptr<SharedMemoryBufferInterface> open_named_shared_memory_buffer(const
+    std::string& name, bool readwrite);
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/range.h

@@ -0,0 +1,372 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/platform.h>
+
+#include <limits>
+#include <algorithm>
+#include <cmath>
+
+//prevent including Eigen in cuda files
+#if defined(HAVE_EIGEN) && !defined(__CUDACC__)
+#  define USE_EIGEN
+#endif
+
+#ifdef USE_EIGEN
+#  include <Eigen/Core>
+#  include <Eigen/Geometry>
+#endif // USE_EIGEN
+
+namespace pangolin
+{
+
+
+template<typename T>
+struct Range
+{
+    static Range<T> Open()
+    {
+        return Range<T>(std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max());
+    }
+
+    static Range<T> Empty()
+    {
+        return Range<T>(std::numeric_limits<T>::max(), std::numeric_limits<T>::lowest());
+    }
+
+    static Range<T> Containing(T val)
+    {
+        return Range<T>(val, val);
+    }
+
+    Range()
+        : min(+std::numeric_limits<T>::max()),
+          max(-std::numeric_limits<T>::max())
+    {
+    }
+
+    Range(T rmin, T rmax)
+        : min(rmin), max(rmax)
+    {
+    }
+
+    Range operator+(T v)
+    {
+        return Range(min+v, max+v);
+    }
+
+    Range operator-(T v)
+    {
+        return Range(min-v, max-v);
+    }
+
+    Range& operator+=(T v)
+    {
+        min += v;
+        max += v;
+        return *this;
+    }
+
+    Range& operator-=(T v)
+    {
+        min -= v;
+        max -= v;
+        return *this;
+    }
+
+    Range& operator*=(T v)
+    {
+        min *= v;
+        max *= v;
+        return *this;
+    }
+
+    Range& operator/=(T v)
+    {
+        min /= v;
+        max /= v;
+        return *this;
+    }
+
+    Range& operator+=(const Range& o)
+    {
+        min += o.min;
+        max += o.max;
+        return *this;
+    }
+
+    Range& operator-=(const Range& o)
+    {
+        min -= o.min;
+        max -= o.max;
+        return *this;
+    }
+
+    Range operator+(const Range& o) const
+    {
+        return Range(min + o.min, max + o.max);
+    }
+
+    Range operator-(const Range& o) const
+    {
+        return Range(min - o.min, max - o.max);
+    }
+
+    Range operator*(float s) const
+    {
+        return Range(T(s*min), T(s*max));
+    }
+
+    T Size() const
+    {
+        return max - min;
+    }
+
+    T AbsSize() const
+    {
+        return std::abs(Size());
+    }
+
+    T Mid() const
+    {
+        return (min + max) / (T)2.0f;
+    }
+
+    void Scale(float s, float center = 0.0f)
+    {
+        min = T(s*(min-center) + center);
+        max = T(s*(max-center) + center);
+    }
+
+    void Insert(T v)
+    {
+        min = std::min(min,v);
+        max = std::max(max,v);
+    }
+
+    void Insert(const Range<T>& r)
+    {
+        Insert(r.min);
+        Insert(r.max);
+    }
+
+    void Clamp(T vmin, T vmax)
+    {
+        min = std::min(std::max(vmin, min), vmax);
+        max = std::min(std::max(vmin, max), vmax);
+    }
+
+    void Clamp(const Range& o)
+    {
+        Clamp(o.min, o.max);
+    }
+
+    void Clear()
+    {
+        min = std::numeric_limits<T>::max();
+        max = std::numeric_limits<T>::lowest();
+    }
+
+    bool Contains(T v) const
+    {
+        return min <= v && v <= max;
+    }
+
+    bool ContainsWeak(T v) const
+    {
+        return (min <= v && v <= max)
+            || (max <= v && v <= min);
+    }
+
+    template<typename To>
+    Range<To> Cast() const
+    {
+        return Range<To>(To(min), To(max));
+    }
+
+    T min;
+    T max;
+};
+
+template<typename T>
+struct XYRange
+{
+    static XYRange<T> Open()
+    {
+        return XYRange<T>(
+            Range<T>(std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max()),
+            Range<T>(std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max())
+        );
+    }
+
+    static XYRange<T> Empty()
+    {
+        return XYRange<T>(
+            Range<T>(std::numeric_limits<T>::max(), std::numeric_limits<T>::lowest()),
+            Range<T>(std::numeric_limits<T>::max(), std::numeric_limits<T>::lowest())
+        );
+    }
+
+    static XYRange<T> Containing(T x, T y)
+    {
+        return XYRange<T>(
+            Range<T>(x, x),
+            Range<T>(y, y)
+        );
+    }
+
+    XYRange()
+    {
+    }
+
+    XYRange(const Range<T>& xrange, const Range<T>& yrange)
+        : x(xrange), y(yrange)
+    {
+    }
+
+    XYRange(T xmin, T xmax, T ymin, T ymax)
+        : x(xmin,xmax), y(ymin,ymax)
+    {
+    }
+
+    XYRange operator-(const XYRange& o) const
+    {
+        return XYRange(x - o.x, y - o.y);
+    }
+
+    XYRange operator*(float s) const
+    {
+        return XYRange(x*s, y*s);
+    }
+
+    XYRange& operator+=(const XYRange& o)
+    {
+        x += o.x;
+        y += o.y;
+        return *this;
+    }
+
+    void Scale(float sx, float sy, float centerx, float centery)
+    {
+        x.Scale(sx, centerx);
+        y.Scale(sy, centery);
+    }
+
+    void Clear()
+    {
+        x.Clear();
+        y.Clear();
+    }
+
+    void Clamp(T xmin, T xmax, T ymin, T ymax)
+    {
+        x.Clamp(xmin,xmax);
+        y.Clamp(ymin,ymax);
+    }
+
+    void Clamp(const XYRange& o)
+    {
+        x.Clamp(o.x);
+        y.Clamp(o.y);
+    }
+
+    void Insert(T xval, T yval)
+    {
+        x.Insert(xval);
+        y.Insert(yval);
+    }
+
+    void Insert(XYRange<T> r)
+    {
+        x.Insert(r.x);
+        y.Insert(r.y);
+    }
+
+    float Area() const
+    {
+        return x.Size() * y.Size();
+    }
+
+    bool Contains(float px, float py) const
+    {
+        return x.Contains(px) && y.Contains(py);
+    }
+
+    bool ContainsWeak(float px, float py) const
+    {
+        return x.ContainsWeak(px) && y.ContainsWeak(py);
+    }
+
+    template<typename To>
+    XYRange<To> Cast() const
+    {
+        return XYRange<To>(
+            x.template Cast<To>(),
+            y.template Cast<To>()
+        );
+    }
+
+#ifdef USE_EIGEN
+    operator Eigen::AlignedBox<T,2>() const {
+        return Eigen::AlignedBox<T,2>(
+            Eigen::Matrix<T,2,1>(x.min, y.min),
+            Eigen::Matrix<T,2,1>(x.max, y.max)
+        );
+    }
+
+    Eigen::Matrix<T,2,1> Center() const {
+        return Eigen::Matrix<T,2,1>(x.Mid(), y.Mid());
+    }
+#endif
+
+    Range<T> x;
+    Range<T> y;
+};
+
+typedef Range<int> Rangei;
+typedef Range<float> Rangef;
+typedef Range<double> Ranged;
+
+typedef XYRange<int> XYRangei;
+typedef XYRange<float> XYRangef;
+typedef XYRange<double> XYRanged;
+
+template<typename T> inline
+Rangei Round(const Range<T>& r)
+{
+    return Rangei( int(r.min+0.5), int(r.max+0.5) );
+}
+
+template<typename T> inline
+XYRangei Round(const XYRange<T>& r)
+{
+    return XYRangei( Round(r.x), Round(r.y) );
+}
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/signal_slot.h

@@ -0,0 +1,4 @@
+#pragma once
+
+#include <sigslot/signal.hpp>
+

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/sigstate.h

@@ -0,0 +1,75 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <map>
+#include <vector>
+#include <pangolin/platform.h>
+#include <pangolin/utils/file_utils.h>
+#include <csignal>
+
+#ifndef SIGPIPE
+#  define SIGPIPE 13
+#endif // !SIGPIPE
+
+namespace pangolin
+{
+
+typedef void (*SigCallbackFn)(int);
+
+struct PANGOLIN_EXPORT SigCallback
+{
+    SigCallback(const int & sig, SigCallbackFn fn, void* data)
+     : sig(sig), fn(fn), data(data), value(false)
+    {
+        std::signal(sig, fn);
+    }
+
+    int sig;
+    SigCallbackFn fn;
+    void * data;
+    volatile sig_atomic_t value;
+};
+
+class PANGOLIN_EXPORT SigState
+{
+public:
+    static SigState& I();
+
+    SigState();
+    ~SigState();
+
+    void Clear();
+
+    std::map<int, SigCallback> sig_callbacks;
+};
+
+PANGOLIN_EXPORT
+void RegisterNewSigCallback(SigCallbackFn callback, void* data, const int signal);
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/simple_math.h

@@ -0,0 +1,446 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <iostream>
+#include <string.h>
+#include <algorithm>
+#include <stdarg.h>
+#include <cmath>
+
+namespace pangolin
+{
+
+static const double Identity3d[] = {1,0,0, 0,1,0, 0,0,1};
+static const double Zero3d[]     = {0,0,0, 0,0,0, 0,0,0};
+static const double Identity4d[] = {1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1};
+static const double Zero4d[]     = {0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0};
+
+static const float Identity3f[] = {1,0,0, 0,1,0, 0,0,1};
+static const float Zero3f[]     = {0,0,0, 0,0,0, 0,0,0};
+static const float Identity4f[] = {1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1};
+static const float Zero4f[]     = {0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0};
+
+template<int R, int C, typename P>
+void MatPrint(const P m[R*C])
+{
+    for( int r=0; r < R; ++r)
+    {
+        for( int c=0; c < C; ++c )
+            std::cout << m[R*c+r] << " ";
+        std::cout << std::endl;
+    }
+    std::cout << std::endl;
+}
+
+template<int R, int C, typename P>
+void MatPrint(const P m[R*C], std::string name)
+{
+    std::cout << name << " = [" << std::endl;
+    for( int r=0; r < R; ++r)
+    {
+        for( int c=0; c < C; ++c )
+            std::cout << m[R*c+r] << " ";
+        std::cout << std::endl;
+    }
+    std::cout << std::endl << "]" << std::endl;
+}
+
+// Set array using varadic arguments
+template<int R, int C, typename P>
+void MatSet(P m[R*C], ...)
+{
+    va_list ap;
+    va_start(ap,m);
+    for( int i=0; i< R*C; ++i )
+    {
+        *m = (P)va_arg(ap,double);
+        ++m;
+    }
+}
+
+// m = zeroes(N)
+template<int R, int C, typename P>
+void SetZero(P m[R*C] )
+{
+    std::fill_n(m,R*C,0);
+}
+
+// m = identity(N)
+template<int N, typename P>
+void SetIdentity(P m[N*N] )
+{
+    std::fill_n(m,N*N,0);
+    for( int i=0; i< N; ++i )
+        m[N*i+i] = 1;
+}
+
+// mo = m1 * m2
+template<int R, int M, int C, typename P>
+void MatMul(P mo[R*C], const P m1[R*M], const P m2[M*C] )
+{
+    for( int r=0; r < R; ++r)
+        for( int c=0; c < C; ++c )
+        {
+            mo[R*c+r] = 0;
+            for( int m=0; m < M; ++ m) mo[R*c+r] += m1[R*m+r] * m2[M*c+m];
+        }
+}
+
+// mo = m1 * m2 * s
+template<int R, int M, int C, typename P>
+void MatMul(P mo[R*C], const P m1[R*M], const P m2[M*C], P s )
+{
+    for( int r=0; r < R; ++r)
+        for( int c=0; c < C; ++c )
+        {
+            mo[R*c+r] = 0;
+            for( int m=0; m < M; ++ m) mo[R*c+r] += m1[R*m+r] * m2[M*c+m] * s;
+        }
+}
+
+// mo = m1 * transpose(m2)
+template<int R, int M, int C, typename P>
+void MatMulTranspose(P mo[R*C], const P m1[R*M], const P m2[C*M] )
+{
+    for( int r=0; r < R; ++r)
+        for( int c=0; c < C; ++c )
+        {
+            mo[R*c+r] = 0;
+            for( int m=0; m < M; ++ m) mo[R*c+r] += m1[R*m+r] * m2[C*m+c];
+        }
+}
+
+// m = m1 + m2
+template<int R, int C, typename P>
+void MatAdd(P m[R*C], const P m1[R*C], const P m2[R*C])
+{
+    for( int i=0; i< R*C; ++i )
+        m[i] = m1[i] + m2[i];
+}
+
+// m = m1 - m2
+template<int R, int C, typename P>
+void MatSub(P m[R*C], const P m1[R*C], const P m2[R*C])
+{
+    for( int i=0; i< R*C; ++i )
+        m[i] = m1[i] - m2[i];
+}
+
+// m = m1 * scalar
+template<int R, int C, typename P>
+void MatMul(P m[R*C], const P m1[R*C], P scalar)
+{
+    for( int i=0; i< R*C; ++i )
+        m[i] = m1[i] * scalar;
+}
+
+// m = m1 + m2
+template<int R, int C, typename P>
+void MatMul(P m[R*C], P scalar)
+{
+    for( int i=0; i< R*C; ++i )
+        m[i] *= scalar;
+}
+
+template<int N, typename P>
+void MatTranspose(P out[N*N], const P in[N*N] )
+{
+    for( int c=0; c<N; ++c )
+        for( int r=0; r<N; ++r )
+            out[N*c+r] = in[N*r+c];
+}
+
+template<int N, typename P>
+void MatTranspose(P m[N*N] )
+{
+    for( int c=0; c<N; ++c )
+        for( int r=0; r<c; ++r )
+            std::swap<P>(m[N*c+r],m[N*r+c]);
+}
+
+// m = a x b
+template<typename P>
+void VecCross3(P m[3], const P a[3], const P b[3])
+{
+    m[0] = a[1]*b[2] - a[2]*b[1];
+    m[1] = a[2]*b[0] - a[0]*b[2];
+    m[2] = a[0]*b[1] - a[1]*b[0];
+}
+
+// s = skewSymetrixMatrix(v)
+template<typename P>
+void MatSkew(P s[3*3], const P v[3] )
+{
+    s[0] = 0;
+    s[1] = v[2];
+    s[2] = -v[1];
+    s[3] = -v[2];
+    s[4] = 0;
+    s[5] = v[0];
+    s[6] = v[1];
+    s[7] = -v[0];
+    s[8] = 0;
+}
+
+template<int N, typename P>
+void MatOrtho( P m[N*N] )
+{
+    // http://www.euclideanspace.com/maths/algebra/matrix/orthogonal/index.htm
+    P Itimes3[N*N];
+    SetIdentity<N>(Itimes3);
+    MatMul<N,N>(Itimes3,(P)3.0);
+    
+    P mmT[N*N];
+    MatMulTranspose<N,N,N>(mmT,m,m);
+    
+    P _c[N*N];
+    MatSub<N,N>(_c,Itimes3,mmT);
+    P _m[N*N];
+    MatMul<N,N,N>(_m,m,_c,(P)0.5);
+    std::copy(_m,_m+(N*N),m);
+}
+
+template<typename P>
+void Rotation(P R[3*3], P x, P y, P z)
+{
+    P sx = sin(x);
+    P sy = sin(y);
+    P sz = sin(z);
+    P cx = cos(x);
+    P cy = cos(y);
+    P cz = cos(z);
+    //  P cx = sqrt( (P)1.0 - sx * sx);
+    //  P cy = sqrt( (P)1.0 - sy * sy);
+    //  P cz = sqrt( (P)1.0 - sz * sz);
+    R[0] = cy * cz;
+    R[1] = sx * sy * cz + cx * sz;
+    R[2] = -cx * sy * cz + sx * sz;
+    R[3] = -cy * sz;
+    R[4] = -sx * sy * sz + cx * cz;
+    R[5] = cx * sy * sz + sx * cz;
+    R[6] = sy;
+    R[7] = -sx * cy;
+    R[8] = cx * cy;
+}
+
+template<typename P>
+void LieSetIdentity(P T_ba[3*4] )
+{
+    SetIdentity<3>(T_ba);
+    std::fill_n(T_ba+(3*3),3,0);
+}
+
+template<typename P>
+void LieSetRotation(P T_ba[3*4], const P R_ba[3*3] )
+{
+    std::copy(R_ba,R_ba+(3*3),T_ba);
+}
+
+template<typename P>
+void LieSetTranslation(P T_ba[3*4], const P a_b[3] )
+{
+    std::copy(a_b, a_b+3, T_ba+(3*3));
+}
+
+template<typename P>
+void LieSetSE3(P T_ba[3*4], const P R_ba[3*3], const P a_b[3] )
+{
+    LieSetRotation<P>(T_ba,R_ba);
+    LieSetTranslation<P>(T_ba,a_b);
+}
+
+template<typename P>
+void LieGetRotation(P R_ba[3*3], const P T_ba[3*4] )
+{
+    std::copy(T_ba,T_ba+(3*3),R_ba);
+}
+
+template<typename P>
+void LieApplySO3( P out[3], const P R_ba[3*3], const P in[3] )
+{
+    MatMul<3,3,1,P>(out,R_ba,in);
+}
+
+template<typename P>
+void LieApplySE3vec( P x_b[3], const P T_ba[3*4], const P x_a[3] )
+{
+    P rot[3];
+    MatMul<3,3,1,P>(rot,T_ba,x_a);
+    MatAdd<3,1,P>(x_b,rot,T_ba+(3*3));
+}
+
+template<typename P>
+void LieApplySE34x4vec3( P x_b[3], const P T_ba[4*4], const P x_a[3] )
+{
+    x_b[0] = T_ba[0]*x_a[0] + T_ba[4]*x_a[1] + T_ba[8]*x_a[2] + T_ba[12];
+    x_b[1] = T_ba[1]*x_a[0] + T_ba[5]*x_a[1] + T_ba[9]*x_a[2] + T_ba[13];
+    x_b[2] = T_ba[2]*x_a[0] + T_ba[6]*x_a[1] + T_ba[10]*x_a[2] + T_ba[14];
+}
+
+template<typename P>
+void LieMulSO3( P R_ca[3*3], const P R_cb[3*3], const P R_ba[3*3] )
+{
+    MatMul<3,3,3>(R_ca,R_cb,R_ba);
+}
+
+template<typename P>
+void LieMulSE3( P T_ca[3*4], const P T_cb[3*4], const P T_ba[3*4] )
+{
+    LieMulSO3<>(T_ca,T_cb,T_ba);
+    P R_cb_times_a_b[3];
+    LieApplySO3<>(R_cb_times_a_b,T_cb,T_ba+(3*3));
+    MatAdd<3,1>(T_ca+(3*3),R_cb_times_a_b,T_cb+(3*3));
+}
+
+template<typename P>
+void LiePutSE3in4x4(P out[4*4], const P in[3*4] )
+{
+    SetIdentity<4>(out);
+    std::copy(in,in+3, out);
+    std::copy(in+3,in+6, out+4);
+    std::copy(in+6,in+9, out+8);
+    std::copy(in+9,in+12, out+12);
+}
+
+template<typename P>
+void LieSE3from4x4(P out[3*4], const P in[4*4] )
+{
+    std::copy(in,in+3, out);
+    std::copy(in+4,in+7, out+3);
+    std::copy(in+8,in+11, out+6);
+    std::copy(in+12,in+15, out+9);
+}
+
+template<typename P>
+void LieMul4x4bySE3( P T_ca[4*4], const P T_cb[3*4], const P T_ba[4*4] )
+{
+    // TODO: fast
+    P T_cb4[4*4];
+    LiePutSE3in4x4<>(T_cb4,T_cb);
+    P res[4*4];
+    MatMul<4,4,4>(res,T_cb4,T_ba);
+    std::copy(res,res+(4*4),T_ca);
+}
+
+template<typename P>
+void LieTransposeSO3( P R_ab[3*3], const P R_ba[3*3] )
+{
+    MatTranspose<3,P>(R_ab,R_ba);
+}
+
+template<typename P>
+void LieInverseSE3( P T_ab[3*4], const P T_ba[3*4] )
+{
+    LieTransposeSO3<P>(T_ab,T_ba);
+    P minus_b_a[3];
+    LieApplySO3(minus_b_a, T_ab, T_ba+(3*3));
+    MatMul<3,1,P>(T_ab+(3*3),minus_b_a, -1);
+}
+
+// c = a x b
+template<typename P>
+void CrossProduct( P c[3], const P a[3], const P b[3] )
+{
+    c[0] = a[1] * b[2] - a[2] * b[1];
+    c[1] = a[2] * b[0] - a[0] * b[2];
+    c[2] = a[0] * b[1] - a[1] * b[0];
+}
+
+template<int R, typename P>
+P Length( P v[R] )
+{
+    P sum_sq = 0;
+    
+    for(size_t r = 0; r < R; ++r ) {
+        sum_sq += v[r] * v[r];
+    }
+    
+    return sqrt(sum_sq);
+}
+
+
+template<int R, typename P>
+void Normalise( P v[R] )
+{
+    const P length = Length<R,P>(v);
+    
+    for(size_t r = 0; r < R; ++r ) {
+        v[r] /= length;
+    }
+}
+
+template<typename P>
+void EnforceUpT_wc(P T_wc[3*4], const P up_w[3])
+{
+    // Copy R_wc
+    P R_wc[3*3];
+    std::copy(T_wc,T_wc+3*3,R_wc);
+    
+    // New R_wc should go into T_wc
+    P* NR_wc = T_wc;
+    
+    //    // cx_w,cy_w,cz_w are camera axis in world coordinates
+    //    // Calculate new camera coordinates (ncx_w,ncy_w,ncz_w)
+    
+    // ncx_w = up_w x cz_w
+    CrossProduct(NR_wc + 0*3, up_w, R_wc + 2*3);
+    
+    // ncy_w = cz_w x ncx_w
+    CrossProduct(NR_wc + 1*3, R_wc + 2*3, NR_wc + 0*3);
+    
+    // ncz_w = cz_w
+    std::copy(R_wc + 2*3, R_wc + 3*3, NR_wc + 2*3);
+    
+    Normalise<3,P>(NR_wc + 0*3);
+    Normalise<3,P>(NR_wc + 1*3);
+    Normalise<3,P>(NR_wc + 2*3);
+}
+
+template<typename P>
+void EnforceUpT_cw(P T_cw_4x4[4*4], const P up_w[3])
+{
+    // 3x4 from 4x4
+    P T_cw[3*4];
+    LieSE3from4x4<P>(T_cw,T_cw_4x4);
+    
+    // Invert T_cw
+    P T_wc[3*4];
+    LieInverseSE3<P>(T_wc, T_cw);
+    
+    // Enforce up for T_wc
+    EnforceUpT_wc<P>(T_wc, up_w);
+    
+    // Invert
+    LieInverseSE3<P>(T_cw, T_wc);
+    
+    // 4x4 from 3x4
+    LiePutSE3in4x4<P>(T_cw_4x4,T_cw);
+}
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/threadedfilebuf.h

@@ -0,0 +1,97 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <iostream>
+#include <streambuf>
+#include <fstream>
+
+#include <pangolin/platform.h>
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+
+#ifdef _LINUX_
+// On linux, using posix file i/o to allow sync writes.
+#define USE_POSIX_FILE_IO
+#endif
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT threadedfilebuf : public std::streambuf
+{
+public:
+    ~threadedfilebuf();
+    threadedfilebuf();
+    threadedfilebuf(const std::string& filename, size_t buffer_size_bytes);
+    
+    void open(const std::string& filename, size_t buffer_size_bytes);
+    void close();
+    void force_close();
+    
+    void operator()();
+    
+protected:
+    void soft_close();
+
+    //! Override streambuf::xsputn for asynchronous write
+    std::streamsize xsputn(const char * s, std::streamsize n) override;
+
+    //! Override streambuf::overflow for asynchronous write
+    int overflow(int c) override;
+
+    std::streampos seekoff(
+        std::streamoff off, std::ios_base::seekdir way,
+        std::ios_base::openmode which = std::ios_base::in | std::ios_base::out
+    ) override;
+    
+#ifdef USE_POSIX_FILE_IO
+    int filenum = -1;
+#else
+    std::filebuf file;
+#endif
+
+    char* mem_buffer;
+    std::streamsize mem_size;
+    std::streamsize mem_max_size;
+    std::streamsize mem_start;
+    std::streamsize mem_end;
+
+    std::streampos input_pos;
+    
+    std::mutex update_mutex;
+    std::condition_variable cond_queued;
+    std::condition_variable cond_dequeued;
+    std::thread write_thread;
+
+    bool should_run;
+    bool is_pipe;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/timer.h

@@ -0,0 +1,122 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <chrono>
+#include <thread>
+
+#include <pangolin/platform.h>
+
+namespace pangolin
+{
+
+// These methods exist for backwards compatibility.
+// They are deprecated in favour of direct use of std::chrono in C++11
+
+using baseclock = std::chrono::steady_clock;
+using basetime = baseclock::time_point;
+static_assert(baseclock::is_steady, "baseclock must be steady to be robust against system time settings");
+
+inline basetime TimeNow()
+{
+    return baseclock::now();
+}
+
+inline double Time_s(basetime t)
+{
+    using namespace std::chrono;
+    return (double)duration_cast<seconds>( t.time_since_epoch() ).count();
+}
+
+inline int64_t Time_us(basetime t)
+{
+    using namespace std::chrono;
+    return duration_cast<microseconds>( t.time_since_epoch() ).count();
+}
+
+inline double TimeDiff_s(basetime start, basetime end)
+{
+    const baseclock::duration d = end - start;
+    return Time_s( basetime() + d);
+}
+
+inline int64_t TimeDiff_us(basetime start, basetime end)
+{
+    const baseclock::duration d = end - start;
+    return Time_us( basetime() + d);
+}
+
+inline basetime TimeAdd(basetime t1, basetime t2)
+{
+
+    return t1 + t2.time_since_epoch();
+}
+
+inline double TimeNow_s()
+{
+    return Time_s(TimeNow());
+}
+
+inline int64_t TimeNow_us()
+{
+    return Time_us(TimeNow());
+}
+
+inline basetime WaitUntil(basetime t)
+{
+    std::this_thread::sleep_until(t);
+    return TimeNow();
+}
+
+struct Timer
+{
+    Timer() {
+        Reset();
+    }
+    
+    void Reset()
+    {
+        start = TimeNow();
+    }
+    
+    double Elapsed_s()
+    {
+        basetime currtime = TimeNow();
+        return TimeDiff_s(start,currtime);
+    }
+
+    double Elapsed_us()
+    {
+        basetime currtime = TimeNow();
+        return (double)TimeDiff_us(start,currtime);
+    }
+    
+    basetime start;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/transform.h

@@ -0,0 +1,102 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <ostream>
+#include <functional>
+
+namespace pangolin
+{
+
+// Find the open brace preceeded by '$'
+inline const char* FirstOpenBrace(const char* str, char token = '$', char open = '{')
+{
+    bool symbol = false;
+
+    for(; *str != '\0'; ++str ) {
+        if( *str == token) {
+            symbol = true;
+        }else{
+            if( symbol ) {
+                if( *str == open ) {
+                    return str;
+                } else {
+                    symbol = false;
+                }
+            }
+        }
+    }
+    return 0;
+}
+
+// Find the first matching end brace. str includes open brace
+inline const char* MatchingEndBrace(const char* str, char open = '{', char close = '}')
+{
+    int b = 0;
+    for(; *str != '\0'; ++str ) {
+        if( *str == open ) {
+            ++b;
+        }else if( *str == close ) {
+            --b;
+            if( b == 0 ) {
+                return str;
+            }
+        }
+    }
+    return 0;
+}
+
+inline std::string Transform(const std::string& val, std::function<std::string(const std::string&)> dictionary, char token = '$', char open = '{', char close = '}')
+{
+    std::string expanded = val;
+
+    while(true)
+    {
+        const char* brace = FirstOpenBrace(expanded.c_str(), token, open);
+        if(brace)
+        {
+            const char* endbrace = MatchingEndBrace(brace);
+            if( endbrace )
+            {
+                std::ostringstream oss;
+                oss << std::string(expanded.c_str(), brace-1);
+
+                const std::string inexpand = Transform( std::string(brace+1,endbrace), dictionary, token, open, close );
+                oss << dictionary(inexpand);
+                oss << std::string(endbrace+1, expanded.c_str() + expanded.length() );
+                expanded = oss.str();
+                continue;
+            }
+        }
+        break;
+    }
+
+    return expanded;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/true_false_toggle.h

@@ -0,0 +1,29 @@
+#pragma once
+
+namespace pangolin {
+
+enum class TrueFalseToggle
+{
+    False=0,
+    True=1,
+    Toggle=2
+};
+
+inline bool to_bool(const TrueFalseToggle on_off_toggle, const bool current_value)
+{
+    switch (on_off_toggle) {
+    case TrueFalseToggle::True: return true;
+    case TrueFalseToggle::False: return false;
+    case TrueFalseToggle::Toggle: return !current_value;
+    default: return false;
+    }
+}
+
+inline bool should_toggle(const TrueFalseToggle on_off_toggle, const bool current_value)
+{
+    return ( (on_off_toggle == TrueFalseToggle::Toggle) ||
+             (current_value != (on_off_toggle==TrueFalseToggle::True))
+           );
+}
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/type_convert.h

@@ -0,0 +1,180 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <iostream>
+#include <sstream>
+
+#include <functional>
+#include <pangolin/compat/type_traits.h>
+
+namespace pangolin
+{
+struct BadInputException : std::exception {
+    char const* what() const throw() { return "Failed to serialise type"; }
+};
+}
+
+namespace pangolin
+{
+
+template<typename T, typename S, typename Enable=void>
+struct Convert;
+
+// Generic conversion through serialisation from / to string
+template<typename T, typename S, typename Enable>
+struct Convert {
+    static T Do(const S& src)
+    {
+        std::ostringstream oss;
+        oss << src;
+        std::istringstream iss(oss.str());
+        T target;
+        iss >> target;
+
+        if(iss.fail())
+            throw BadInputException();
+
+        return target;
+    }
+};
+
+// Between the same types is just a copy
+template<typename T>
+struct Convert<T, T > {
+    static T Do(const T& src)
+    {
+        return src;
+    }
+};
+
+// Apply bool alpha IO manipulator for bool types
+template<>
+struct Convert<bool,std::string> {
+    static bool Do(const std::string& src)
+    {
+        bool target;
+        std::istringstream iss(src);
+        iss >> target;
+        
+        if(iss.fail())
+        {
+            std::istringstream iss2(src);
+            iss2 >> std::boolalpha >> target;
+            if( iss2.fail())
+                throw BadInputException();
+        }
+        
+        return target;
+    }
+};
+
+// From strings
+template<typename T>
+struct Convert<T,std::string, typename pangolin::enable_if_c<
+        !std::is_same<T,std::string>::value
+        >::type > {
+    static T Do(const std::string& src)
+    {
+        T target;
+        std::istringstream iss(src);
+        iss >> target;
+        
+        if(iss.fail())
+            throw BadInputException();
+        
+        return target;
+    }
+};
+
+// To strings
+template<typename S>
+struct Convert<std::string, S, typename pangolin::enable_if_c<
+        !std::is_same<S,std::string>::value
+        >::type > {
+    static std::string Do(const S& src)
+    {
+        std::ostringstream oss;
+        oss << src;
+        return oss.str();
+    }
+};
+
+// Between scalars
+template<typename T, typename S>
+struct Convert<T, S, typename pangolin::enable_if_c<
+        std::is_scalar<T>::value && !std::is_same<T, bool>::value &&
+        std::is_scalar<S>::value && !std::is_same<S, bool>::value &&
+        !std::is_same<S,T>::value
+        >::type > {
+    static T Do(const S& src)
+    {
+        return static_cast<T>(src);
+    }
+};
+
+// From Scalars to bool (different than scalar definition to avoid MSVC Warnings)
+template<typename T, typename S>
+struct Convert<T, S, typename pangolin::enable_if_c<
+    std::is_same<T, bool>::value &&
+    std::is_scalar<S>::value &&
+    !std::is_same<S, T>::value
+>::type > {
+    static T Do(const S& src)
+    {
+        return src != static_cast<S>(0);
+    }
+};
+
+// From bool to Scalars (different than scalar definition to avoid MSVC Warnings)
+template<typename T, typename S>
+struct Convert<T, S, typename pangolin::enable_if_c<
+    std::is_scalar<T>::value &&
+    std::is_same<S, bool>::value &&
+    !std::is_same<S, T>::value
+>::type > {
+    static T Do(const S& src)
+    {
+        return src ? static_cast<T>(0) : static_cast<T>(1);
+    }
+};
+
+template<typename S>
+std::string ToString(const S& src)
+{
+    return Convert<std::string,S>::Do(src);
+}
+
+template<typename T>
+T FromString(const std::string& src)
+{
+    return Convert<T,std::string>::Do(src);
+}
+
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/uri.h

@@ -0,0 +1,48 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <string>
+#include <pangolin/platform.h>
+#include <pangolin/utils/params.h>
+
+namespace pangolin
+{
+
+struct PANGOLIN_EXPORT Uri : public Params
+{
+    std::string scheme;
+    std::string url;
+    std::string full_uri;
+};
+
+//! Parse string as Video URI
+PANGOLIN_EXPORT
+Uri ParseUri(const std::string& str_uri);
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/variadic_all.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <tuple>
+
+namespace pangolin {
+
+template<typename TPred, typename T>
+bool all_of(TPred pred, const T& i)
+{
+    return pred(i);
+}
+
+template<typename TPred, typename T, typename... Targs>
+bool all_of(const TPred& pred, const T& i, const Targs& ... ins)
+{
+    return pred(i) && all_of(pred, ins...);
+}
+
+template<typename TPred, typename T>
+bool any_of(TPred pred, const T& i)
+{
+    return pred(i);
+}
+
+template<typename TPred, typename T, typename... Targs>
+bool any_of(const TPred& pred, const T& i, Targs& ... ins)
+{
+    return pred(i) || any_of(pred, ins...);
+}
+
+template<typename TContainer, typename... Targs>
+bool all_found(const TContainer& c, const Targs& ... its)
+{
+    using T1 = typename std::tuple_element<0, std::tuple<Targs...>>::type;
+    return all_of([&c](const T1& it){return it != c.end();}, its...);
+}
+
+template<typename T, typename... Targs>
+bool all_equal(const T& v1, const Targs& ... its)
+{
+    return all_of([v1](const T& o){return v1 == o;}, its...);
+}
+
+}

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/xml/license.txt

@@ -0,0 +1,52 @@
+Use of this software is granted under one of the following two licenses,
+to be chosen freely by the user.
+
+1. Boost Software License - Version 1.0 - August 17th, 2003
+===============================================================================
+
+Copyright (c) 2006, 2007 Marcin Kalicinski
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+2. The MIT License
+===============================================================================
+
+Copyright (c) 2006, 2007 Marcin Kalicinski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy 
+of this software and associated documentation files (the "Software"), to deal 
+in the Software without restriction, including without limitation the rights 
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 
+IN THE SOFTWARE.

third-party/DPVO/Pangolin/components/pango_core/include/pangolin/utils/xml/rapidxml_iterators.hpp

@@ -0,0 +1,174 @@
+#ifndef RAPIDXML_ITERATORS_HPP_INCLUDED
+#define RAPIDXML_ITERATORS_HPP_INCLUDED
+
+// Copyright (C) 2006, 2009 Marcin Kalicinski
+// Version 1.13
+// Revision $DateTime: 2009/05/13 01:46:17 $
+//! \file rapidxml_iterators.hpp This file contains rapidxml iterators
+
+#include "rapidxml.hpp"
+
+namespace rapidxml
+{
+
+    //! Iterator of child nodes of xml_node
+    template<class Ch>
+    class node_iterator
+    {
+    
+    public:
+
+        typedef typename xml_node<Ch> value_type;
+        typedef typename xml_node<Ch> &reference;
+        typedef typename xml_node<Ch> *pointer;
+        typedef std::ptrdiff_t difference_type;
+        typedef std::bidirectional_iterator_tag iterator_category;
+        
+        node_iterator()
+            : m_node(0)
+        {
+        }
+
+        node_iterator(xml_node<Ch> *node)
+            : m_node(node->first_node())
+        {
+        }
+        
+        reference operator *() const
+        {
+            assert(m_node);
+            return *m_node;
+        }
+
+        pointer operator->() const
+        {
+            assert(m_node);
+            return m_node;
+        }
+
+        node_iterator& operator++()
+        {
+            assert(m_node);
+            m_node = m_node->next_sibling();
+            return *this;
+        }
+
+        node_iterator operator++(int)
+        {
+            node_iterator tmp = *this;
+            ++this;
+            return tmp;
+        }
+
+        node_iterator& operator--()
+        {
+            assert(m_node && m_node->previous_sibling());
+            m_node = m_node->previous_sibling();
+            return *this;
+        }
+
+        node_iterator operator--(int)
+        {
+            node_iterator tmp = *this;
+            ++this;
+            return tmp;
+        }
+
+        bool operator ==(const node_iterator<Ch> &rhs)
+        {
+            return m_node == rhs.m_node;
+        }
+
+        bool operator !=(const node_iterator<Ch> &rhs)
+        {
+            return m_node != rhs.m_node;
+        }
+
+    private:
+
+        xml_node<Ch> *m_node;
+
+    };
+
+    //! Iterator of child attributes of xml_node
+    template<class Ch>
+    class attribute_iterator
+    {
+    
+    public:
+
+        typedef typename xml_attribute<Ch> value_type;
+        typedef typename xml_attribute<Ch> &reference;
+        typedef typename xml_attribute<Ch> *pointer;
+        typedef std::ptrdiff_t difference_type;
+        typedef std::bidirectional_iterator_tag iterator_category;
+        
+        attribute_iterator()
+            : m_attribute(0)
+        {
+        }
+
+        attribute_iterator(xml_node<Ch> *node)
+            : m_attribute(node->first_attribute())
+        {
+        }
+        
+        reference operator *() const
+        {
+            assert(m_attribute);
+            return *m_attribute;
+        }
+
+        pointer operator->() const
+        {
+            assert(m_attribute);
+            return m_attribute;
+        }
+
+        attribute_iterator& operator++()
+        {
+            assert(m_attribute);
+            m_attribute = m_attribute->next_attribute();
+            return *this;
+        }
+
+        attribute_iterator operator++(int)
+        {
+            attribute_iterator tmp = *this;
+            ++this;
+            return tmp;
+        }
+
+        attribute_iterator& operator--()
+        {
+            assert(m_attribute && m_attribute->previous_attribute());
+            m_attribute = m_attribute->previous_attribute();
+            return *this;
+        }
+
+        attribute_iterator operator--(int)
+        {
+            attribute_iterator tmp = *this;
+            ++this;
+            return tmp;
+        }
+
+        bool operator ==(const attribute_iterator<Ch> &rhs)
+        {
+            return m_attribute == rhs.m_attribute;
+        }
+
+        bool operator !=(const attribute_iterator<Ch> &rhs)
+        {
+            return m_attribute != rhs.m_attribute;
+        }
+
+    private:
+
+        xml_attribute<Ch> *m_attribute;
+
+    };
+
+}
+
+#endif