2c62cd0b0eb2c78fec26a20e2ee85f1e4f8dd6f649125667e3b449817773c6c1

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

@@ -0,0 +1,421 @@
+#ifndef RAPIDXML_PRINT_HPP_INCLUDED
+#define RAPIDXML_PRINT_HPP_INCLUDED
+
+// Copyright (C) 2006, 2009 Marcin Kalicinski
+// Version 1.13
+// Revision $DateTime: 2009/05/13 01:46:17 $
+//! \file rapidxml_print.hpp This file contains rapidxml printer implementation
+
+#include "rapidxml.hpp"
+
+// Only include streams if not disabled
+#ifndef RAPIDXML_NO_STREAMS
+    #include <ostream>
+    #include <iterator>
+#endif
+
+namespace rapidxml
+{
+
+    ///////////////////////////////////////////////////////////////////////
+    // Printing flags
+
+    const int print_no_indenting = 0x1;   //!< Printer flag instructing the printer to suppress indenting of XML. See print() function.
+
+    ///////////////////////////////////////////////////////////////////////
+    // Internal
+
+    //! \cond internal
+    namespace internal
+    {
+        
+        ///////////////////////////////////////////////////////////////////////////
+        // Internal character operations
+    
+        // Copy characters from given range to given output iterator
+        template<class OutIt, class Ch>
+        inline OutIt copy_chars(const Ch *begin, const Ch *end, OutIt out)
+        {
+            while (begin != end)
+                *out++ = *begin++;
+            return out;
+        }
+        
+        // Copy characters from given range to given output iterator and expand
+        // characters into references (&lt; &gt; &apos; &quot; &amp;)
+        template<class OutIt, class Ch>
+        inline OutIt copy_and_expand_chars(const Ch *begin, const Ch *end, Ch noexpand, OutIt out)
+        {
+            while (begin != end)
+            {
+                if (*begin == noexpand)
+                {
+                    *out++ = *begin;    // No expansion, copy character
+                }
+                else
+                {
+                    switch (*begin)
+                    {
+                    case Ch('<'):
+                        *out++ = Ch('&'); *out++ = Ch('l'); *out++ = Ch('t'); *out++ = Ch(';');
+                        break;
+                    case Ch('>'): 
+                        *out++ = Ch('&'); *out++ = Ch('g'); *out++ = Ch('t'); *out++ = Ch(';');
+                        break;
+                    case Ch('\''): 
+                        *out++ = Ch('&'); *out++ = Ch('a'); *out++ = Ch('p'); *out++ = Ch('o'); *out++ = Ch('s'); *out++ = Ch(';');
+                        break;
+                    case Ch('"'): 
+                        *out++ = Ch('&'); *out++ = Ch('q'); *out++ = Ch('u'); *out++ = Ch('o'); *out++ = Ch('t'); *out++ = Ch(';');
+                        break;
+                    case Ch('&'): 
+                        *out++ = Ch('&'); *out++ = Ch('a'); *out++ = Ch('m'); *out++ = Ch('p'); *out++ = Ch(';'); 
+                        break;
+                    default:
+                        *out++ = *begin;    // No expansion, copy character
+                    }
+                }
+                ++begin;    // Step to next character
+            }
+            return out;
+        }
+
+        // Fill given output iterator with repetitions of the same character
+        template<class OutIt, class Ch>
+        inline OutIt fill_chars(OutIt out, int n, Ch ch)
+        {
+            for (int i = 0; i < n; ++i)
+                *out++ = ch;
+            return out;
+        }
+
+        // Find character
+        template<class Ch, Ch ch>
+        inline bool find_char(const Ch *begin, const Ch *end)
+        {
+            while (begin != end)
+                if (*begin++ == ch)
+                    return true;
+            return false;
+        }
+
+        ///////////////////////////////////////////////////////////////////////////
+        // Internal printing operations
+    
+        // Print node
+        template<class OutIt, class Ch>
+        inline OutIt print_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
+        {
+            // Print proper node type
+            switch (node->type())
+            {
+
+            // Document
+            case node_document:
+                out = print_children(out, node, flags, indent);
+                break;
+
+            // Element
+            case node_element:
+                out = print_element_node(out, node, flags, indent);
+                break;
+            
+            // Data
+            case node_data:
+                out = print_data_node(out, node, flags, indent);
+                break;
+            
+            // CDATA
+            case node_cdata:
+                out = print_cdata_node(out, node, flags, indent);
+                break;
+
+            // Declaration
+            case node_declaration:
+                out = print_declaration_node(out, node, flags, indent);
+                break;
+
+            // Comment
+            case node_comment:
+                out = print_comment_node(out, node, flags, indent);
+                break;
+            
+            // Doctype
+            case node_doctype:
+                out = print_doctype_node(out, node, flags, indent);
+                break;
+
+            // Pi
+            case node_pi:
+                out = print_pi_node(out, node, flags, indent);
+                break;
+
+                // Unknown
+            default:
+                assert(0);
+                break;
+            }
+            
+            // If indenting not disabled, add line break after node
+            if (!(flags & print_no_indenting))
+                *out = Ch('\n'), ++out;
+
+            // Return modified iterator
+            return out;
+        }
+        
+        // Print children of the node                               
+        template<class OutIt, class Ch>
+        inline OutIt print_children(OutIt out, const xml_node<Ch> *node, int flags, int indent)
+        {
+            for (xml_node<Ch> *child = node->first_node(); child; child = child->next_sibling())
+                out = print_node(out, child, flags, indent);
+            return out;
+        }
+
+        // Print attributes of the node
+        template<class OutIt, class Ch>
+        inline OutIt print_attributes(OutIt out, const xml_node<Ch> *node, int flags)
+        {
+            for (xml_attribute<Ch> *attribute = node->first_attribute(); attribute; attribute = attribute->next_attribute())
+            {
+                if (attribute->name() && attribute->value())
+                {
+                    // Print attribute name
+                    *out = Ch(' '), ++out;
+                    out = copy_chars(attribute->name(), attribute->name() + attribute->name_size(), out);
+                    *out = Ch('='), ++out;
+                    // Print attribute value using appropriate quote type
+                    if (find_char<Ch, Ch('"')>(attribute->value(), attribute->value() + attribute->value_size()))
+                    {
+                        *out = Ch('\''), ++out;
+                        out = copy_and_expand_chars(attribute->value(), attribute->value() + attribute->value_size(), Ch('"'), out);
+                        *out = Ch('\''), ++out;
+                    }
+                    else
+                    {
+                        *out = Ch('"'), ++out;
+                        out = copy_and_expand_chars(attribute->value(), attribute->value() + attribute->value_size(), Ch('\''), out);
+                        *out = Ch('"'), ++out;
+                    }
+                }
+            }
+            return out;
+        }
+
+        // Print data node
+        template<class OutIt, class Ch>
+        inline OutIt print_data_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
+        {
+            assert(node->type() == node_data);
+            if (!(flags & print_no_indenting))
+                out = fill_chars(out, indent, Ch('\t'));
+            out = copy_and_expand_chars(node->value(), node->value() + node->value_size(), Ch(0), out);
+            return out;
+        }
+
+        // Print data node
+        template<class OutIt, class Ch>
+        inline OutIt print_cdata_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
+        {
+            assert(node->type() == node_cdata);
+            if (!(flags & print_no_indenting))
+                out = fill_chars(out, indent, Ch('\t'));
+            *out = Ch('<'); ++out;
+            *out = Ch('!'); ++out;
+            *out = Ch('['); ++out;
+            *out = Ch('C'); ++out;
+            *out = Ch('D'); ++out;
+            *out = Ch('A'); ++out;
+            *out = Ch('T'); ++out;
+            *out = Ch('A'); ++out;
+            *out = Ch('['); ++out;
+            out = copy_chars(node->value(), node->value() + node->value_size(), out);
+            *out = Ch(']'); ++out;
+            *out = Ch(']'); ++out;
+            *out = Ch('>'); ++out;
+            return out;
+        }
+
+        // Print element node
+        template<class OutIt, class Ch>
+        inline OutIt print_element_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
+        {
+            assert(node->type() == node_element);
+
+            // Print element name and attributes, if any
+            if (!(flags & print_no_indenting))
+                out = fill_chars(out, indent, Ch('\t'));
+            *out = Ch('<'), ++out;
+            out = copy_chars(node->name(), node->name() + node->name_size(), out);
+            out = print_attributes(out, node, flags);
+            
+            // If node is childless
+            if (node->value_size() == 0 && !node->first_node())
+            {
+                // Print childless node tag ending
+                *out = Ch('/'), ++out;
+                *out = Ch('>'), ++out;
+            }
+            else
+            {
+                // Print normal node tag ending
+                *out = Ch('>'), ++out;
+
+                // Test if node contains a single data node only (and no other nodes)
+                xml_node<Ch> *child = node->first_node();
+                if (!child)
+                {
+                    // If node has no children, only print its value without indenting
+                    out = copy_and_expand_chars(node->value(), node->value() + node->value_size(), Ch(0), out);
+                }
+                else if (child->next_sibling() == 0 && child->type() == node_data)
+                {
+                    // If node has a sole data child, only print its value without indenting
+                    out = copy_and_expand_chars(child->value(), child->value() + child->value_size(), Ch(0), out);
+                }
+                else
+                {
+                    // Print all children with full indenting
+                    if (!(flags & print_no_indenting))
+                        *out = Ch('\n'), ++out;
+                    out = print_children(out, node, flags, indent + 1);
+                    if (!(flags & print_no_indenting))
+                        out = fill_chars(out, indent, Ch('\t'));
+                }
+
+                // Print node end
+                *out = Ch('<'), ++out;
+                *out = Ch('/'), ++out;
+                out = copy_chars(node->name(), node->name() + node->name_size(), out);
+                *out = Ch('>'), ++out;
+            }
+            return out;
+        }
+
+        // Print declaration node
+        template<class OutIt, class Ch>
+        inline OutIt print_declaration_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
+        {
+            // Print declaration start
+            if (!(flags & print_no_indenting))
+                out = fill_chars(out, indent, Ch('\t'));
+            *out = Ch('<'), ++out;
+            *out = Ch('?'), ++out;
+            *out = Ch('x'), ++out;
+            *out = Ch('m'), ++out;
+            *out = Ch('l'), ++out;
+
+            // Print attributes
+            out = print_attributes(out, node, flags);
+            
+            // Print declaration end
+            *out = Ch('?'), ++out;
+            *out = Ch('>'), ++out;
+            
+            return out;
+        }
+
+        // Print comment node
+        template<class OutIt, class Ch>
+        inline OutIt print_comment_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
+        {
+            assert(node->type() == node_comment);
+            if (!(flags & print_no_indenting))
+                out = fill_chars(out, indent, Ch('\t'));
+            *out = Ch('<'), ++out;
+            *out = Ch('!'), ++out;
+            *out = Ch('-'), ++out;
+            *out = Ch('-'), ++out;
+            out = copy_chars(node->value(), node->value() + node->value_size(), out);
+            *out = Ch('-'), ++out;
+            *out = Ch('-'), ++out;
+            *out = Ch('>'), ++out;
+            return out;
+        }
+
+        // Print doctype node
+        template<class OutIt, class Ch>
+        inline OutIt print_doctype_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
+        {
+            assert(node->type() == node_doctype);
+            if (!(flags & print_no_indenting))
+                out = fill_chars(out, indent, Ch('\t'));
+            *out = Ch('<'), ++out;
+            *out = Ch('!'), ++out;
+            *out = Ch('D'), ++out;
+            *out = Ch('O'), ++out;
+            *out = Ch('C'), ++out;
+            *out = Ch('T'), ++out;
+            *out = Ch('Y'), ++out;
+            *out = Ch('P'), ++out;
+            *out = Ch('E'), ++out;
+            *out = Ch(' '), ++out;
+            out = copy_chars(node->value(), node->value() + node->value_size(), out);
+            *out = Ch('>'), ++out;
+            return out;
+        }
+
+        // Print pi node
+        template<class OutIt, class Ch>
+        inline OutIt print_pi_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
+        {
+            assert(node->type() == node_pi);
+            if (!(flags & print_no_indenting))
+                out = fill_chars(out, indent, Ch('\t'));
+            *out = Ch('<'), ++out;
+            *out = Ch('?'), ++out;
+            out = copy_chars(node->name(), node->name() + node->name_size(), out);
+            *out = Ch(' '), ++out;
+            out = copy_chars(node->value(), node->value() + node->value_size(), out);
+            *out = Ch('?'), ++out;
+            *out = Ch('>'), ++out;
+            return out;
+        }
+
+    }
+    //! \endcond
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Printing
+
+    //! Prints XML to given output iterator.
+    //! \param out Output iterator to print to.
+    //! \param node Node to be printed. Pass xml_document to print entire document.
+    //! \param flags Flags controlling how XML is printed.
+    //! \return Output iterator pointing to position immediately after last character of printed text.
+    template<class OutIt, class Ch> 
+    inline OutIt print(OutIt out, const xml_node<Ch> &node, int flags = 0)
+    {
+        return internal::print_node(out, &node, flags, 0);
+    }
+
+#ifndef RAPIDXML_NO_STREAMS
+
+    //! Prints XML to given output stream.
+    //! \param out Output stream to print to.
+    //! \param node Node to be printed. Pass xml_document to print entire document.
+    //! \param flags Flags controlling how XML is printed.
+    //! \return Output stream.
+    template<class Ch> 
+    inline std::basic_ostream<Ch> &print(std::basic_ostream<Ch> &out, const xml_node<Ch> &node, int flags = 0)
+    {
+        print(std::ostream_iterator<Ch>(out), node, flags);
+        return out;
+    }
+
+    //! Prints formatted XML to given output stream. Uses default printing flags. Use print() function to customize printing process.
+    //! \param out Output stream to print to.
+    //! \param node Node to be printed.
+    //! \return Output stream.
+    template<class Ch> 
+    inline std::basic_ostream<Ch> &operator <<(std::basic_ostream<Ch> &out, const xml_node<Ch> &node)
+    {
+        return print(out, node);
+    }
+
+#endif
+
+}
+
+#endif

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

@@ -0,0 +1,122 @@
+#ifndef RAPIDXML_UTILS_HPP_INCLUDED
+#define RAPIDXML_UTILS_HPP_INCLUDED
+
+// Copyright (C) 2006, 2009 Marcin Kalicinski
+// Version 1.13
+// Revision $DateTime: 2009/05/13 01:46:17 $
+//! \file rapidxml_utils.hpp This file contains high-level rapidxml utilities that can be useful
+//! in certain simple scenarios. They should probably not be used if maximizing performance is the main objective.
+
+#include "rapidxml.hpp"
+#include <vector>
+#include <string>
+#include <fstream>
+#include <stdexcept>
+
+namespace rapidxml
+{
+
+    //! Represents data loaded from a file
+    template<class Ch = char>
+    class file
+    {
+        
+    public:
+        
+        //! Loads file into the memory. Data will be automatically destroyed by the destructor.
+        //! \param filename Filename to load.
+        file(const char *filename)
+        {
+            using namespace std;
+
+            // Open stream
+            basic_ifstream<Ch> stream(filename, ios::binary);
+            if (!stream)
+                throw runtime_error(string("cannot open file ") + filename);
+            stream.unsetf(ios::skipws);
+            
+            // Determine stream size
+            stream.seekg(0, ios::end);
+            size_t size = (size_t)stream.tellg();
+            stream.seekg(0);   
+            
+            // Load data and add terminating 0
+            m_data.resize(size + 1);
+            stream.read(&m_data.front(), static_cast<streamsize>(size));
+            m_data[size] = 0;
+        }
+
+        //! Loads file into the memory. Data will be automatically destroyed by the destructor
+        //! \param stream Stream to load from
+        file(std::basic_istream<Ch> &stream)
+        {
+            using namespace std;
+
+            // Load data and add terminating 0
+            stream.unsetf(ios::skipws);
+            m_data.assign(istreambuf_iterator<Ch>(stream), istreambuf_iterator<Ch>());
+            if (stream.fail() || stream.bad())
+                throw runtime_error("error reading stream");
+            m_data.push_back(0);
+        }
+        
+        //! Gets file data.
+        //! \return Pointer to data of file.
+        Ch *data()
+        {
+            return &m_data.front();
+        }
+
+        //! Gets file data.
+        //! \return Pointer to data of file.
+        const Ch *data() const
+        {
+            return &m_data.front();
+        }
+
+        //! Gets file data size.
+        //! \return Size of file data, in characters.
+        std::size_t size() const
+        {
+            return m_data.size();
+        }
+
+    private:
+
+        std::vector<Ch> m_data;   // File data
+
+    };
+
+    //! Counts children of node. Time complexity is O(n).
+    //! \return Number of children of node
+    template<class Ch>
+    inline std::size_t count_children(xml_node<Ch> *node)
+    {
+        xml_node<Ch> *child = node->first_node();
+        std::size_t count = 0;
+        while (child)
+        {
+            ++count;
+            child = child->next_sibling();
+        }
+        return count;
+    }
+
+    //! Counts attributes of node. Time complexity is O(n).
+    //! \return Number of attributes of node
+    template<class Ch>
+    inline std::size_t count_attributes(xml_node<Ch> *node)
+    {
+        xml_attribute<Ch> *attr = node->first_attribute();
+        std::size_t count = 0;
+        while (attr)
+        {
+            ++count;
+            attr = attr->next_attribute();
+        }
+        return count;
+    }
+
+}
+
+#endif

third-party/DPVO/Pangolin/components/pango_core/include/sigslot/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Pierre-Antoine Lacaze
+
+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/sigslot/README.md

@@ -0,0 +1,717 @@
+# Sigslot, a signal-slot library
+
+Sigslot is a header-only, thread safe implementation of signal-slots for C++.
+
+## Features
+
+The main goal was to replace Boost.Signals2.
+
+Apart from the usual features, it offers
+
+- Thread safety,
+- Object lifetime tracking for automatic slot disconnection (extensible through ADL),
+- RAII connection management,
+- Slot groups to enforce slots execution order,
+- Reasonable performance. and a simple and straightforward implementation.
+
+Sigslot is unit-tested and should be reliable and stable enough to replace Boost Signals2.
+
+The tests run cleanly under the address, thread and undefined behaviour sanitizers.
+
+Many implementations allow signal return types, Sigslot does not because I have
+no use for them. If I can be convinced of otherwise I may change my mind later on.
+
+## Installation
+
+No compilation or installation is required, just include `sigslot/signal.hpp`
+and use it. Sigslot currently depends on a C++14 compliant compiler, but if need
+arises it may be retrofitted to C++11. It is known to work with Clang 4.0 and GCC
+5.0+ compilers on GNU Linux, MSVC 2017 and up, Clang-cl and MinGW on Windows.
+
+However, be aware of a potential gotcha on Windows with MSVC and Clang-Cl compilers,
+which may need the `/OPT:NOICF` linker flags in exceptional situations. Read The
+Implementation Details chapter for an explanation.
+
+A CMake list file is supplied for installation purpose and generating a CMake import
+module. This is the preferred installation method. The `Pal::Sigslot` imported target
+is available and already applies the needed linker flags. It is also required for
+examples and tests, which optionally depend on Qt5 and Boost for adapters unit tests.
+
+```cmake
+# Using Sigslot from cmake
+find_package(PalSigslot)
+
+add_executable(MyExe main.cpp)
+target_link_libraries(MyExe PRIVATE Pal::Sigslot)
+```
+
+A configuration option `SIGSLOT_REDUCE_COMPILE_TIME` is available at configuration
+time. When activated, it attempts to reduce code bloat by avoiding heavy template
+instantiations resulting from calls to `std::make_shared`.
+This option is off by default, but can be activated for those who wish to favor
+code size and compilation time at the expanse of slightly less efficient code.
+
+Installation may be done using the following instructions from the root directory:
+
+```sh
+mkdir build && cd build
+cmake .. -DSIGSLOT_REDUCE_COMPILE_TIME=ON -DCMAKE_INSTALL_PREFIX=~/local
+cmake --build . --target install
+
+# If you want to compile examples:
+cmake --build . --target sigslot-examples
+
+# And compile/execute unit tests:
+cmake --build . --target sigslot-tests
+```
+
+### CMake FetchContent
+
+`Pal::Sigslot` can also be integrated using the [FetchContent](https://cmake.org/cmake/help/latest/module/FetchContent.html) method.
+
+```cmake
+include(FetchContent)
+
+FetchContent_Declare(
+  sigslot
+  GIT_REPOSITORY https://github.com/palacaze/sigslot
+  GIT_TAG        19a6f0f5ea11fc121fe67f81fd5e491f2d7a4637 # v1.2.0
+)
+FetchContent_MakeAvailable(sigslot)
+
+add_executable(MyExe main.cpp)
+target_link_libraries(MyExe PRIVATE Pal::Sigslot)
+```
+
+## Documentation
+
+Sigslot implements the signal-slot construct popular in UI frameworks, making it
+easy to use the observer pattern or event-based programming. The main entry point
+of the library is the `sigslot::signal<T...>` class template.
+
+A signal is an object that can emit typed notifications, really values parametrized
+after the signal class template parameters, and register any number of notification
+handlers (callables) of compatible argument types to be executed with the values
+supplied whenever a signal emission happens. In signal-slot parlance this is called
+connecting a slot to a signal, where a "slot" represents a callable instance and
+a "connection" can be thought of as a conceptual link from signal to slot.
+
+All the snippets presented below are available in compilable source code form in
+the example subdirectory.
+
+### Basic usage
+
+Here is a first example that showcases the most basic features of the library.
+
+We first declare a parameter-free signal `sig`, then we proceed to connect several
+slots and at last emit a signal which triggers the invocation of every slot callable
+connected beforehand. Notice how The library handles diverse forms of callables.
+
+```cpp
+#include <sigslot/signal.hpp>
+#include <iostream>
+
+void f() { std::cout << "free function\n"; }
+
+struct s {
+    void m() { std::cout << "member function\n"; }
+    static void sm() { std::cout << "static member function\n";  }
+};
+
+struct o {
+    void operator()() { std::cout << "function object\n"; }
+};
+
+int main() {
+    s d;
+    auto lambda = []() { std::cout << "lambda\n"; };
+    auto gen_lambda = [](auto && ...a) { std::cout << "generic lambda\n"; };
+
+    // declare a signal instance with no arguments
+    sigslot::signal<> sig;
+
+    // connect slots
+    sig.connect(f);
+    sig.connect(&s::m, &d);
+    sig.connect(&s::sm);
+    sig.connect(o());
+    sig.connect(lambda);
+    sig.connect(gen_lambda);
+
+    // emit a signal
+    sig();
+}
+```
+
+By default, the slot invocation order when emitting a signal is unspecified, please
+do not rely on it being always the same. You may constrain a particular invocation
+order by using slot groups, which are presented later on.
+
+### Signal with arguments
+
+That first example was simple but not so useful, let us move on to a signal that
+emits values instead. A signal can emit any number of arguments, below.
+
+```cpp
+#include <sigslot/signal.hpp>
+#include <iostream>
+#include <string>
+
+struct foo {
+    // Notice how we accept a double as first argument here.
+    // This is fine because float is convertible to double.
+    // 's' is a reference and can thus be modified.
+    void bar(double d, int i, bool b, std::string &s) {
+        s = b ? std::to_string(i) : std::to_string(d);
+    }
+};
+
+// Function objects can cope with default arguments and overloading.
+// It does not work with static and member functions.
+struct obj {
+    void operator()(float, int, bool, std::string &, int = 0) {
+        std::cout << "I was here\n";
+    }
+
+    void operator()() {}
+};
+
+int main() {
+    // declare a signal with float, int, bool and string& arguments
+    sigslot::signal<float, int, bool, std::string&> sig;
+
+    // a generic lambda that prints its arguments to stdout
+    auto printer = [] (auto a, auto && ...args) {
+        std::cout << a;
+        (void)std::initializer_list<int>{
+            ((void)(std::cout << " " << args), 1)...
+        };
+        std::cout << "\n";
+    };
+
+    // connect the slots
+    foo ff;
+    sig.connect(printer);
+    sig.connect(&foo::bar, &ff);
+    sig.connect(obj());
+
+    float f = 1.f;
+    short i = 2;  // convertible to int
+    std::string s = "0";
+
+    // emit a signal
+    sig(f, i, false, s);
+    sig(f, i, true, s);
+}
+```
+
+As shown, slots arguments types don't need to be strictly identical to the signal
+template parameters, being convertible-from is fine. Generic arguments are fine too,
+as shown with the `printer` generic lambda (which could have been written as a
+function template too).
+
+Right now there are two limitations that I can think of with respect to callable
+handling: default arguments and function overloading. Both are working correctly
+in the case of function objects but will fail to compile with static and member
+functions, for different but related reasons.
+
+#### Coping with overloaded functions
+
+Consider the following piece of code:
+
+```cpp
+struct foo {
+    void bar(double d);
+    void bar();
+};
+```
+
+What should `&foo::bar` refer to? As per overloading, this pointer over member
+function does not map to a unique symbol, so the compiler won't be able to pick
+the right symbol. One way of resolving the right symbol is to explicitly cast the
+function pointer to the right function type. Here is an example that does just that
+using a little helper tool for a lighter syntax (In fact I will probably add this
+to the library soon).
+
+```cpp
+#include <sigslot/signal.hpp>
+
+template <typename... Args, typename C>
+constexpr auto overload(void (C::*ptr)(Args...)) {
+    return ptr;
+}
+
+template <typename... Args>
+constexpr auto overload(void (*ptr)(Args...)) {
+    return ptr;
+}
+
+struct obj {
+    void operator()(int) const {}
+    void operator()() {}
+};
+
+struct foo {
+    void bar(int) {}
+    void bar() {}
+
+    static void baz(int) {}
+    static void baz() {}
+};
+
+void moo(int) {}
+void moo() {}
+
+int main() {
+    sigslot::signal<int> sig;
+
+    // connect the slots, casting to the right overload if necessary
+    foo ff;
+    sig.connect(overload<int>(&foo::bar), &ff);
+    sig.connect(overload<int>(&foo::baz));
+    sig.connect(overload<int>(&moo));
+    sig.connect(obj());
+
+    sig(0);
+
+    return 0;
+}
+```
+
+#### Coping with function with default arguments
+
+Default arguments are not part of the function type signature, and can be redefined,
+so they are really difficult to deal with. When connecting a slot to a signal, the
+library determines if the supplied callable can be invoked with the signal argument
+types, but at this point the existence of default function arguments is unknown
+so there might be a mismatch in the number of arguments.
+
+A simple work around for this use case would is to create a bind adapter, in fact
+we can even make it quite generic like so:
+
+```cpp
+#include <sigslot/signal.hpp>
+
+#define ADAPT(func) \
+    [=](auto && ...a) { (func)(std::forward<decltype(a)>(a)...); }
+
+void foo(int &i, int b = 1) {
+    i += b;
+}
+
+int main() {
+    int i = 0;
+
+    // fine, all the arguments are handled
+    sigslot::signal<int&, int> sig1;
+    sig1.connect(foo);
+    sig1(i, 2);
+
+    // must wrap in an adapter
+    i = 0;
+    sigslot::signal<int&> sig2;
+    sig2.connect(ADAPT(foo));
+    sig2(i);
+
+    return 0;
+}
+```
+
+### Connection management
+
+#### Connection object
+
+What was not made apparent until now is that `signal::connect()` actually returns
+a `sigslot::connection` object that may be used to manage the behaviour and lifetime
+of a signal-slot connection. `sigslot::connection` is a lightweight object (basically
+a `std::weak_ptr`) that allows interaction with an ongoing signal-slot connection
+and exposes the following features:
+
+- Status querying, that is testing whether a connection is valid, ongoing or facing destruction,
+- Connection (un)blocking, which allows to temporarily disable the invocation of a slot when a signal is emitted,
+- Disconnection of a slot, the destruction of a connection previously created via `signal::connect()`.
+
+A `sigslot::connection` does not tie a connection to a scope: this is not a RAII
+object, which explains why it can be copied. It can be however implicitly converted
+into a `sigslot::scoped_connection` which destroys the connection when going out
+of scope.
+
+Here is an example illustrating some of those features:
+
+```cpp
+#include <sigslot/signal.hpp>
+#include <string>
+
+int i = 0;
+
+void f() { i += 1; }
+
+int main() {
+    sigslot::signal<> sig;
+
+    // keep a sigslot::connection object
+    auto c1 = sig.connect(f);
+
+    // disconnection
+    sig();  // i == 1
+    c1.disconnect();
+    sig();  // i == 1
+
+    // scope based disconnection
+    {
+        sigslot::scoped_connection sc = sig.connect(f);
+        sig();  // i == 2
+    }
+
+    sig();  // i == 2;
+
+
+    // connection blocking
+    auto c2 = sig.connect(f);
+    sig();  // i == 3
+    c2.block();
+    sig();  // i == 3
+    c2.unblock();
+    sig();  // i == 4
+}
+```
+
+#### Extended connection signature
+
+Sigslot supports an extended slot signature with an additional `sigslot::connection`
+reference as first argument, which permits connection management from inside the
+slot. This extended signature is accessible using the `connect_extended()` method.
+
+```cpp
+#include <sigslot/signal.hpp>
+
+int main() {
+    int i = 0;
+    sigslot::signal<> sig;
+
+    // extended connection
+    auto f = [](auto &con) {
+        i += 1;             // do work
+        con.disconnect();   // then disconnects
+    };
+
+    sig.connect_extended(f);
+    sig();  // i == 1
+    sig();  // i == 1 because f was disconnected
+}
+```
+
+#### Automatic slot lifetime tracking
+
+The user must make sure that the lifetime of a slot exceeds the one of a signal,
+which may get tedious in complex software. To simplify this task, Sigslot can
+automatically disconnect slot object whose lifetime it is able to track. In order
+to do that, the slot must be convertible to a weak pointer of some form.
+
+`std::shared_ptr` and `std::weak_ptr` are supported out of the box, and adapters
+are provided to support `boost::shared_ptr`, `boost::weak_ptr` and Qt `QSharedPointer`,
+`QWeakPointer` and any class deriving from `QObject`.
+
+Other trackable objects can be added by declaring a `to_weak()` adapter function.
+
+```cpp
+#include <sigslot/signal.hpp>
+#include <sigslot/adapter/qt.hpp>
+
+int sum = 0;
+
+struct s {
+    void f(int i) { sum += i; }
+};
+
+class MyObject : public QObject {
+    Q_OBJECT
+public:
+    void add(int i) const { sum += i; }
+};
+
+int main() {
+    sum = 0;
+    signal<int> sig;
+
+    // track lifetime of object and also connect to a member function
+    auto p = std::make_shared<s>();
+    sig.connect(&s::f, p);
+
+    sig(1);     // sum == 1
+    p.reset();
+    sig(1);     // sum == 1
+
+    // track an unrelated object lifetime
+    struct dummy;
+    auto l = [&](int i) { sum += i; };
+
+    auto d = std::make_shared<dummy>();
+    sig.connect(l, d);
+    sig(1);     // sum == 2
+    d.reset();
+    sig(1);     // sum == 2
+
+    // track a QObject
+    {
+        MyObject o;
+        sig.connect(&MyObject::add, &o);
+
+        sig(1); // sum == 3
+    }
+
+    sig(1);     // sum == 3
+}
+```
+
+#### Intrusive slot lifetime tracking
+
+Another way of ensuring automatic disconnection of pointer over member functions
+slots is by explicitly inheriting from `sigslot::observer` or `sigslot::observer_st`.
+The former is thread-safe, contrary to the later.
+
+Here is an example usage.
+
+```cpp
+#include <sigslot/signal.hpp>
+
+int sum = 0;
+
+struct s : sigslot::observer_st {
+    void f(int i) { sum += i; }
+};
+
+struct s_mt : sigslot::observer {
+    ~s_mt() {
+        // Needed to ensure proper disconnection prior to object destruction
+        // in multithreaded contexts.
+        this->disconnect_all();
+    }
+    
+    void f(int i) { sum += i; }
+};
+
+int main() {
+    sum = 0;
+    signal<int> sig;
+    
+    {
+        // Lifetime of object instance p is tracked
+        s p;
+        s_mt pm;
+        sig.connect(&s::f, &p);
+        sig.connect(&s_mt::f, &pm);
+        sig(1);     // sum == 2
+    }
+    
+    // The slots got disconnected at instance destruction
+    sig(1);         // sum == 2
+}
+```
+
+The objects that use this intrusive approach may be connected to any number of
+unrelated signals.
+
+### Disconnection without a connection object
+
+Support for slot disconnection by supplying an appropriate function signature,
+object pointer or tracker has been introduced in version 1.2.0.
+
+One can disconnect any number of slots using the `signal::disconnect()` method,
+which proposes 4 overloads to specify the disconnection criterion:
+
+- The first takes a reference to a callable. Any kind of callable can be passed,
+  even pointers to member functions, function objects and lambdas,
+- The second takes a pointer to an object, for slots bound to a pointer to member
+  function, or a tracking object,
+- The third overload takes both kinds of arguments at the same time and can be
+  used to pinpoint a specific pair of object + callable.
+- The last overload takes a group id and disconnects all the slots in this group.
+
+Disconnection of lambdas is only possible for lambdas bound to a variable, due
+to their uniqueness.
+
+The second overload currently needs RTTI to disconnect from pointers to member
+functions, function objects and lambdas. This limitation does not apply to free
+and static member functions. The reasons stems from the fact that in C++, pointers
+to member functions of unrelated types are not comparable, contrary to pointers to
+free and static member functions. For instance, the pointer to member functions of
+virtual methods of different classes can have the same address (they kind of store
+the offset of the method into the vtable).
+
+However, Sigslot can be compiled with RTTI disabled and the overload will be
+deactivated for problematic cases.
+
+As a side node, this feature admittedly added more code than anticipated at first
+because it is a tricky and easy to get wrong. It has been designed carefully, with
+correctness in mind, and does not have any hidden costs unless you actually use it.
+
+Here is an example demonstrating the feature.
+
+```cpp
+#include <sigslot/signal.hpp>
+#include <string>
+
+static int i = 0;
+
+void f1() { i += 1; }
+void f2() { i += 1; }
+
+struct s {
+    void m1() { i += 1; }
+    void m2() { i += 1; }
+    void m3() { i += 1; }
+};
+
+struct o {
+    void operator()() { i += 1; }
+};
+
+int main() {
+    sigslot::signal<> sig;
+    s s1;
+    auto s2 = std::make_shared<s>();
+
+    auto lbd = [&] { i += 1; };
+
+    sig.connect(f1);           // #1
+    sig.connect(f2);           // #2
+    sig.connect(&s::m1, &s1);  // #3
+    sig.connect(&s::m2, &s1);  // #4
+    sig.connect(&s::m3, &s1);  // #5
+    sig.connect(&s::m1, s2);   // #6
+    sig.connect(&s::m2, s2);   // #7
+    sig.connect(o{});          // #8
+    sig.connect(lbd);          // #9
+
+    sig();  // i == 9
+
+    sig.disconnect(f2);              // #2 is removed
+    sig.disconnect(&s::m1);          // #3 and #6 are removed
+    sig.disconnect(o{});             // #8 and is removed
+ // sig.disconnect(&o::operator());  // same as the above, more efficient
+    sig.disconnect(lbd);             // #9 and is removed
+    sig.disconnect(s2);              // #7 is removed
+    sig.disconnect(&s::m3, &s1);     // #5 is removed, not #4
+
+    sig();  // i == 11
+
+    sig.disconnect_all();         // remove all remaining slots
+    return 0;
+}
+```
+
+### Enforcing slot invocation order with slot groups
+
+From version 1.2.0, slots can be assigned a group id in order to control the
+relative order of invocation of slots.
+
+The order of invocation of slots in a same group is unspecified and should not be
+relied upon, however slot groups are invoked in ascending group id order.
+When the group id of a slot is not set, it is assigned to the group 0.
+Group ids can have any value in the range of signed 32 bit integers.
+
+```cpp
+#include <sigslot/signal.hpp>
+#include <cstdio>
+#include <limits>
+
+int main() {
+    sigslot::signal<> sig;
+
+    // simply assigning a group id as last argument to connect
+    sig.connect([] { std::puts("Second"); }, 1);
+    sig.connect([] { std::puts("Last"); }, std::numeric_limits<sigslot::group_id>::max());
+    sig.connect([] { std::puts("First"); }, -10);
+    sig();
+
+    return 0;
+}
+```
+
+### Thread safety
+
+Thread safety is unit-tested. In particular, cross-signal emission and recursive
+emission run fine in a multiple threads scenario.
+
+`sigslot::signal` is a typedef to the more general `sigslot::signal_base` template
+class, whose first template argument must be a Lockable type. This type will dictate
+the locking policy of the class.
+
+Sigslot offers 2 typedefs,
+
+- `sigslot::signal` usable from multiple threads and uses std::mutex as a lockable.
+  In particular, connection, disconnection, emission and slot execution are thread
+  safe. It is also safe with recursive signal emission.
+- `sigslot::signal_st` is a non thread-safe alternative, it trades safety for slightly
+  faster operation.
+
+
+## Implementation details
+
+### Using function pointers to disconnect slots
+
+Comparing function pointers is a nightmare in C++. Here is a table demonstrating
+the size and address of a variety of cases as a showcase:
+
+```cpp
+void fun() {}
+
+struct b1 {
+    virtual ~b1() = default;
+    static void sm() {}
+    void m() {}
+    virtual void vm() {}
+};
+
+struct b2 {
+    virtual ~b2() = default;
+    static void sm() {}
+    void m() {}
+    virtual void vm() {}
+};
+
+struct c {
+    virtual ~c() = default;
+    virtual void w() {}
+};
+
+struct d : b1 {
+    static void sm() {}
+    void m() {}
+    void vm() override {}
+};
+
+struct e : b1, c {
+    static void sm() {}
+    void m() {}
+    void vm() override{}
+};
+```
+
+| Symbol  | GCC 9 Linux 64<br>Sizeof | GCC 9 Linux 64<br>Address | MSVC 16.6 32<br>Sizeof | MSVC 16.6 32<br>Address | GCC 8 Mingw 32<br>Sizeof | GCC 8 Mingw 32<br>Address | Clang-cl 9 32<br>Sizeof | Clang-cl 9 32<br>Address |
+|---------|--------------------------|---------------------------|------------------------|-------------------------|--------------------------|---------------------------|-------------------------|--------------------------|
+| fun     | 8                        | 0x802340                  | 4                      | 0x1311A6                | 4                        | 0xF41540                  | 4                       | 0x0010AE                 |
+| &b1::sm | 8                        | 0xE03140                  | 4                      | 0x7612A5                | 4                        | 0x308D40                  | 4                       | 0x0010AE                 |
+| &b1::m  | 16                       | 0xF03240                  | 4                      | 0x1514A5                | 8                        | 0x248D40                  | 4                       | 0x0010AE                 |
+| &b1::vm | 16                       | 0x11                      | 4                      | 0x9F11A5                | 8                        | 0x09                      | 4                       | 0x8023AE                 |
+| &b2::sm | 8                        | 0x003340                  | 4                      | 0xA515A5                | 4                        | 0x408D40                  | 4                       | 0x0010AE                 |
+| &b2::m  | 16                       | 0x103440                  | 4                      | 0xEB10A5                | 8                        | 0x348D40                  | 4                       | 0x0010AE                 |
+| &b2::vm | 16                       | 0x11                      | 4                      | 0x6A14A5                | 8                        | 0x09                      | 4                       | 0x8023AE                 |
+| &d::sm  | 8                        | 0x203440                  | 4                      | 0x2612A5                | 4                        | 0x108D40                  | 4                       | 0x0010AE                 |
+| &d::m   | 16                       | 0x303540                  | 4                      | 0x9D13A5                | 8                        | 0x048D40                  | 4                       | 0x0010AE                 |
+| &d::vm  | 16                       | 0x11                      | 4                      | 0x4412A5                | 8                        | 0x09                      | 4                       | 0x8023AE                 |
+| &e::sm  | 8                        | 0x403540                  | 4                      | 0xF911A5                | 4                        | 0x208D40                  | 4                       | 0x0010AE                 |
+| &e::m   | 16                       | 0x503640                  | 8                      | 0x8111A5                | 8                        | 0x148D40                  | 8                       | 0x0010AE                 |
+| &e::vm  | 16                       | 0x11                      | 8                      | 0xA911A5                | 8                        | 0x09                      | 8                       | 0x8023AE                 |
+
+MSVC and Clang-cl in Release mode optimize functions with the same definition by
+merging them. This is a behaviour that can be deactivated with the `/OPT:NOICF`
+linker option.
+Sigslot tests and examples rely on a lot a identical callables which trigger this
+behaviour, which is why it deactivates this particular optimization on the affected
+compilers.
+
+### Known bugs
+
+Using generic lambdas with GCC less than version 7.4 can trigger [Bug #68071](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=68071).

third-party/DPVO/Pangolin/components/pango_core/include/sigslot/signal.hpp

@@ -0,0 +1,1611 @@
+#pragma once
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <type_traits>
+#include <utility>
+#include <thread>
+#include <vector>
+
+#if defined __clang__ || (__GNUC__ > 5)
+#define SIGSLOT_MAY_ALIAS __attribute__((__may_alias__))
+#else
+#define SIGSLOT_MAY_ALIAS
+#endif
+
+#if defined(__GXX_RTTI) || defined(__cpp_rtti) || defined(_CPPRTTI)
+#define SIGSLOT_RTTI_ENABLED 1
+#include <typeinfo>
+#endif
+
+namespace sigslot {
+
+namespace detail {
+
+// Used to detect an object of observer type
+struct observer_type {};
+
+} // namespace detail
+
+namespace trait {
+
+/// represent a list of types
+template <typename...> struct typelist {};
+
+/**
+ * Pointers that can be converted to a weak pointer concept for tracking
+ * purpose must implement the to_weak() function in order to make use of
+ * ADL to convert that type and make it usable
+ */
+
+template <typename T>
+std::weak_ptr<T> to_weak(std::weak_ptr<T> w) {
+    return w;
+}
+
+template <typename T>
+std::weak_ptr<T> to_weak(std::shared_ptr<T> s) {
+    return s;
+}
+
+// tools
+namespace detail {
+
+template <typename...>
+struct voider { using type = void; };
+
+// void_t from c++17
+template <typename...T>
+using void_t = typename detail::voider<T...>::type;
+
+template <typename, typename = void>
+struct has_call_operator : std::false_type {};
+
+template <typename F>
+struct has_call_operator<F, void_t<decltype(&std::remove_reference<F>::type::operator())>>
+    : std::true_type {};
+
+template <typename, typename, typename = void, typename = void>
+struct is_callable : std::false_type {};
+
+template <typename F, typename P, typename... T>
+struct is_callable<F, P, typelist<T...>,
+        void_t<decltype(((*std::declval<P>()).*std::declval<F>())(std::declval<T>()...))>>
+    : std::true_type {};
+
+template <typename F, typename... T>
+struct is_callable<F, typelist<T...>,
+        void_t<decltype(std::declval<F>()(std::declval<T>()...))>>
+    : std::true_type {};
+
+
+template <typename T, typename = void>
+struct is_weak_ptr : std::false_type {};
+
+template <typename T>
+struct is_weak_ptr<T, void_t<decltype(std::declval<T>().expired()),
+                             decltype(std::declval<T>().lock()),
+                             decltype(std::declval<T>().reset())>>
+    : std::true_type {};
+
+template <typename T, typename = void>
+struct is_weak_ptr_compatible : std::false_type {};
+
+template <typename T>
+struct is_weak_ptr_compatible<T, void_t<decltype(to_weak(std::declval<T>()))>>
+    : is_weak_ptr<decltype(to_weak(std::declval<T>()))> {};
+
+} // namespace detail
+
+static constexpr bool with_rtti =
+#ifdef SIGSLOT_RTTI_ENABLED
+        true;
+#else
+        false;
+#endif
+
+/// determine if a pointer is convertible into a "weak" pointer
+template <typename P>
+constexpr bool is_weak_ptr_compatible_v = detail::is_weak_ptr_compatible<std::decay_t<P>>::value;
+
+/// determine if a type T (Callable or Pmf) is callable with supplied arguments
+template <typename L, typename... T>
+constexpr bool is_callable_v = detail::is_callable<T..., L>::value;
+
+template <typename T>
+constexpr bool is_weak_ptr_v = detail::is_weak_ptr<T>::value;
+
+template <typename T>
+constexpr bool has_call_operator_v = detail::has_call_operator<T>::value;
+
+template <typename T>
+constexpr bool is_pointer_v = std::is_pointer<T>::value;
+
+template <typename T>
+constexpr bool is_func_v = std::is_function<T>::value;
+
+template <typename T>
+constexpr bool is_pmf_v = std::is_member_function_pointer<T>::value;
+
+template <typename T>
+constexpr bool is_observer_v = std::is_base_of<::sigslot::detail::observer_type,
+                                               std::remove_pointer_t<T>>::value;
+
+} // namespace trait
+
+template <typename, typename...>
+class signal_base;
+
+/**
+ * A group_id is used to identify a group of slots
+ */
+using group_id = std::int32_t;
+
+namespace detail {
+
+/**
+ * The following function_traits and object_pointer series of templates are
+ * used to circumvent the type-erasing that takes place in the slot_base
+ * implementations. They are used to compare the stored functions and objects
+ * with another one for disconnection purpose.
+ */
+
+/*
+ * Function pointers and member function pointers size differ from compiler to
+ * compiler, and for virtual members compared to non virtual members. On some
+ * compilers, multiple inheritance has an impact too. Hence, we form an union
+ * big enough to store any kind of function pointer.
+ */
+namespace mock {
+
+struct a { virtual ~a() = default; void f(); virtual void g(); };
+struct b { virtual ~b() = default; virtual void h(); };
+struct c : a, b { void g() override; };
+
+union fun_types {
+    decltype(&c::g) m;
+    decltype(&a::g) v;
+    decltype(&a::f) d;
+    void (*f)();
+    void *o;
+ };
+
+} // namespace mock
+
+/*
+ * This union is used to compare function pointers
+ * Generic callables cannot be compared. Here we compare pointers but there is
+ * no guarantee that this always works.
+ */
+union SIGSLOT_MAY_ALIAS func_ptr {
+    void* value() {
+        return &data[0];
+    }
+
+    const void* value() const {
+        return &data[0];
+    }
+
+    template <typename T>
+    T& value() {
+        return *static_cast<T*>(value());
+    }
+
+    template <typename T>
+    const T& value() const {
+        return *static_cast<const T*>(value());
+    }
+
+    inline explicit operator bool() const {
+        return value() != nullptr;
+    }
+
+    inline bool operator==(const func_ptr &o) const {
+        return std::equal(std::begin(data), std::end(data), std::begin(o.data));
+    }
+
+    mock::fun_types _;
+    char data[sizeof(mock::fun_types)];
+};
+
+
+template <typename T, typename = void>
+struct function_traits {
+    static void ptr(const T &/*t*/, func_ptr &d) {
+        d.value<std::nullptr_t>() = nullptr;
+    }
+
+    static constexpr bool is_disconnectable = false;
+    static constexpr bool must_check_object = true;
+};
+
+template <typename T>
+struct function_traits<T, std::enable_if_t<trait::is_func_v<T>>> {
+    static void ptr(T &t, func_ptr &d) {
+        d.value<T*>() = &t;
+    }
+
+    static constexpr bool is_disconnectable = true;
+    static constexpr bool must_check_object = false;
+};
+
+template <typename T>
+struct function_traits<T*, std::enable_if_t<trait::is_func_v<T>>> {
+    static void ptr(T *t, func_ptr &d) {
+        d.value<T*>() = t;
+    }
+
+    static constexpr bool is_disconnectable = true;
+    static constexpr bool must_check_object = false;
+};
+
+template <typename T>
+struct function_traits<T, std::enable_if_t<trait::is_pmf_v<T>>> {
+    static void ptr(const T &t, func_ptr &d) {
+        d.value<T>() = t;
+    }
+
+    static constexpr bool is_disconnectable = trait::with_rtti;
+    static constexpr bool must_check_object = true;
+};
+
+// for function objects, the assumption is that we are looking for the call operator
+template <typename T>
+struct function_traits<T, std::enable_if_t<trait::has_call_operator_v<T>>> {
+    using call_type = decltype(&std::remove_reference<T>::type::operator());
+
+    static void ptr(const T &/*t*/, func_ptr &d) {
+        function_traits<call_type>::ptr(&T::operator(), d);
+    }
+
+    static constexpr bool is_disconnectable = function_traits<call_type>::is_disconnectable;
+    static constexpr bool must_check_object = function_traits<call_type>::must_check_object;
+};
+
+template <typename T>
+func_ptr get_function_ptr(const T &t) {
+    func_ptr d;
+    std::uninitialized_fill(std::begin(d.data), std::end(d.data), '\0');
+    function_traits<std::decay_t<T>>::ptr(t, d);
+    return d;
+}
+
+/*
+ * obj_ptr is used to store a pointer to an object.
+ * The object_pointer traits are needed to handle trackable objects correctly,
+ * as they are likely to not be pointers.
+ */
+using obj_ptr = const void*;
+
+template <typename T>
+obj_ptr get_object_ptr(const T &t);
+
+template <typename T, typename = void>
+struct object_pointer {
+    static obj_ptr get(const T&) {
+        return nullptr;
+    }
+};
+
+template <typename T>
+struct object_pointer<T*, std::enable_if_t<trait::is_pointer_v<T*>>> {
+    static obj_ptr get(const T *t) {
+        return reinterpret_cast<obj_ptr>(t);
+    }
+};
+
+template <typename T>
+struct object_pointer<T, std::enable_if_t<trait::is_weak_ptr_v<T>>> {
+    static obj_ptr get(const T &t) {
+        auto p = t.lock();
+        return get_object_ptr(p);
+    }
+};
+
+template <typename T>
+struct object_pointer<T, std::enable_if_t<!trait::is_pointer_v<T> &&
+                                          !trait::is_weak_ptr_v<T> &&
+                                          trait::is_weak_ptr_compatible_v<T>>>
+{
+    static obj_ptr get(const T &t) {
+        return t ? reinterpret_cast<obj_ptr>(t.get()) : nullptr;
+    }
+};
+
+template <typename T>
+obj_ptr get_object_ptr(const T &t) {
+    return object_pointer<T>::get(t);
+}
+
+
+// noop mutex for thread-unsafe use
+struct null_mutex {
+    null_mutex() noexcept = default;
+    ~null_mutex() noexcept = default;
+    null_mutex(const null_mutex &) = delete;
+    null_mutex& operator=(const null_mutex &) = delete;
+    null_mutex(null_mutex &&) = delete;
+    null_mutex& operator=(null_mutex &&) = delete;
+
+    inline bool try_lock() noexcept { return true; }
+    inline void lock() noexcept {}
+    inline void unlock() noexcept {}
+};
+
+/**
+ * A spin mutex that yields, mostly for use in benchmarks and scenarii that invoke
+ * slots at a very high pace.
+ * One should almost always prefer a standard mutex over this.
+ */
+struct spin_mutex {
+    spin_mutex() noexcept = default;
+    ~spin_mutex() noexcept = default;
+    spin_mutex(spin_mutex const&) = delete;
+    spin_mutex& operator=(const spin_mutex &) = delete;
+    spin_mutex(spin_mutex &&) = delete;
+    spin_mutex& operator=(spin_mutex &&) = delete;
+
+    void lock() noexcept {
+        while (true) {
+            while (!state.load(std::memory_order_relaxed)) {
+                std::this_thread::yield();
+            }
+
+            if (try_lock()) {
+                break;
+            }
+        }
+    }
+
+    bool try_lock() noexcept {
+        return state.exchange(false, std::memory_order_acquire);
+    }
+
+    void unlock() noexcept {
+        state.store(true, std::memory_order_release);
+    }
+
+private:
+    std::atomic<bool> state {true};
+};
+
+/**
+ * A simple copy on write container that will be used to improve slot lists
+ * access efficiency in a multithreaded context.
+ */
+template <typename T>
+class copy_on_write {
+    struct payload {
+        payload() = default;
+
+        template <typename... Args>
+        explicit payload(Args && ...args)
+            : value(std::forward<Args>(args)...)
+        {}
+
+        std::atomic<std::size_t> count{1};
+        T value;
+    };
+
+public:
+    using element_type = T;
+
+    copy_on_write()
+        : m_data(new payload)
+    {}
+
+    template <typename U>
+    explicit copy_on_write(U && x, std::enable_if_t<!std::is_same<std::decay_t<U>,
+                           copy_on_write>::value>* = nullptr)
+        : m_data(new payload(std::forward<U>(x)))
+    {}
+
+    copy_on_write(const copy_on_write &x) noexcept
+        : m_data(x.m_data)
+    {
+        ++m_data->count;
+    }
+
+    copy_on_write(copy_on_write && x) noexcept
+        : m_data(x.m_data)
+    {
+        x.m_data = nullptr;
+    }
+
+    ~copy_on_write() {
+        if (m_data && (--m_data->count == 0)) {
+            delete m_data;
+        }
+    }
+
+    copy_on_write& operator=(const copy_on_write &x) noexcept {
+        if (&x != this) {
+            *this = copy_on_write(x);
+        }
+        return *this;
+    }
+
+    copy_on_write& operator=(copy_on_write && x) noexcept  {
+        auto tmp = std::move(x);
+        swap(*this, tmp);
+        return *this;
+    }
+
+    element_type& write() {
+        if (!unique()) {
+            *this = copy_on_write(read());
+        }
+        return m_data->value;
+    }
+
+    const element_type& read() const noexcept {
+        return m_data->value;
+    }
+
+    friend inline void swap(copy_on_write &x, copy_on_write &y) noexcept {
+        using std::swap;
+        swap(x.m_data, y.m_data);
+    }
+
+private:
+    bool unique() const noexcept {
+        return m_data->count == 1;
+    }
+
+private:
+    payload *m_data;
+};
+
+/**
+ * Specializations for thread-safe code path
+ */
+template <typename T>
+const T& cow_read(const T &v) {
+    return v;
+}
+
+template <typename T>
+const T& cow_read(copy_on_write<T> &v) {
+    return v.read();
+}
+
+template <typename T>
+T& cow_write(T &v) {
+    return v;
+}
+
+template <typename T>
+T& cow_write(copy_on_write<T> &v) {
+    return v.write();
+}
+
+/**
+ * std::make_shared instantiates a lot a templates, and makes both compilation time
+ * and executable size far bigger than they need to be. We offer a make_shared
+ * equivalent that will avoid most instantiations with the following tradeoffs:
+ * - Not exception safe,
+ * - Allocates a separate control block, and will thus make the code slower.
+ */
+#ifdef SIGSLOT_REDUCE_COMPILE_TIME
+template <typename B, typename D, typename ...Arg>
+inline std::shared_ptr<B> make_shared(Arg && ... arg) {
+    return std::shared_ptr<B>(static_cast<B*>(new D(std::forward<Arg>(arg)...)));
+}
+#else
+template <typename B, typename D, typename ...Arg>
+inline std::shared_ptr<B> make_shared(Arg && ... arg) {
+    return std::static_pointer_cast<B>(std::make_shared<D>(std::forward<Arg>(arg)...));
+}
+#endif
+
+/* slot_state holds slot type independent state, to be used to interact with
+ * slots indirectly through connection and scoped_connection objects.
+ */
+class slot_state {
+public:
+    constexpr slot_state(group_id gid) noexcept
+        : m_index(0)
+        , m_group(gid)
+        , m_connected(true)
+        , m_blocked(false)
+    {}
+
+    virtual ~slot_state() = default;
+
+    virtual bool connected() const noexcept { return m_connected; }
+
+    bool disconnect() noexcept {
+        bool ret = m_connected.exchange(false);
+        if (ret) {
+            do_disconnect();
+        }
+        return ret;
+    }
+
+    bool blocked() const noexcept { return m_blocked.load(); }
+    void block()   noexcept { m_blocked.store(true); }
+    void unblock() noexcept { m_blocked.store(false); }
+
+protected:
+    virtual void do_disconnect() {}
+
+    auto index() const {
+        return m_index;
+    }
+
+    auto& index() {
+        return m_index;
+    }
+
+    group_id group() const {
+        return m_group;
+    }
+
+private:
+    template <typename, typename...>
+    friend class ::sigslot::signal_base;
+
+    std::size_t m_index;     // index into the array of slot pointers inside the signal
+    const group_id m_group;  // slot group this slot belongs to
+    std::atomic<bool> m_connected;
+    std::atomic<bool> m_blocked;
+};
+
+} // namespace detail
+
+/**
+ * connection_blocker is a RAII object that blocks a connection until destruction
+ */
+class connection_blocker {
+public:
+    connection_blocker() = default;
+    ~connection_blocker() noexcept { release(); }
+
+    connection_blocker(const connection_blocker &) = delete;
+    connection_blocker & operator=(const connection_blocker &) = delete;
+
+    connection_blocker(connection_blocker && o) noexcept
+        : m_state{std::move(o.m_state)}
+    {}
+
+    connection_blocker & operator=(connection_blocker && o) noexcept {
+        release();
+        m_state.swap(o.m_state);
+        return *this;
+    }
+
+private:
+    friend class connection;
+    explicit connection_blocker(std::weak_ptr<detail::slot_state> s) noexcept
+        : m_state{std::move(s)}
+    {
+        if (auto d = m_state.lock()) {
+            d->block();
+        }
+    }
+
+    void release() noexcept {
+        if (auto d = m_state.lock()) {
+            d->unblock();
+        }
+    }
+
+private:
+    std::weak_ptr<detail::slot_state> m_state;
+};
+
+
+/**
+ * A connection object allows interaction with an ongoing slot connection
+ *
+ * It allows common actions such as connection blocking and disconnection.
+ * Note that connection is not a RAII object, one does not need to hold one
+ * such object to keep the signal-slot connection alive.
+ */
+class connection {
+public:
+    connection() = default;
+    virtual ~connection() = default;
+
+    connection(const connection &) noexcept = default;
+    connection & operator=(const connection &) noexcept = default;
+    connection(connection &&) noexcept = default;
+    connection & operator=(connection &&) noexcept = default;
+
+    bool valid() const noexcept {
+        return !m_state.expired();
+    }
+
+    bool connected() const noexcept {
+        const auto d = m_state.lock();
+        return d && d->connected();
+    }
+
+    bool disconnect() noexcept {
+        auto d = m_state.lock();
+        return d && d->disconnect();
+    }
+
+    bool blocked() const noexcept {
+        const auto d = m_state.lock();
+        return d && d->blocked();
+    }
+
+    void block() noexcept {
+        if (auto d = m_state.lock()) {
+            d->block();
+        }
+    }
+
+    void unblock() noexcept {
+        if (auto d = m_state.lock()) {
+            d->unblock();
+        }
+    }
+
+    connection_blocker blocker() const noexcept {
+        return connection_blocker{m_state};
+    }
+
+protected:
+    template <typename, typename...> friend class signal_base;
+    explicit connection(std::weak_ptr<detail::slot_state> s) noexcept
+        : m_state{std::move(s)}
+    {}
+
+protected:
+    std::weak_ptr<detail::slot_state> m_state;
+};
+
+/**
+ * scoped_connection is a RAII version of connection
+ * It disconnects the slot from the signal upon destruction.
+ */
+class scoped_connection final : public connection {
+public:
+    scoped_connection() = default;
+    ~scoped_connection() override {
+        disconnect();
+    }
+
+    /*implicit*/ scoped_connection(const connection &c) noexcept : connection(c) {}
+    /*implicit*/ scoped_connection(connection &&c) noexcept : connection(std::move(c)) {}
+
+    scoped_connection(const scoped_connection &) noexcept = delete;
+    scoped_connection & operator=(const scoped_connection &) noexcept = delete;
+
+    scoped_connection(scoped_connection && o) noexcept
+        : connection{std::move(o.m_state)}
+    {}
+
+    scoped_connection & operator=(scoped_connection && o) noexcept {
+        disconnect();
+        m_state.swap(o.m_state);
+        return *this;
+    }
+
+private:
+    template <typename, typename...> friend class signal_base;
+    explicit scoped_connection(std::weak_ptr<detail::slot_state> s) noexcept
+        : connection{std::move(s)}
+    {}
+};
+
+/**
+ * Observer is a base class for intrusive lifetime tracking of objects.
+ *
+ * This is an alternative to trackable pointers, such as std::shared_ptr,
+ * and manual connection management by keeping connection objects in scope.
+ * Deriving from this class allows automatic disconnection of all the slots
+ * connected to any signal when an instance is destroyed.
+ */
+template <typename Lockable>
+struct observer_base : private detail::observer_type {
+    virtual ~observer_base() = default;
+
+protected:
+    /**
+     * Disconnect all signals connected to this object.
+     *
+     * To avoid invocation of slots on a semi-destructed instance, which may happen
+     * in multi-threaded contexts, derived classes should call this method in their
+     * destructor. This will ensure proper disconnection prior to the destruction.
+     */
+    void disconnect_all() {
+        std::unique_lock<Lockable> _{m_mutex};
+        m_connections.clear();
+    }
+
+private:
+    template <typename, typename ...>
+    friend class signal_base;
+
+    void add_connection(connection conn) {
+        std::unique_lock<Lockable> _{m_mutex};
+        m_connections.emplace_back(std::move(conn));
+    }
+
+    Lockable m_mutex;
+    std::vector<scoped_connection> m_connections;
+};
+
+/**
+ * Specialization of observer_base to be used in single threaded contexts.
+ */
+using observer_st = observer_base<detail::null_mutex>;
+
+/**
+ * Specialization of observer_base to be used in multi-threaded contexts.
+ */
+using observer = observer_base<std::mutex>;
+
+
+namespace detail {
+
+// interface for cleanable objects, used to cleanup disconnected slots
+struct cleanable {
+    virtual ~cleanable() = default;
+    virtual void clean(slot_state *) = 0;
+};
+
+template <typename...>
+class slot_base;
+
+template <typename... T>
+using slot_ptr = std::shared_ptr<slot_base<T...>>;
+
+
+/* A base class for slot objects. This base type only depends on slot argument
+ * types, it will be used as an element in an intrusive singly-linked list of
+ * slots, hence the public next member.
+ */
+template <typename... Args>
+class slot_base : public slot_state {
+public:
+    using base_types = trait::typelist<Args...>;
+
+    explicit slot_base(cleanable &c, group_id gid)
+        : slot_state(gid)
+        , cleaner(c)
+    {}
+    ~slot_base() override = default;
+
+    // method effectively responsible for calling the "slot" function with
+    // supplied arguments whenever emission happens.
+    virtual void call_slot(Args...) = 0;
+
+    template <typename... U>
+    void operator()(U && ...u) {
+        if (slot_state::connected() && !slot_state::blocked()) {
+            call_slot(std::forward<U>(u)...);
+        }
+    }
+
+    // check if we are storing callable c
+    template <typename C>
+    bool has_callable(const C &c) const {
+        auto cp = get_function_ptr(c);
+        auto p = get_callable();
+        return cp && p && cp == p;
+    }
+
+    template <typename C>
+    std::enable_if_t<function_traits<C>::must_check_object, bool>
+    has_full_callable(const C &c) const {
+        return has_callable(c) && check_class_type<std::decay_t<C>>();
+    }
+
+    template <typename C>
+    std::enable_if_t<!function_traits<C>::must_check_object, bool>
+    has_full_callable(const C &c) const {
+        return has_callable(c);
+    }
+
+    // check if we are storing object o
+    template <typename O>
+    bool has_object(const O &o) const {
+        return get_object() == get_object_ptr(o);
+    }
+
+protected:
+    void do_disconnect() final {
+        cleaner.clean(this);
+    }
+
+    // retieve a pointer to the object embedded in the slot
+    virtual obj_ptr get_object() const noexcept {
+        return nullptr;
+    }
+
+    // retieve a pointer to the callable embedded in the slot
+    virtual func_ptr get_callable() const noexcept {
+        return get_function_ptr(nullptr);
+    }
+
+#ifdef SIGSLOT_RTTI_ENABLED
+    // retieve a pointer to the callable embedded in the slot
+    virtual const std::type_info& get_callable_type() const noexcept {
+        return typeid(nullptr);
+    }
+
+private:
+    template <typename U>
+    bool check_class_type() const {
+        return typeid(U) == get_callable_type();
+    }
+
+#else
+    template <typename U>
+    bool check_class_type() const {
+        return false;
+    }
+#endif
+
+private:
+    cleanable &cleaner;
+};
+
+/*
+ * A slot object holds state information, and a callable to to be called
+ * whenever the function call operator of its slot_base base class is called.
+ */
+template <typename Func, typename... Args>
+class slot final : public slot_base<Args...> {
+public:
+    template <typename F, typename Gid>
+    constexpr slot(cleanable &c, F && f, Gid gid)
+        : slot_base<Args...>(c, gid)
+        , func{std::forward<F>(f)} {}
+
+protected:
+    void call_slot(Args ...args) override {
+        func(args...);
+    }
+
+    func_ptr get_callable() const noexcept override {
+        return get_function_ptr(func);
+    }
+
+#ifdef SIGSLOT_RTTI_ENABLED
+    const std::type_info& get_callable_type() const noexcept override {
+        return typeid(func);
+    }
+#endif
+
+private:
+    std::decay_t<Func> func;
+};
+
+/*
+ * Variation of slot that prepends a connection object to the callable
+ */
+template <typename Func, typename... Args>
+class slot_extended final : public slot_base<Args...> {
+public:
+    template <typename F>
+    constexpr slot_extended(cleanable &c, F && f, group_id gid)
+        : slot_base<Args...>(c, gid)
+        , func{std::forward<F>(f)} {}
+
+    connection conn;
+
+protected:
+    void call_slot(Args ...args) override {
+        func(conn, args...);
+    }
+
+    func_ptr get_callable() const noexcept override {
+        return get_function_ptr(func);
+    }
+
+#ifdef SIGSLOT_RTTI_ENABLED
+    const std::type_info& get_callable_type() const noexcept override {
+        return typeid(func);
+    }
+#endif
+
+private:
+    std::decay_t<Func> func;
+};
+
+/*
+ * A slot object holds state information, an object and a pointer over member
+ * function to be called whenever the function call operator of its slot_base
+ * base class is called.
+ */
+template <typename Pmf, typename Ptr, typename... Args>
+class slot_pmf final : public slot_base<Args...> {
+public:
+    template <typename F, typename P>
+    constexpr slot_pmf(cleanable &c, F && f, P && p, group_id gid)
+        : slot_base<Args...>(c, gid)
+        , pmf{std::forward<F>(f)}
+        , ptr{std::forward<P>(p)} {}
+
+protected:
+    void call_slot(Args ...args) override {
+        ((*ptr).*pmf)(args...);
+    }
+
+    func_ptr get_callable() const noexcept override {
+        return get_function_ptr(pmf);
+    }
+
+    obj_ptr get_object() const noexcept override {
+        return get_object_ptr(ptr);
+    }
+
+#ifdef SIGSLOT_RTTI_ENABLED
+    const std::type_info& get_callable_type() const noexcept override {
+        return typeid(pmf);
+    }
+#endif
+
+private:
+    std::decay_t<Pmf> pmf;
+    std::decay_t<Ptr> ptr;
+};
+
+/*
+ * Variation of slot that prepends a connection object to the callable
+ */
+template <typename Pmf, typename Ptr, typename... Args>
+class slot_pmf_extended final : public slot_base<Args...> {
+public:
+    template <typename F, typename P>
+    constexpr slot_pmf_extended(cleanable &c, F && f, P && p, group_id gid)
+        : slot_base<Args...>(c, gid)
+        , pmf{std::forward<F>(f)}
+        , ptr{std::forward<P>(p)} {}
+
+    connection conn;
+
+protected:
+    void call_slot(Args ...args) override {
+        ((*ptr).*pmf)(conn, args...);
+    }
+
+    func_ptr get_callable() const noexcept override {
+        return get_function_ptr(pmf);
+    }
+    obj_ptr get_object() const noexcept override {
+        return get_object_ptr(ptr);
+    }
+
+#ifdef SIGSLOT_RTTI_ENABLED
+    const std::type_info& get_callable_type() const noexcept override {
+        return typeid(pmf);
+    }
+#endif
+
+private:
+    std::decay_t<Pmf> pmf;
+    std::decay_t<Ptr> ptr;
+};
+
+/*
+ * An implementation of a slot that tracks the life of a supplied object
+ * through a weak pointer in order to automatically disconnect the slot
+ * on said object destruction.
+ */
+template <typename Func, typename WeakPtr, typename... Args>
+class slot_tracked final : public slot_base<Args...> {
+public:
+    template <typename F, typename P>
+    constexpr slot_tracked(cleanable &c, F && f, P && p, group_id gid)
+        : slot_base<Args...>(c, gid)
+        , func{std::forward<F>(f)}
+        , ptr{std::forward<P>(p)}
+    {}
+
+    bool connected() const noexcept override {
+        return !ptr.expired() && slot_state::connected();
+    }
+
+protected:
+    void call_slot(Args ...args) override {
+        auto sp = ptr.lock();
+        if (!sp) {
+            slot_state::disconnect();
+            return;
+        }
+        if (slot_state::connected()) {
+            func(args...);
+        }
+    }
+
+    func_ptr get_callable() const noexcept override {
+        return get_function_ptr(func);
+    }
+
+    obj_ptr get_object() const noexcept override {
+        return get_object_ptr(ptr);
+    }
+
+#ifdef SIGSLOT_RTTI_ENABLED
+    const std::type_info& get_callable_type() const noexcept override {
+        return typeid(func);
+    }
+#endif
+
+private:
+    std::decay_t<Func> func;
+    std::decay_t<WeakPtr> ptr;
+};
+
+/*
+ * An implementation of a slot as a pointer over member function, that tracks
+ * the life of a supplied object through a weak pointer in order to automatically
+ * disconnect the slot on said object destruction.
+ */
+template <typename Pmf, typename WeakPtr, typename... Args>
+class slot_pmf_tracked final : public slot_base<Args...> {
+public:
+    template <typename F, typename P>
+    constexpr slot_pmf_tracked(cleanable &c, F && f, P && p, group_id gid)
+        : slot_base<Args...>(c, gid)
+        , pmf{std::forward<F>(f)}
+        , ptr{std::forward<P>(p)}
+    {}
+
+    bool connected() const noexcept override {
+        return !ptr.expired() && slot_state::connected();
+    }
+
+protected:
+    void call_slot(Args ...args) override {
+        auto sp = ptr.lock();
+        if (!sp) {
+            slot_state::disconnect();
+            return;
+        }
+        if (slot_state::connected()) {
+            ((*sp).*pmf)(args...);
+        }
+    }
+
+    func_ptr get_callable() const noexcept override {
+        return get_function_ptr(pmf);
+    }
+
+    obj_ptr get_object() const noexcept override {
+        return get_object_ptr(ptr);
+    }
+
+#ifdef SIGSLOT_RTTI_ENABLED
+    const std::type_info& get_callable_type() const noexcept override {
+        return typeid(pmf);
+    }
+#endif
+
+private:
+    std::decay_t<Pmf> pmf;
+    std::decay_t<WeakPtr> ptr;
+};
+
+} // namespace detail
+
+
+/**
+ * signal_base is an implementation of the observer pattern, through the use
+ * of an emitting object and slots that are connected to the signal and called
+ * with supplied arguments when a signal is emitted.
+ *
+ * signal_base is the general implementation, whose locking policy must be
+ * set in order to decide thread safety guarantees. signal and signal_st
+ * are partial specializations for multi-threaded and single-threaded use.
+ *
+ * It does not allow slots to return a value.
+ *
+ * Slot execution order can be constrained by assigning group ids to the slots.
+ * The execution order of slots in a same group is unspecified and should not be
+ * relied upon, however groups are executed in ascending group ids order. When
+ * the group id of a slot is not set, it is assigned to the group 0. Group ids
+ * can have any value in the range of signed 32 bit integers.
+ *
+ * @tparam Lockable a lock type to decide the lock policy
+ * @tparam T... the argument types of the emitting and slots functions.
+ */
+template <typename Lockable, typename... T>
+class signal_base final : public detail::cleanable {
+    template <typename L>
+    using is_thread_safe = std::integral_constant<bool, !std::is_same<L, detail::null_mutex>::value>;
+
+    template <typename U, typename L>
+    using cow_type = std::conditional_t<is_thread_safe<L>::value,
+                                        detail::copy_on_write<U>, U>;
+
+    template <typename U, typename L>
+    using cow_copy_type = std::conditional_t<is_thread_safe<L>::value,
+                                             detail::copy_on_write<U>, const U&>;
+
+    using lock_type = std::unique_lock<Lockable>;
+    using slot_base = detail::slot_base<T...>;
+    using slot_ptr = detail::slot_ptr<T...>;
+    using slots_type = std::vector<slot_ptr>;
+    struct group_type { slots_type slts; group_id gid; };
+    using list_type = std::vector<group_type>;  // kept ordered by ascending gid
+
+public:
+    using arg_list = trait::typelist<T...>;
+    using ext_arg_list = trait::typelist<connection&, T...>;
+
+    signal_base() noexcept : m_block(false) {}
+    ~signal_base() override {
+        disconnect_all();
+    }
+
+    signal_base(const signal_base&) = delete;
+    signal_base & operator=(const signal_base&) = delete;
+
+    signal_base(signal_base && o) /* not noexcept */
+        : m_block{o.m_block.load()}
+    {
+        lock_type lock(o.m_mutex);
+        using std::swap;
+        swap(m_slots, o.m_slots);
+    }
+
+    signal_base & operator=(signal_base && o) /* not noexcept */ {
+        lock_type lock1(m_mutex, std::defer_lock);
+        lock_type lock2(o.m_mutex, std::defer_lock);
+        std::lock(lock1, lock2);
+
+        using std::swap;
+        swap(m_slots, o.m_slots);
+        m_block.store(o.m_block.exchange(m_block.load()));
+        return *this;
+    }
+
+    /**
+     * Emit a signal
+     *
+     * Effect: All non blocked and connected slot functions will be called
+     *         with supplied arguments.
+     * Safety: With proper locking (see pal::signal), emission can happen from
+     *         multiple threads simultaneously. The guarantees only apply to the
+     *         signal object, it does not cover thread safety of potentially
+     *         shared state used in slot functions.
+     *
+     * @param a... arguments to emit
+     */
+    template <typename... U>
+    void operator()(U && ...a) {
+        if (m_block) {
+            return;
+        }
+
+        // Reference to the slots to execute them out of the lock
+        // a copy may occur if another thread writes to it.
+        cow_copy_type<list_type, Lockable> ref = slots_reference();
+
+        for (const auto &group : detail::cow_read(ref)) {
+            for (const auto &s : group.slts) {
+                s->operator()(a...);
+            }
+        }
+    }
+
+    /**
+     * Connect a callable of compatible arguments
+     *
+     * Effect: Creates and stores a new slot responsible for executing the
+     *         supplied callable for every subsequent signal emission.
+     * Safety: Thread-safety depends on locking policy.
+     *
+     * @param c a callable
+     * @param gid an identifier that can be used to order slot execution
+     * @return a connection object that can be used to interact with the slot
+     */
+    template <typename Callable>
+    std::enable_if_t<trait::is_callable_v<arg_list, Callable>, connection>
+    connect(Callable && c, group_id gid = 0) {
+        using slot_t = detail::slot<Callable, T...>;
+        auto s = make_slot<slot_t>(std::forward<Callable>(c), gid);
+        connection conn(s);
+        add_slot(std::move(s));
+        return conn;
+    }
+
+    /**
+     * Connect a callable with an additional connection argument
+     *
+     * The callable's first argument must be of type connection. This overload
+     * the callable to manage it's own connection through this argument.
+     *
+     * @param c a callable
+     * @param gid an identifier that can be used to order slot execution
+     * @return a connection object that can be used to interact with the slot
+     */
+    template <typename Callable>
+    std::enable_if_t<trait::is_callable_v<ext_arg_list, Callable>, connection>
+    connect_extended(Callable && c, group_id gid = 0) {
+        using slot_t = detail::slot_extended<Callable, T...>;
+        auto s = make_slot<slot_t>(std::forward<Callable>(c), gid);
+        connection conn(s);
+        std::static_pointer_cast<slot_t>(s)->conn = conn;
+        add_slot(std::move(s));
+        return conn;
+    }
+
+    /**
+     * Overload of connect for pointers over member functions derived from
+     * observer
+     *
+     * @param pmf a pointer over member function
+     * @param ptr an object pointer derived from observer
+     * @param gid an identifier that can be used to order slot execution
+     * @return a connection object that can be used to interact with the slot
+     */
+    template <typename Pmf, typename Ptr>
+    std::enable_if_t<trait::is_callable_v<arg_list, Pmf, Ptr> &&
+                     trait::is_observer_v<Ptr>, connection>
+    connect(Pmf && pmf, Ptr && ptr, group_id gid = 0) {
+        using slot_t = detail::slot_pmf<Pmf, Ptr, T...>;
+        auto s = make_slot<slot_t>(std::forward<Pmf>(pmf), std::forward<Ptr>(ptr), gid);
+        connection conn(s);
+        add_slot(std::move(s));
+        ptr->add_connection(conn);
+        return conn;
+    }
+
+    /**
+     * Overload of connect for pointers over member functions
+     *
+     * @param pmf a pointer over member function
+     * @param ptr an object pointer
+     * @param gid an identifier that can be used to order slot execution
+     * @return a connection object that can be used to interact with the slot
+     */
+    template <typename Pmf, typename Ptr>
+    std::enable_if_t<trait::is_callable_v<arg_list, Pmf, Ptr> &&
+                     !trait::is_observer_v<Ptr> &&
+                     !trait::is_weak_ptr_compatible_v<Ptr>, connection>
+    connect(Pmf && pmf, Ptr && ptr, group_id gid = 0) {
+        using slot_t = detail::slot_pmf<Pmf, Ptr, T...>;
+        auto s = make_slot<slot_t>(std::forward<Pmf>(pmf), std::forward<Ptr>(ptr), gid);
+        connection conn(s);
+        add_slot(std::move(s));
+        return conn;
+    }
+
+    /**
+     * Overload  of connect for pointer over member functions and
+     *
+     * @param pmf a pointer over member function
+     * @param ptr an object pointer
+     * @param gid an identifier that can be used to order slot execution
+     * @return a connection object that can be used to interact with the slot
+     */
+    template <typename Pmf, typename Ptr>
+    std::enable_if_t<trait::is_callable_v<ext_arg_list, Pmf, Ptr> &&
+                     !trait::is_weak_ptr_compatible_v<Ptr>, connection>
+    connect_extended(Pmf && pmf, Ptr && ptr, group_id gid = 0) {
+        using slot_t = detail::slot_pmf_extended<Pmf, Ptr, T...>;
+        auto s = make_slot<slot_t>(std::forward<Pmf>(pmf), std::forward<Ptr>(ptr), gid);
+        connection conn(s);
+        std::static_pointer_cast<slot_t>(s)->conn = conn;
+        add_slot(std::move(s));
+        return conn;
+    }
+
+    /**
+     * Overload of connect for lifetime object tracking and automatic disconnection
+     *
+     * Ptr must be convertible to an object following a loose form of weak pointer
+     * concept, by implementing the ADL-detected conversion function to_weak().
+     *
+     * This overload covers the case of a pointer over member function and a
+     * trackable pointer of that class.
+     *
+     * Note: only weak references are stored, a slot does not extend the lifetime
+     * of a suppied object.
+     *
+     * @param pmf a pointer over member function
+     * @param ptr a trackable object pointer
+     * @param gid an identifier that can be used to order slot execution
+     * @return a connection object that can be used to interact with the slot
+     */
+    template <typename Pmf, typename Ptr>
+    std::enable_if_t<!trait::is_callable_v<arg_list, Pmf> &&
+                     trait::is_weak_ptr_compatible_v<Ptr>, connection>
+    connect(Pmf && pmf, Ptr && ptr, group_id gid = 0) {
+        using trait::to_weak;
+        auto w = to_weak(std::forward<Ptr>(ptr));
+        using slot_t = detail::slot_pmf_tracked<Pmf, decltype(w), T...>;
+        auto s = make_slot<slot_t>(std::forward<Pmf>(pmf), w, gid);
+        connection conn(s);
+        add_slot(std::move(s));
+        return conn;
+    }
+
+    /**
+     * Overload of connect for lifetime object tracking and automatic disconnection
+     *
+     * Trackable must be convertible to an object following a loose form of weak
+     * pointer concept, by implementing the ADL-detected conversion function to_weak().
+     *
+     * This overload covers the case of a standalone callable and unrelated trackable
+     * object.
+     *
+     * Note: only weak references are stored, a slot does not extend the lifetime
+     * of a suppied object.
+     *
+     * @param c a callable
+     * @param ptr a trackable object pointer
+     * @param gid an identifier that can be used to order slot execution
+     * @return a connection object that can be used to interact with the slot
+     */
+    template <typename Callable, typename Trackable>
+    std::enable_if_t<trait::is_callable_v<arg_list, Callable> &&
+                     trait::is_weak_ptr_compatible_v<Trackable>, connection>
+    connect(Callable && c, Trackable && ptr, group_id gid = 0) {
+        using trait::to_weak;
+        auto w = to_weak(std::forward<Trackable>(ptr));
+        using slot_t = detail::slot_tracked<Callable, decltype(w), T...>;
+        auto s = make_slot<slot_t>(std::forward<Callable>(c), w, gid);
+        connection conn(s);
+        add_slot(std::move(s));
+        return conn;
+    }
+
+    /**
+     * Creates a connection whose duration is tied to the return object
+     * Use the same semantics as connect
+     */
+    template <typename... CallArgs>
+    scoped_connection connect_scoped(CallArgs && ...args) {
+        return connect(std::forward<CallArgs>(args)...);
+    }
+
+    /**
+     * Disconnect slots bound to a callable
+     *
+     * Effect: Disconnects all the slots bound to the callable in argument.
+     * Safety: Thread-safety depends on locking policy.
+     *
+     * If the callable is a free or static member function, this overload is always
+     * available. However, RTTI is needed for it to work for pointer to member
+     * functions, function objects or and (references to) lambdas, because the
+     * C++ spec does not mandate the pointers to member functions to be unique.
+     *
+     * @param c a callable
+     * @return the number of disconnected slots
+     */
+    template <typename Callable>
+    std::enable_if_t<(trait::is_callable_v<arg_list, Callable> ||
+                      trait::is_callable_v<ext_arg_list, Callable> ||
+                      trait::is_pmf_v<Callable>) &&
+                     detail::function_traits<Callable>::is_disconnectable, size_t>
+    disconnect(const Callable &c) {
+        return disconnect_if([&] (const auto &s) {
+            return s->has_full_callable(c);
+        });
+    }
+
+    /**
+     * Disconnect slots bound to this object
+     *
+     * Effect: Disconnects all the slots bound to the object or tracked object
+     *         in argument.
+     * Safety: Thread-safety depends on locking policy.
+     *
+     * The object may be a pointer or trackable object.
+     *
+     * @param obj an object
+     * @return the number of disconnected slots
+     */
+    template <typename Obj>
+    std::enable_if_t<!trait::is_callable_v<arg_list, Obj> &&
+                     !trait::is_callable_v<ext_arg_list, Obj> &&
+                     !trait::is_pmf_v<Obj>, size_t>
+    disconnect(const Obj &obj) {
+        return disconnect_if([&] (const auto &s) {
+            return s->has_object(obj);
+        });
+    }
+
+    /**
+     * Disconnect slots bound both to a callable and object
+     *
+     * Effect: Disconnects all the slots bound to the callable and object in argument.
+     * Safety: Thread-safety depends on locking policy.
+     *
+     * For naked pointers, the Callable is expected to be a pointer over member
+     * function. If obj is trackable, any kind of Callable can be used.
+     *
+     * @param c a callable
+     * @param obj an object
+     * @return the number of disconnected slots
+     */
+    template <typename Callable, typename Obj>
+    size_t disconnect(const Callable &c, const Obj &obj) {
+        return disconnect_if([&] (const auto &s) {
+            return s->has_object(obj) && s->has_callable(c);
+        });
+    }
+
+    /**
+     * Disconnect slots in a particular group
+     *
+     * Effect: Disconnects all the slots in the group id in argument.
+     * Safety: Thread-safety depends on locking policy.
+     *
+     * @param gid a group id
+     * @return the number of disconnected slots
+     */
+    size_t disconnect(group_id gid) {
+        lock_type lock(m_mutex);
+        for (auto &group : detail::cow_write(m_slots)) {
+            if (group.gid == gid) {
+                size_t count = group.slts.size();
+                group.slts.clear();
+                return count;
+            }
+        }
+        return 0;
+    }
+
+    /**
+     * Disconnects all the slots
+     * Safety: Thread safety depends on locking policy
+     */
+    void disconnect_all() {
+        lock_type lock(m_mutex);
+        clear();
+    }
+
+    /**
+     * Blocks signal emission
+     * Safety: thread safe
+     */
+    void block() noexcept {
+        m_block.store(true);
+    }
+
+    /**
+     * Unblocks signal emission
+     * Safety: thread safe
+     */
+    void unblock() noexcept {
+        m_block.store(false);
+    }
+
+    /**
+     * Tests blocking state of signal emission
+     */
+    bool blocked() const noexcept {
+        return m_block.load();
+    }
+
+    /**
+     * Get number of connected slots
+     * Safety: thread safe
+     */
+    size_t slot_count() noexcept {
+        cow_copy_type<list_type, Lockable> ref = slots_reference();
+        size_t count = 0;
+        for (const auto &g : detail::cow_read(ref)) {
+            count += g.slts.size();
+        }
+        return count;
+    }
+
+protected:
+    /**
+     * remove disconnected slots
+     */
+    void clean(detail::slot_state *state) override {
+        lock_type lock(m_mutex);
+        const auto idx = state->index();
+        const auto gid = state->group();
+
+        // find the group
+        for (auto &group : detail::cow_write(m_slots)) {
+            if (group.gid == gid) {
+                auto &slts = group.slts;
+
+                // ensure we have the right slot, in case of concurrent cleaning
+                if (idx < slts.size() && slts[idx] && slts[idx].get() == state) {
+                    std::swap(slts[idx], slts.back());
+                    slts[idx]->index() = idx;
+                    slts.pop_back();
+                }
+
+                return;
+            }
+        }
+    }
+
+private:
+    // used to get a reference to the slots for reading
+    inline cow_copy_type<list_type, Lockable> slots_reference() {
+        lock_type lock(m_mutex);
+        return m_slots;
+    }
+
+    // create a new slot
+    template <typename Slot, typename... A>
+    inline auto make_slot(A && ...a) {
+        return detail::make_shared<slot_base, Slot>(*this, std::forward<A>(a)...);
+    }
+
+    // add the slot to the list of slots of the right group
+    void add_slot(slot_ptr &&s) {
+        const group_id gid = s->group();
+
+        lock_type lock(m_mutex);
+        auto &groups = detail::cow_write(m_slots);
+
+        // find the group
+        auto it = groups.begin();
+        while (it != groups.end() && it->gid < gid) {
+            it++;
+        }
+
+        // create a new group if necessary
+        if (it == groups.end() || it->gid != gid) {
+            it = groups.insert(it, {{}, gid});
+        }
+
+        // add the slot
+        s->index() = it->slts.size();
+        it->slts.push_back(std::move(s));
+    }
+
+    // disconnect a slot if a condition occurs
+    template <typename Cond>
+    size_t disconnect_if(Cond && cond) {
+        lock_type lock(m_mutex);
+        auto &groups = detail::cow_write(m_slots);
+
+        size_t count = 0;
+
+        for (auto &group : groups) {
+            auto &slts = group.slts;
+            size_t i = 0;
+            while (i < slts.size()) {
+                if (cond(slts[i])) {
+                    std::swap(slts[i], slts.back());
+                    slts[i]->index() = i;
+                    slts.pop_back();
+                    ++count;
+                } else {
+                    ++i;
+                }
+            }
+        }
+
+        return count;
+    }
+
+    // to be called under lock: remove all the slots
+    void clear() {
+        detail::cow_write(m_slots).clear();
+    }
+
+private:
+    Lockable m_mutex;
+    cow_type<list_type, Lockable> m_slots;
+    std::atomic<bool> m_block;
+};
+
+/**
+ * Specialization of signal_base to be used in single threaded contexts.
+ * Slot connection, disconnection and signal emission are not thread-safe.
+ * The performance improvement over the thread-safe variant is not impressive,
+ * so this is not very useful.
+ */
+template <typename... T>
+using signal_st = signal_base<detail::null_mutex, T...>;
+
+/**
+ * Specialization of signal_base to be used in multi-threaded contexts.
+ * Slot connection, disconnection and signal emission are thread-safe.
+ *
+ * Recursive signal emission and emission cycles are supported too.
+ */
+template <typename... T>
+using signal = signal_base<std::mutex, T...>;
+
+} // namespace sigslot

third-party/DPVO/Pangolin/components/pango_core/src/avx_math.cpp

@@ -0,0 +1,553 @@
+/*
+   AVX implementation of sin, cos, sincos, exp and log
+
+   Based on "sse_mathfun.h", by Julien Pommier
+   http://gruntthepeon.free.fr/ssemath/
+
+   Copyright (C) 2012 Giovanni Garberoglio
+   Interdisciplinary Laboratory for Computational Science (LISC)
+   Fondazione Bruno Kessler and University of Trento
+   via Sommarive, 18
+   I-38123 Trento (Italy)
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  (this is the zlib license)
+*/
+
+/*
+  From: http://software-lisc.fbk.eu/avx_mathfun/
+*/
+
+#include <pangolin/utils/avx_math.h>
+
+#ifdef __AVX2__
+namespace pangolin
+{
+/* yes I know, the top of this file is quite ugly */
+#ifdef _MSC_VER
+# define ALIGN32_BEG __declspec(align(32))
+# define ALIGN32_END
+#else
+# define ALIGN32_BEG
+# define ALIGN32_END __attribute__((aligned(32)))
+#endif
+
+/* declare some AVX constants -- why can't I figure a better way to do that? */
+#define _PS256_CONST(Name, Val)                                            \
+  static const ALIGN32_BEG float _ps256_##Name[8] ALIGN32_END = { Val, Val, Val, Val, Val, Val, Val, Val }
+#define _PI32_CONST256(Name, Val)                                            \
+  static const ALIGN32_BEG int _pi32_256_##Name[8] ALIGN32_END = { Val, Val, Val, Val, Val, Val, Val, Val }
+#define _PS256_CONST_TYPE(Name, Type, Val)                                 \
+  static const ALIGN32_BEG Type _ps256_##Name[8] ALIGN32_END = { Val, Val, Val, Val, Val, Val, Val, Val }
+
+_PS256_CONST(1  , 1.0f);
+_PS256_CONST(0p5, 0.5f);
+/* the smallest non denormalized float number */
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnarrowing"
+#endif
+_PS256_CONST_TYPE(min_norm_pos, int, 0x00800000);
+_PS256_CONST_TYPE(inv_mant_mask, int, ~0x7f800000);
+_PS256_CONST_TYPE(sign_mask, int, 0x80000000);
+_PS256_CONST_TYPE(inv_sign_mask, int, ~0x80000000);
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+_PI32_CONST256(0, 0);
+_PI32_CONST256(1, 1);
+_PI32_CONST256(inv1, ~1);
+_PI32_CONST256(2, 2);
+_PI32_CONST256(4, 4);
+_PI32_CONST256(0x7f, 0x7f);
+_PI32_CONST256(signbit, 0x7FFFFFFF);
+
+_PS256_CONST(cephes_SQRTHF, 0.707106781186547524);
+_PS256_CONST(cephes_log_p0, 7.0376836292E-2);
+_PS256_CONST(cephes_log_p1, - 1.1514610310E-1);
+_PS256_CONST(cephes_log_p2, 1.1676998740E-1);
+_PS256_CONST(cephes_log_p3, - 1.2420140846E-1);
+_PS256_CONST(cephes_log_p4, + 1.4249322787E-1);
+_PS256_CONST(cephes_log_p5, - 1.6668057665E-1);
+_PS256_CONST(cephes_log_p6, + 2.0000714765E-1);
+_PS256_CONST(cephes_log_p7, - 2.4999993993E-1);
+_PS256_CONST(cephes_log_p8, + 3.3333331174E-1);
+_PS256_CONST(cephes_log_q1, -2.12194440e-4);
+_PS256_CONST(cephes_log_q2, 0.693359375);
+
+/* natural logarithm computed for 8 simultaneous float
+   return NaN for x <= 0
+*/
+__m256 log256_ps(__m256 x) {
+  __m256i imm0;
+  __m256 one = *(__m256*)_ps256_1;
+
+  //__m256 invalid_mask = _mm256_cmple_ps(x, _mm256_setzero_ps());
+  __m256 invalid_mask = _mm256_cmp_ps(x, _mm256_setzero_ps(), _CMP_LE_OS);
+
+  x = _mm256_max_ps(x, *(__m256*)_ps256_min_norm_pos);  /* cut off denormalized stuff */
+
+  // can be done with AVX2
+  imm0 = _mm256_srli_epi32(_mm256_castps_si256(x), 23);
+
+  /* keep only the fractional part */
+  x = _mm256_and_ps(x, *(__m256*)_ps256_inv_mant_mask);
+  x = _mm256_or_ps(x, *(__m256*)_ps256_0p5);
+
+  // this is again another AVX2 instruction
+  imm0 = _mm256_sub_epi32(imm0, *(__m256i*)_pi32_256_0x7f);
+  __m256 e = _mm256_cvtepi32_ps(imm0);
+
+  e = _mm256_add_ps(e, one);
+
+  /* part2:
+     if( x < SQRTHF ) {
+       e -= 1;
+       x = x + x - 1.0;
+     } else { x = x - 1.0; }
+  */
+  //__m256 mask = _mm256_cmplt_ps(x, *(__m256*)_ps256_cephes_SQRTHF);
+  __m256 mask = _mm256_cmp_ps(x, *(__m256*)_ps256_cephes_SQRTHF, _CMP_LT_OS);
+  __m256 tmp = _mm256_and_ps(x, mask);
+  x = _mm256_sub_ps(x, one);
+  e = _mm256_sub_ps(e, _mm256_and_ps(one, mask));
+  x = _mm256_add_ps(x, tmp);
+
+  __m256 z = _mm256_mul_ps(x,x);
+
+  __m256 y = *(__m256*)_ps256_cephes_log_p0;
+  y = _mm256_mul_ps(y, x);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_cephes_log_p1);
+  y = _mm256_mul_ps(y, x);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_cephes_log_p2);
+  y = _mm256_mul_ps(y, x);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_cephes_log_p3);
+  y = _mm256_mul_ps(y, x);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_cephes_log_p4);
+  y = _mm256_mul_ps(y, x);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_cephes_log_p5);
+  y = _mm256_mul_ps(y, x);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_cephes_log_p6);
+  y = _mm256_mul_ps(y, x);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_cephes_log_p7);
+  y = _mm256_mul_ps(y, x);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_cephes_log_p8);
+  y = _mm256_mul_ps(y, x);
+
+  y = _mm256_mul_ps(y, z);
+
+  tmp = _mm256_mul_ps(e, *(__m256*)_ps256_cephes_log_q1);
+  y = _mm256_add_ps(y, tmp);
+
+
+  tmp = _mm256_mul_ps(z, *(__m256*)_ps256_0p5);
+  y = _mm256_sub_ps(y, tmp);
+
+  tmp = _mm256_mul_ps(e, *(__m256*)_ps256_cephes_log_q2);
+  x = _mm256_add_ps(x, y);
+  x = _mm256_add_ps(x, tmp);
+  x = _mm256_or_ps(x, invalid_mask); // negative arg will be NAN
+  return x;
+}
+
+_PS256_CONST(exp_hi,	88.3762626647949f);
+_PS256_CONST(exp_lo,	-88.3762626647949f);
+
+_PS256_CONST(cephes_LOG2EF, 1.44269504088896341);
+_PS256_CONST(cephes_exp_C1, 0.693359375);
+_PS256_CONST(cephes_exp_C2, -2.12194440e-4);
+
+_PS256_CONST(cephes_exp_p0, 1.9875691500E-4);
+_PS256_CONST(cephes_exp_p1, 1.3981999507E-3);
+_PS256_CONST(cephes_exp_p2, 8.3334519073E-3);
+_PS256_CONST(cephes_exp_p3, 4.1665795894E-2);
+_PS256_CONST(cephes_exp_p4, 1.6666665459E-1);
+_PS256_CONST(cephes_exp_p5, 5.0000001201E-1);
+
+__m256 exp256_ps(__m256 x) {
+  __m256 tmp = _mm256_setzero_ps(), fx;
+  __m256i imm0;
+  __m256 one = *(__m256*)_ps256_1;
+
+  x = _mm256_min_ps(x, *(__m256*)_ps256_exp_hi);
+  x = _mm256_max_ps(x, *(__m256*)_ps256_exp_lo);
+
+  /* express exp(x) as exp(g + n*log(2)) */
+  fx = _mm256_mul_ps(x, *(__m256*)_ps256_cephes_LOG2EF);
+  fx = _mm256_add_ps(fx, *(__m256*)_ps256_0p5);
+
+  /* how to perform a floorf with SSE: just below */
+  //imm0 = _mm256_cvttps_epi32(fx);
+  //tmp  = _mm256_cvtepi32_ps(imm0);
+
+  tmp = _mm256_floor_ps(fx);
+
+  /* if greater, substract 1 */
+  //__m256 mask = _mm256_cmpgt_ps(tmp, fx);
+  __m256 mask = _mm256_cmp_ps(tmp, fx, _CMP_GT_OS);
+  mask = _mm256_and_ps(mask, one);
+  fx = _mm256_sub_ps(tmp, mask);
+
+  tmp = _mm256_mul_ps(fx, *(__m256*)_ps256_cephes_exp_C1);
+  __m256 z = _mm256_mul_ps(fx, *(__m256*)_ps256_cephes_exp_C2);
+  x = _mm256_sub_ps(x, tmp);
+  x = _mm256_sub_ps(x, z);
+
+  z = _mm256_mul_ps(x,x);
+
+  __m256 y = *(__m256*)_ps256_cephes_exp_p0;
+  y = _mm256_mul_ps(y, x);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_cephes_exp_p1);
+  y = _mm256_mul_ps(y, x);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_cephes_exp_p2);
+  y = _mm256_mul_ps(y, x);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_cephes_exp_p3);
+  y = _mm256_mul_ps(y, x);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_cephes_exp_p4);
+  y = _mm256_mul_ps(y, x);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_cephes_exp_p5);
+  y = _mm256_mul_ps(y, z);
+  y = _mm256_add_ps(y, x);
+  y = _mm256_add_ps(y, one);
+
+  /* build 2^n */
+  imm0 = _mm256_cvttps_epi32(fx);
+  // another two AVX2 instructions
+  imm0 = _mm256_add_epi32(imm0, *(__m256i*)_pi32_256_0x7f);
+  imm0 = _mm256_slli_epi32(imm0, 23);
+  __m256 pow2n = _mm256_castsi256_ps(imm0);
+  y = _mm256_mul_ps(y, pow2n);
+  return y;
+}
+
+_PS256_CONST(minus_cephes_DP1, -0.78515625);
+_PS256_CONST(minus_cephes_DP2, -2.4187564849853515625e-4);
+_PS256_CONST(minus_cephes_DP3, -3.77489497744594108e-8);
+_PS256_CONST(sincof_p0, -1.9515295891E-4);
+_PS256_CONST(sincof_p1,  8.3321608736E-3);
+_PS256_CONST(sincof_p2, -1.6666654611E-1);
+_PS256_CONST(coscof_p0,  2.443315711809948E-005);
+_PS256_CONST(coscof_p1, -1.388731625493765E-003);
+_PS256_CONST(coscof_p2,  4.166664568298827E-002);
+_PS256_CONST(cephes_FOPI, 1.27323954473516); // 4 / M_PI
+
+
+/* evaluation of 8 sines at onces using AVX intrisics
+
+   The code is the exact rewriting of the cephes sinf function.
+   Precision is excellent as long as x < 8192 (I did not bother to
+   take into account the special handling they have for greater values
+   -- it does not return garbage for arguments over 8192, though, but
+   the extra precision is missing).
+
+   Note that it is such that sinf((float)M_PI) = 8.74e-8, which is the
+   surprising but correct result.
+
+*/
+__m256 sin256_ps(__m256 x) { // any x
+  __m256 xmm1, xmm2 = _mm256_setzero_ps(), xmm3, sign_bit, y;
+  __m256i imm0, imm2;
+
+  sign_bit = x;
+  /* take the absolute value */
+  x = _mm256_and_ps(x, *(__m256*)_ps256_inv_sign_mask);
+  /* extract the sign bit (upper one) */
+  sign_bit = _mm256_and_ps(sign_bit, *(__m256*)_ps256_sign_mask);
+
+  /* scale by 4/Pi */
+  y = _mm256_mul_ps(x, *(__m256*)_ps256_cephes_FOPI);
+
+  /*
+    Here we start a series of integer operations, which are in the
+    realm of AVX2.
+    If we don't have AVX, let's perform them using SSE2 directives
+  */
+
+  /* store the integer part of y in mm0 */
+  imm2 = _mm256_cvttps_epi32(y);
+  /* j=(j+1) & (~1) (see the cephes sources) */
+  // another two AVX2 instruction
+  imm2 = _mm256_add_epi32(imm2, *(__m256i*)_pi32_256_1);
+  imm2 = _mm256_and_si256(imm2, *(__m256i*)_pi32_256_inv1);
+  y = _mm256_cvtepi32_ps(imm2);
+
+  /* get the swap sign flag */
+  imm0 = _mm256_and_si256(imm2, *(__m256i*)_pi32_256_4);
+  imm0 = _mm256_slli_epi32(imm0, 29);
+  /* get the polynom selection mask
+     there is one polynom for 0 <= x <= Pi/4
+     and another one for Pi/4<x<=Pi/2
+
+     Both branches will be computed.
+  */
+  imm2 = _mm256_and_si256(imm2, *(__m256i*)_pi32_256_2);
+  imm2 = _mm256_cmpeq_epi32(imm2,*(__m256i*)_pi32_256_0);
+
+  __m256 swap_sign_bit = _mm256_castsi256_ps(imm0);
+  __m256 poly_mask = _mm256_castsi256_ps(imm2);
+  sign_bit = _mm256_xor_ps(sign_bit, swap_sign_bit);
+
+  /* The magic pass: "Extended precision modular arithmetic"
+     x = ((x - y * DP1) - y * DP2) - y * DP3; */
+  xmm1 = *(__m256*)_ps256_minus_cephes_DP1;
+  xmm2 = *(__m256*)_ps256_minus_cephes_DP2;
+  xmm3 = *(__m256*)_ps256_minus_cephes_DP3;
+  xmm1 = _mm256_mul_ps(y, xmm1);
+  xmm2 = _mm256_mul_ps(y, xmm2);
+  xmm3 = _mm256_mul_ps(y, xmm3);
+  x = _mm256_add_ps(x, xmm1);
+  x = _mm256_add_ps(x, xmm2);
+  x = _mm256_add_ps(x, xmm3);
+
+  /* Evaluate the first polynom  (0 <= x <= Pi/4) */
+  y = *(__m256*)_ps256_coscof_p0;
+  __m256 z = _mm256_mul_ps(x,x);
+
+  y = _mm256_mul_ps(y, z);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_coscof_p1);
+  y = _mm256_mul_ps(y, z);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_coscof_p2);
+  y = _mm256_mul_ps(y, z);
+  y = _mm256_mul_ps(y, z);
+  __m256 tmp = _mm256_mul_ps(z, *(__m256*)_ps256_0p5);
+  y = _mm256_sub_ps(y, tmp);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_1);
+
+  /* Evaluate the second polynom  (Pi/4 <= x <= 0) */
+
+  __m256 y2 = *(__m256*)_ps256_sincof_p0;
+  y2 = _mm256_mul_ps(y2, z);
+  y2 = _mm256_add_ps(y2, *(__m256*)_ps256_sincof_p1);
+  y2 = _mm256_mul_ps(y2, z);
+  y2 = _mm256_add_ps(y2, *(__m256*)_ps256_sincof_p2);
+  y2 = _mm256_mul_ps(y2, z);
+  y2 = _mm256_mul_ps(y2, x);
+  y2 = _mm256_add_ps(y2, x);
+
+  /* select the correct result from the two polynoms */
+  xmm3 = poly_mask;
+  y2 = _mm256_and_ps(xmm3, y2); //, xmm3);
+  y = _mm256_andnot_ps(xmm3, y);
+  y = _mm256_add_ps(y,y2);
+  /* update the sign */
+  y = _mm256_xor_ps(y, sign_bit);
+
+  return y;
+}
+
+/* almost the same as sin_ps */
+__m256 cos256_ps(__m256 x) { // any x
+  __m256 xmm1, xmm2 = _mm256_setzero_ps(), xmm3, y;
+  __m256i imm0, imm2;
+
+  /* take the absolute value */
+  x = _mm256_and_ps(x, *(__m256*)_ps256_inv_sign_mask);
+
+  /* scale by 4/Pi */
+  y = _mm256_mul_ps(x, *(__m256*)_ps256_cephes_FOPI);
+
+  /* store the integer part of y in mm0 */
+  imm2 = _mm256_cvttps_epi32(y);
+  /* j=(j+1) & (~1) (see the cephes sources) */
+  imm2 = _mm256_add_epi32(imm2, *(__m256i*)_pi32_256_1);
+  imm2 = _mm256_and_si256(imm2, *(__m256i*)_pi32_256_inv1);
+  y = _mm256_cvtepi32_ps(imm2);
+  imm2 = _mm256_sub_epi32(imm2, *(__m256i*)_pi32_256_2);
+
+  /* get the swap sign flag */
+  imm0 = _mm256_andnot_si256(imm2, *(__m256i*)_pi32_256_4);
+  imm0 = _mm256_slli_epi32(imm0, 29);
+  /* get the polynom selection mask */
+  imm2 = _mm256_and_si256(imm2, *(__m256i*)_pi32_256_2);
+  imm2 = _mm256_cmpeq_epi32(imm2, *(__m256i*)_pi32_256_0);
+
+  __m256 sign_bit = _mm256_castsi256_ps(imm0);
+  __m256 poly_mask = _mm256_castsi256_ps(imm2);
+
+  /* The magic pass: "Extended precision modular arithmetic"
+     x = ((x - y * DP1) - y * DP2) - y * DP3; */
+  xmm1 = *(__m256*)_ps256_minus_cephes_DP1;
+  xmm2 = *(__m256*)_ps256_minus_cephes_DP2;
+  xmm3 = *(__m256*)_ps256_minus_cephes_DP3;
+  xmm1 = _mm256_mul_ps(y, xmm1);
+  xmm2 = _mm256_mul_ps(y, xmm2);
+  xmm3 = _mm256_mul_ps(y, xmm3);
+  x = _mm256_add_ps(x, xmm1);
+  x = _mm256_add_ps(x, xmm2);
+  x = _mm256_add_ps(x, xmm3);
+
+  /* Evaluate the first polynom  (0 <= x <= Pi/4) */
+  y = *(__m256*)_ps256_coscof_p0;
+  __m256 z = _mm256_mul_ps(x,x);
+
+  y = _mm256_mul_ps(y, z);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_coscof_p1);
+  y = _mm256_mul_ps(y, z);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_coscof_p2);
+  y = _mm256_mul_ps(y, z);
+  y = _mm256_mul_ps(y, z);
+  __m256 tmp = _mm256_mul_ps(z, *(__m256*)_ps256_0p5);
+  y = _mm256_sub_ps(y, tmp);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_1);
+
+  /* Evaluate the second polynom  (Pi/4 <= x <= 0) */
+
+  __m256 y2 = *(__m256*)_ps256_sincof_p0;
+  y2 = _mm256_mul_ps(y2, z);
+  y2 = _mm256_add_ps(y2, *(__m256*)_ps256_sincof_p1);
+  y2 = _mm256_mul_ps(y2, z);
+  y2 = _mm256_add_ps(y2, *(__m256*)_ps256_sincof_p2);
+  y2 = _mm256_mul_ps(y2, z);
+  y2 = _mm256_mul_ps(y2, x);
+  y2 = _mm256_add_ps(y2, x);
+
+  /* select the correct result from the two polynoms */
+  xmm3 = poly_mask;
+  y2 = _mm256_and_ps(xmm3, y2); //, xmm3);
+  y = _mm256_andnot_ps(xmm3, y);
+  y = _mm256_add_ps(y,y2);
+  /* update the sign */
+  y = _mm256_xor_ps(y, sign_bit);
+
+  return y;
+}
+
+/* since sin256_ps and cos256_ps are almost identical, sincos256_ps could replace both of them..
+   it is almost as fast, and gives you a free cosine with your sine */
+void sincos256_ps(__m256 x, __m256 *s, __m256 *c) {
+
+  __m256 xmm1, xmm2, xmm3 = _mm256_setzero_ps(), sign_bit_sin, y;
+  __m256i imm0, imm2, imm4;
+
+  sign_bit_sin = x;
+  /* take the absolute value */
+  x = _mm256_and_ps(x, *(__m256*)_ps256_inv_sign_mask);
+  /* extract the sign bit (upper one) */
+  sign_bit_sin = _mm256_and_ps(sign_bit_sin, *(__m256*)_ps256_sign_mask);
+
+  /* scale by 4/Pi */
+  y = _mm256_mul_ps(x, *(__m256*)_ps256_cephes_FOPI);
+
+  /* store the integer part of y in imm2 */
+  imm2 = _mm256_cvttps_epi32(y);
+
+  /* j=(j+1) & (~1) (see the cephes sources) */
+  imm2 = _mm256_add_epi32(imm2, *(__m256i*)_pi32_256_1);
+  imm2 = _mm256_and_si256(imm2, *(__m256i*)_pi32_256_inv1);
+
+  y = _mm256_cvtepi32_ps(imm2);
+  imm4 = imm2;
+
+  /* get the swap sign flag for the sine */
+  imm0 = _mm256_and_si256(imm2, *(__m256i*)_pi32_256_4);
+  imm0 = _mm256_slli_epi32(imm0, 29);
+  //__m256 swap_sign_bit_sin = _mm256_castsi256_ps(imm0);
+
+  /* get the polynom selection mask for the sine*/
+  imm2 = _mm256_and_si256(imm2, *(__m256i*)_pi32_256_2);
+  imm2 = _mm256_cmpeq_epi32(imm2, *(__m256i*)_pi32_256_0);
+  //__m256 poly_mask = _mm256_castsi256_ps(imm2);
+
+  __m256 swap_sign_bit_sin = _mm256_castsi256_ps(imm0);
+  __m256 poly_mask = _mm256_castsi256_ps(imm2);
+
+  /* The magic pass: "Extended precision modular arithmetic"
+     x = ((x - y * DP1) - y * DP2) - y * DP3; */
+  xmm1 = *(__m256*)_ps256_minus_cephes_DP1;
+  xmm2 = *(__m256*)_ps256_minus_cephes_DP2;
+  xmm3 = *(__m256*)_ps256_minus_cephes_DP3;
+  xmm1 = _mm256_mul_ps(y, xmm1);
+  xmm2 = _mm256_mul_ps(y, xmm2);
+  xmm3 = _mm256_mul_ps(y, xmm3);
+  x = _mm256_add_ps(x, xmm1);
+  x = _mm256_add_ps(x, xmm2);
+  x = _mm256_add_ps(x, xmm3);
+
+  imm4 = _mm256_sub_epi32(imm4, *(__m256i*)_pi32_256_2);
+  imm4 = _mm256_andnot_si256(imm4, *(__m256i*)_pi32_256_4);
+  imm4 = _mm256_slli_epi32(imm4, 29);
+
+  __m256 sign_bit_cos = _mm256_castsi256_ps(imm4);
+
+  sign_bit_sin = _mm256_xor_ps(sign_bit_sin, swap_sign_bit_sin);
+
+  /* Evaluate the first polynom  (0 <= x <= Pi/4) */
+  __m256 z = _mm256_mul_ps(x,x);
+  y = *(__m256*)_ps256_coscof_p0;
+
+  y = _mm256_mul_ps(y, z);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_coscof_p1);
+  y = _mm256_mul_ps(y, z);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_coscof_p2);
+  y = _mm256_mul_ps(y, z);
+  y = _mm256_mul_ps(y, z);
+  __m256 tmp = _mm256_mul_ps(z, *(__m256*)_ps256_0p5);
+  y = _mm256_sub_ps(y, tmp);
+  y = _mm256_add_ps(y, *(__m256*)_ps256_1);
+
+  /* Evaluate the second polynom  (Pi/4 <= x <= 0) */
+
+  __m256 y2 = *(__m256*)_ps256_sincof_p0;
+  y2 = _mm256_mul_ps(y2, z);
+  y2 = _mm256_add_ps(y2, *(__m256*)_ps256_sincof_p1);
+  y2 = _mm256_mul_ps(y2, z);
+  y2 = _mm256_add_ps(y2, *(__m256*)_ps256_sincof_p2);
+  y2 = _mm256_mul_ps(y2, z);
+  y2 = _mm256_mul_ps(y2, x);
+  y2 = _mm256_add_ps(y2, x);
+
+  /* select the correct result from the two polynoms */
+  xmm3 = poly_mask;
+  __m256 ysin2 = _mm256_and_ps(xmm3, y2);
+  __m256 ysin1 = _mm256_andnot_ps(xmm3, y);
+  y2 = _mm256_sub_ps(y2,ysin2);
+  y = _mm256_sub_ps(y, ysin1);
+
+  xmm1 = _mm256_add_ps(ysin1,ysin2);
+  xmm2 = _mm256_add_ps(y,y2);
+
+  /* update the sign */
+  *s = _mm256_xor_ps(xmm1, sign_bit_sin);
+  *c = _mm256_xor_ps(xmm2, sign_bit_cos);
+}
+
+__m256 fabs256_ps(__m256 x) {
+    return _mm256_and_ps(x, *(__m256*)_pi32_256_signbit);
+}
+
+// I did not find any implementation
+// that is as exact as sequential execution.
+// Furthermore, there is none under a free
+// license:
+//
+// http://jrfonseca.blogspot.de/2008/09/fast-sse2-pow-tables-or-polynomials.html
+// http://www.dctsystems.co.uk/Software/power.html
+//
+// This implementation is the trivial
+// reformulation a = x^y -> a = exp(y * ln(x))
+__m256 pow256_ps(__m256 x, __m256 y)
+{
+    const __m256 l = log256_ps(x);
+    const __m256 f = _mm256_mul_ps(l, y);
+    return exp256_ps(f);
+}
+}
+
+#endif

third-party/DPVO/Pangolin/components/pango_core/src/factory/factory_help.cpp

@@ -0,0 +1,145 @@
+#include <iomanip>
+#include <numeric>
+#include <limits>
+#include <pangolin/factory/factory_help.h>
+#include <pangolin/factory/factory_registry.h>
+
+namespace pangolin {
+
+void PrintSchemeHelp(std::ostream& out, bool color)
+{
+    const std::string c_normal = color ? "\033[0m"  : "";
+    const std::string c_bold   = color ? "\033[1m"  : "";
+    const std::string c_scheme = color ? "\033[36m" : "";
+    const std::string c_alias  = color ? "\033[32m" : "";
+    const std::string c_params = color ? "\033[34m" : "";
+    const std::string c_param  = color ? "\033[31m" : "";
+
+    out << c_bold << "Using Factory Schemes" << c_normal << std::endl << std::endl;
+
+    out << "The factory to use is specified in the 'scheme' portion of the URL. Any parameters the factory takes will be reset to default values." << std::endl;
+    out << " e.g. \"" << c_scheme << "scheme" << c_normal << "://" << c_normal << "\"" << std::endl;
+    out << std::endl;
+
+    out << "When a factory needs to choose a unique resource, it can be specified using the URI portion of the URL." << std::endl;
+    out << " e.g. \"" << c_scheme << "scheme" << c_normal << "://" << c_param << "uri" << c_normal << "\"" << std::endl;
+    out << std::endl;
+
+    out << "Parameters can be specified within square brackets to override defaults." << std::endl;
+    out << " e.g. \"" << c_scheme << "scheme" << c_normal << ":[";
+    out << c_param << "param1" << c_normal << "=" << c_alias << "value1" << c_normal << ",";
+    out << c_param << "param2" << c_normal << "=" << c_alias << "value2" << c_normal << ",...";
+    out << "]//" << c_param << "uri" << c_normal << "\"" << std::endl;
+    out << std::endl;
+}
+
+// assumes schemes is not empty
+std::string HighestPriScheme(const std::map<FactoryInterface::Name,FactoryInterface::Precedence>& schemes)
+{
+    FactoryInterface::Name best_name;
+    FactoryInterface::Precedence best_pri = std::numeric_limits<FactoryInterface::Precedence>::max();
+    for(const auto& scheme : schemes) {
+        if(scheme.second < best_pri) {
+            best_name = scheme.first;
+            best_pri = scheme.second;
+        }
+    }
+    return best_name;
+}
+
+void PrintFactoryDetails(std::ostream& out, const std::string name, const pangolin::FactoryInterface& f, HelpVerbosity level, size_t indent, bool color)
+{
+    const std::string c_normal = color ? "\033[0m"  : "";
+    const std::string c_scheme = color ? "\033[36m" : "";
+    const std::string c_alias  = color ? "\033[32m" : "";
+    const std::string c_params = color ? "\033[34m" : "";
+    const std::string c_param  = color ? "\033[31m" : "";
+
+    indent = std::max(indent, name.size());
+
+    out << c_scheme;
+    out << std::setw(indent);
+    out << name << c_normal;
+    out << "| " << f.Description() << std::endl;
+    if(level >= HelpVerbosity::SYNOPSIS) {
+        if(f.Schemes().size() > 1) {
+            out << std::setw(indent) << " " << "| ";
+            out << c_alias << "aliases: " << c_normal << "{";
+            for(const auto& s : f.Schemes()) {
+                out << c_scheme << s.first << c_normal << " (" << s.second << "); ";
+            }
+            out << "}" << std::endl;
+        }
+    }
+    if(level >= HelpVerbosity::PARAMS) {
+        if(f.Params().params.size()) {
+            out << std::setw(indent) << " " << "| ";
+            out << c_alias << "params: " << c_normal << std::endl;
+            for(auto& param : f.Params().params) {
+                out << std::setw(indent) << " " << "|   ";
+                out << c_param << param.name_regex << c_normal << ":";
+                if(!param.default_value.empty()) {
+                    out << " (default='" << param.default_value << "')";
+                } 
+                out << std::endl;
+                out << std::setw(indent) << " " << "|     ";
+                out << param.description << std::endl;
+            }
+        }
+    }
+    if(level >= HelpVerbosity::SYNOPSIS) {
+        std::cout << std::endl;
+    }
+}
+
+void PrintFactoryRegistryDetails(
+    std::ostream& out, const pangolin::FactoryRegistry& registry, std::type_index factory_type,
+    const std::string& scheme_filter, HelpVerbosity level, bool color
+) {
+    const std::string c_normal = color ? "\033[0m"  : "";
+    const std::string c_bold   = color ? "\033[1m"  : "";
+
+    auto& factories = registry.GetFactories(factory_type);
+    std::vector<std::string> high_pri_names;
+    size_t longest_scheme = 0;
+    for(const auto& f : factories) {
+        const std::string scheme = HighestPriScheme(f->Schemes());
+        high_pri_names.push_back(scheme);
+        longest_scheme = std::max(longest_scheme, scheme.size());
+    }
+    
+    // Create vector of indices which we will use to store alphabetical order
+    std::vector<size_t> order(factories.size());
+    std::iota(order.begin(), order.end(), 0);
+
+    std::sort(order.begin(), order.end(), [&](size_t lhs, size_t rhs){
+        return high_pri_names[lhs] < high_pri_names[rhs];
+    });
+
+    const std::string post = ":// ";
+    longest_scheme += post.size();
+
+    out << c_bold << "Factory Scheme List" << c_normal << std::endl << std::endl;
+
+    if(level >= HelpVerbosity::SYNOPSIS) {
+        out << "Factory schemes can be accessed through any of their named aliases (shown below). If multiple factories support the same scheme, the factory having the lowest scheme precedence (shown in brackets) will be used." << std::endl;
+    }
+    if(level >= HelpVerbosity::PARAMS) {
+        out << "Available parameters and their default values for the factories are also shown. Regular expressions may be used if the parameter itself can vary (see the examples)."<< std::endl;
+    }
+    out << "The following is a list of factory provided schemes:" << std::endl;
+    
+    out << std::endl;
+
+    for(size_t idx : order) {
+        if(scheme_filter.empty() || factories[idx]->Schemes().count(scheme_filter) > 0) {
+            PrintFactoryDetails(out, high_pri_names[idx] + post, *factories[idx], level, longest_scheme, color);
+        }
+    }
+
+    if(level == 0) {
+        out << std::endl;
+    }
+}
+
+}

third-party/DPVO/Pangolin/components/pango_core/src/factory/factory_registry.cpp

@@ -0,0 +1,11 @@
+#include "pangolin/factory/factory_registry.h"
+
+namespace pangolin {
+
+std::shared_ptr<FactoryRegistry> FactoryRegistry::I()
+{
+    static std::shared_ptr<FactoryRegistry> registry(new FactoryRegistry());
+    return registry;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_core/src/file_extension.cpp

@@ -0,0 +1,247 @@
+/* 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.
+ */
+
+#include <pangolin/utils/file_extension.h>
+
+#include <algorithm>
+#include <fstream>
+#include <string.h>
+
+namespace pangolin
+{
+
+std::string ImageFileTypeToName(ImageFileType t)
+{
+    switch(t)
+    {
+    case ImageFileTypePpm:
+        return "ppm";
+    case ImageFileTypeTga:
+        return "tga";
+    case ImageFileTypePng:
+        return "png";
+    case ImageFileTypeJpg:
+        return "jpg";
+    case ImageFileTypeTiff:
+        return "tiff";
+    case ImageFileTypeGif:
+        return "gif";
+    case ImageFileTypeExr:
+        return "exr";
+    case ImageFileTypeBmp:
+        return "bmp";
+    case ImageFileTypePango:
+        return "pango";
+    case ImageFileTypePvn:
+        return "pvn";
+    case ImageFileTypeVrs:
+        return "vrs";
+    case ImageFileTypePly:
+        return "ply";
+    case ImageFileTypeObj:
+        return "obj";
+    case ImageFileTypeArw:
+        return "arw";
+    case ImageFileTypeUnknown:
+    default:
+        return "unknown";
+    }
+}
+
+ImageFileType NameToImageFileType(const std::string& name)
+{
+    if ("ppm" == name)
+        return ImageFileTypePpm;
+    else if ("pgm" == name)
+        return ImageFileTypePpm;
+    else if ("tga" == name)
+        return ImageFileTypeTga;
+    else if ("png" == name)
+        return ImageFileTypePng;
+    else if ("jpg" == name)
+        return ImageFileTypeJpg;
+    else if ("jpeg" == name)
+        return ImageFileTypeJpg;
+    else if ("tiff" == name)
+        return ImageFileTypeTiff;
+    else if ("gif" == name)
+        return ImageFileTypeGif;
+    else if ("exr" == name)
+        return ImageFileTypeExr;
+    else if ("bmp" == name)
+        return ImageFileTypeBmp;
+    else if ("pango" == name)
+        return ImageFileTypePango;
+    else if ("pvn" == name)
+        return ImageFileTypePvn;
+    else if ("vrs" == name)
+        return ImageFileTypeVrs;
+    else if ("zstd" == name)
+        return ImageFileTypeZstd;
+    else if ("lzf" == name)
+        return ImageFileTypeLz4;
+    else if ("p12b" == name)
+        return ImageFileTypeP12b;
+    else if ("ply" == name)
+        return ImageFileTypePly;
+    else if ("obj" == name)
+        return ImageFileTypeObj;
+    else if ("arw" == name)
+        return ImageFileTypeArw;
+
+    return ImageFileTypeUnknown;
+}
+
+ImageFileType FileTypeExtension(const std::string& ext)
+{
+    if( ext == ".png" ) {
+        return ImageFileTypePng;
+    } else if( ext == ".tga" || ext == ".targa") {
+        return ImageFileTypeTga;
+    } else if( ext == ".jpg" || ext == ".jpeg" ) {
+        return ImageFileTypeJpg;
+    } else if( ext == ".gif" ) {
+        return ImageFileTypeGif;
+    } else if( ext == ".tif" || ext == ".tiff" ) {
+        return ImageFileTypeTiff;
+    } else if( ext == ".exr"  ) {
+        return ImageFileTypeExr;
+    } else if( ext == ".bmp"  ) {
+        return ImageFileTypeBmp;
+    } else if( ext == ".ppm" || ext == ".pgm" || ext == ".pbm" || ext == ".pxm" || ext == ".pdm" ) {
+        return ImageFileTypePpm;
+    } else if( ext == ".pvn"  ) {
+        return ImageFileTypePvn;
+    } else if( ext == ".vrs"  ) {
+        return ImageFileTypeVrs;
+    } else if( ext == ".pango"  ) {
+        return ImageFileTypePango;
+    } else if( ext == ".zstd"  ) {
+        return ImageFileTypeZstd;
+    } else if( ext == ".lzf"  ) {
+        return ImageFileTypeLz4;
+    } else if( ext == ".p12b"  ) {
+        return ImageFileTypeP12b;
+    } else if( ext == ".ply"  ) {
+        return ImageFileTypePly;
+    } else if( ext == ".obj"  ) {
+        return ImageFileTypeObj;
+    } else if( ext == ".ARW"  ) {
+        return ImageFileTypeArw;
+    } else {
+        return ImageFileTypeUnknown;
+    }
+}
+
+std::string FileLowercaseExtention(const std::string& filename)
+{
+    size_t pos = filename.find_last_of('.');
+    if(pos != std::string::npos) {
+        std::string ext = filename.substr(pos);
+        std::transform( ext.begin(), ext.end(), ext.begin(), tolower );
+        return ext;
+    }else{
+        return "";
+    }
+}
+
+ImageFileType FileTypeMagic(const unsigned char data[], size_t bytes)
+{
+    // Check we wont go over bounds when comparing.
+    if(bytes >= 8) {
+        const unsigned char magic_png[]  = "\211PNG\r\n\032\n";
+        const unsigned char magic_jpg1[] = "\xFF\xD8";
+        const unsigned char magic_jpg2[] = "\xFF\xD9";
+        const unsigned char magic_gif1[] = "GIF87a";
+        const unsigned char magic_gif2[] = "GIF89a";
+        const unsigned char magic_tiff1[] = "\x49\x49\x2A\x00";
+        const unsigned char magic_tiff2[] = "\x4D\x4D\x00\x2A";
+        const unsigned char magic_exr[]   = "\x76\x2F\x31\x01";
+        const unsigned char magic_bmp[]   = "BM";
+        const unsigned char magic_pango[] = "PANGO";
+        const unsigned char magic_pango_zstd[] = "ZSTD";
+        const unsigned char magic_pango_lz4[] = "LZ4";
+        const unsigned char magic_pango_p12b[] = "P12B";
+        const unsigned char magic_vrs[] = "VisionR";
+        const unsigned char magic_ply[]   = "ply";
+
+        if( !strncmp((char*)data, (char*)magic_png, 8) ) {
+            return ImageFileTypePng;
+        }else if( !strncmp( (char*)data, (char*)magic_jpg1, 2)
+                  || !strncmp( (char*)data, (char*)magic_jpg2, 2) ) {
+            return ImageFileTypeJpg;
+        }else if( !strncmp((char*)data, (char*)magic_gif1,6)
+                  || !strncmp((char*)data, (char*)magic_gif2,6) ) {
+            return ImageFileTypeGif;
+        }else if( !strncmp((char*)data, (char*)magic_tiff1,4)
+                  || !strncmp((char*)data, (char*)magic_tiff2,4) ) {
+            return ImageFileTypeTiff;
+        }else if( !strncmp((char*)data, (char*)magic_exr,4) ) {
+            return ImageFileTypeExr;
+        }else if( !strncmp((char*)data, (char*)magic_bmp,2) ) {
+            return ImageFileTypeBmp;
+        }else if( !strncmp((char*)data, (char*)magic_pango,5) ) {
+            return ImageFileTypePango;
+        }else if( !strncmp((char*)data, (char*)magic_vrs,7) ) {
+            return ImageFileTypeVrs;
+        }else if( !strncmp((char*)data, (char*)magic_pango_zstd,4) ) {
+            return ImageFileTypeZstd;
+        }else if( !strncmp((char*)data, (char*)magic_pango_lz4,3) ) {
+            return ImageFileTypeLz4;
+        }else if( !strncmp((char*)data, (char*)magic_pango_p12b,4) ) {
+            return ImageFileTypeP12b;
+        }else if( !strncmp((char*)data, (char*)magic_ply, 3) ) {
+            return ImageFileTypePly;
+        }else if( data[0] == 'P' && '0' < data[1] && data[1] < '9') {
+            return ImageFileTypePpm;
+        }
+    }
+    return ImageFileTypeUnknown;
+}
+
+ImageFileType FileType(const std::string& filename)
+{
+    // Check magic number of file...
+    std::ifstream f(filename.c_str(), std::ios::binary );
+    if(f.is_open()) {
+        const size_t magic_bytes = 8;
+        unsigned char magic[magic_bytes];
+        f.read((char*)magic, magic_bytes);
+        if(f.good()) {
+            ImageFileType magic_type = FileTypeMagic(magic, magic_bytes);
+            if(magic_type != ImageFileTypeUnknown) {
+                return magic_type;
+            }
+        }
+    }
+
+    // Fallback on using extension...
+    const std::string ext = FileLowercaseExtention(filename);
+    return FileTypeExtension(ext);
+}
+
+}

third-party/DPVO/Pangolin/components/pango_core/src/file_utils.cpp

@@ -0,0 +1,544 @@
+/* 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.
+ */
+
+#include <pangolin/platform.h>
+
+#include <pangolin/utils/file_utils.h>
+
+#ifdef _WIN_
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <Windows.h>
+#  include <Shlobj.h>
+#  ifdef UNICODE
+#    include <codecvt>
+#  endif
+#else
+#  include <dirent.h>
+#  include <sys/types.h>
+#  include <sys/stat.h>
+#  include <sys/signal.h>
+#  include <stdio.h>
+#  include <string.h>
+#  include <unistd.h>
+#  include <fcntl.h>
+#  include <errno.h>
+#  include <poll.h>
+#endif // _WIN_
+
+#include <algorithm>
+#include <sstream>
+#include <fstream>
+#include <list>
+#include <NaturalSort/natural_sort.hpp>
+
+namespace pangolin
+{
+
+std::vector<std::string>& Split(const std::string& s, char delim, std::vector<std::string>& elements) {
+    std::stringstream ss(s);
+    std::string item;
+    while (std::getline(ss, item, delim)) {
+        elements.push_back(item);
+    }
+    return elements;
+}
+
+std::vector<std::string> Split(const std::string &s, char delim) {
+    std::vector<std::string> elems;
+    return Split(s, delim, elems);
+}
+
+std::vector<std::string> Expand(const std::string &s, char open, char close, char delim)
+{
+    const size_t no = s.find_first_of(open);
+    if(no != std::string::npos) {
+        const size_t nc = s.find_first_of(close, no);
+        if(no != std::string::npos) {
+            const std::string pre  = s.substr(0, no);
+            const std::string mid  = s.substr(no+1, nc-no-1);
+            const std::string post = s.substr(nc+1, std::string::npos);
+            const std::vector<std::string> options = Split(mid, delim);
+            std::vector<std::string> expansion;
+            
+            for(std::vector<std::string>::const_iterator iop = options.begin(); iop != options.end(); ++iop)
+            {
+                std::string full = pre + *iop + post;
+                expansion.push_back(full);
+            }
+            return expansion;
+        }
+        // Open but no close is unusual. Leave it for caller to see if valid
+    }
+    
+    std::vector<std::string> ret;
+    ret.push_back(s);
+    return ret;
+}
+
+// Make path seperator consistent for OS.
+void PathOsNormaliseInplace(std::string& path)
+{
+#ifdef _WIN_
+    std::replace(path.begin(), path.end(), '/', '\\');
+#else
+    std::replace(path.begin(), path.end(), '\\', '/');
+#endif
+}
+
+std::string SanitizePath(const std::string& path)
+{
+    std::string path_copy(path.length(), '\0');
+
+    int p_slash1 = -1;
+    int p_slash0 = -1;
+    int n_dots = 0;
+
+    int dst = 0;
+    for(int src=0; src < (int)path.length(); ++src) {
+        if(path[src] == '/') {
+            if(n_dots==1 && p_slash0 >=0) {
+                dst = p_slash0;
+                for(p_slash1=p_slash0-1; p_slash1>=0 && path_copy[p_slash1] != '/'; --p_slash1);
+            }else if(n_dots==2) {
+                if(p_slash1 >=0) {
+                    dst = p_slash1;
+                    p_slash0 = dst;
+                    for(p_slash1=p_slash0-1; p_slash1>=0 && path_copy[p_slash1] != '/'; --p_slash1) {
+                        if( path_copy[p_slash1] == '.' ) {
+                            p_slash1=-1;
+                            break;
+                        }
+                    }
+                }else{
+                    p_slash1 = -1;
+                    p_slash0 = dst;
+                }
+            }else{
+                p_slash1 = p_slash0;
+                p_slash0 = dst;
+            }
+            n_dots = 0;
+        }else if(path[src] == '.' ){
+            if((dst-p_slash0) == n_dots+1) {
+                ++n_dots;
+            }
+        }else{
+            n_dots = 0;
+        }
+        path_copy[dst++] = path[src];
+    }
+
+    return path_copy.substr(0,dst);
+}
+
+// Return path 'levels' directories above 'path'
+std::string PathParent(const std::string& path, int levels)
+{
+    std::string res = path;
+
+    while (levels > 0) {
+        if (res.length() == 0) {
+            res = std::string();
+            for (int l = 0; l < levels; ++l) {
+#ifdef _WIN_
+                res += std::string("..\\");
+#else
+                res += std::string("../");
+#endif
+            }
+            return res;
+        }else{
+            const size_t nLastSlash = res.find_last_of("/\\");
+
+            if (nLastSlash != std::string::npos) {
+                res = path.substr(0, nLastSlash);
+            } else{
+                res = std::string();
+            }
+
+            --levels;
+        }
+    }
+
+    return res;
+}
+
+std::string FindPath(const std::string& child_path, const std::string& signature_path)
+{
+    std::string path = PathExpand(child_path);
+#ifdef _UNIX_
+    char abs_path[PATH_MAX];
+    if (realpath(path.c_str(), abs_path)) {
+        path = abs_path;
+    }
+#endif
+    std::string signature = signature_path;
+    PathOsNormaliseInplace(path);
+    PathOsNormaliseInplace(signature);
+
+    while(!FileExists(path + signature)) {
+        if (path.empty()) {
+            return std::string();
+        } else {
+            path = PathParent(path);
+        }
+    }
+
+    return path + signature;
+}
+
+std::string PathExpand(const std::string& sPath)
+{
+    if(sPath.length() >0 && sPath[0] == '~') {
+#ifdef _WIN_
+        std::string sHomeDir;
+        WCHAR path[MAX_PATH];
+        if (SUCCEEDED(SHGetFolderPathW(NULL, CSIDL_PROFILE, NULL, 0, path))) {
+            std::wstring ws(path);
+            sHomeDir = std::string(ws.begin(), ws.end());
+        }
+#else
+        std::string sHomeDir = std::string(getenv("HOME"));
+#endif
+        return sHomeDir + sPath.substr(1,std::string::npos);
+    }else{
+        return sPath;
+    }
+}
+
+// Based on http://www.codeproject.com/Articles/188256/A-Simple-Wildcard-Matching-Function
+bool MatchesWildcard(const std::string& str, const std::string& wildcard)
+{
+    const char* psQuery = str.c_str();
+    const char* psWildcard = wildcard.c_str();
+    
+    while(*psWildcard)
+    {
+        if(*psWildcard=='?')
+        {
+            if(!*psQuery)
+                return false;
+
+            ++psQuery;
+            ++psWildcard;
+        }
+        else if(*psWildcard=='*')
+        {
+            if(MatchesWildcard(psQuery,psWildcard+1))
+                return true;
+
+            if(*psQuery && MatchesWildcard(psQuery+1,psWildcard))
+                return true;
+
+            return false;
+        }
+        else
+        {
+            if(*psQuery++ != *psWildcard++ )
+                return false;
+        }
+    }
+
+    return !*psQuery && !*psWildcard;
+}
+
+std::string MakeUniqueFilename(const std::string& filename)
+{
+    if( FileExists(filename) ) {
+        const size_t dot = filename.find_last_of('.');
+
+        std::string fn;
+        std::string ext;
+
+        if(dot == filename.npos) {
+            fn = filename;
+            ext = "";
+        }else{
+            fn = filename.substr(0, dot);
+            ext = filename.substr(dot);
+        }
+
+        int id = 1;
+        std::string new_file;
+        do {
+            id++;
+            std::stringstream ss;
+            ss << fn << "_" << id << ext;
+            new_file = ss.str();
+        }while( FileExists(new_file) );
+
+        return new_file;
+    }else{
+        return filename;
+    }
+}
+
+// Based on https://insanecoding.blogspot.com/2011/11/how-to-read-in-file-in-c.html
+std::string GetFileContents(const std::string& filename)
+{
+    std::ifstream in(filename.c_str(), std::ios::in | std::ios::binary);
+    if (in)
+    {
+        std::string contents;
+        in.seekg(0, std::ios::end);
+        contents.resize(in.tellg());
+        in.seekg(0, std::ios::beg);
+        in.read(&contents[0], contents.size());
+        in.close();
+        return(contents);
+    }else{
+        throw std::runtime_error(std::string("Unable to open file: ") + filename);
+    }
+}
+
+bool IsPipe(const std::string& file)
+{
+#ifdef _WIN_
+    return false;
+#else
+    struct stat st;
+    int err = stat(file.c_str(), &st);
+    return (err == 0) && ((st.st_mode & S_IFMT) == S_IFIFO);
+#endif // _WIN_
+}
+
+bool IsPipe(int fd)
+{
+#ifdef _WIN_
+    return false;
+#else
+    struct stat st;
+    int err = fstat(fd, &st);
+    return (err == 0) && ((st.st_mode & S_IFMT) == S_IFIFO);
+#endif
+}
+
+int WritablePipeFileDescriptor(const std::string& file)
+{
+#ifdef _WIN_
+    return false;
+#else
+    // open(2) will return ENXIO when there is no reader on the other
+    // side of the pipe, but only if O_WRONLY|O_NONBLOCK is specified.
+    // The file descriptor can be adjusted to be a blocking file
+    // descriptor if it is valid.
+    return open(file.c_str(), O_WRONLY | O_NONBLOCK);
+#endif // _WIN_
+}
+
+int ReadablePipeFileDescriptor(const std::string& file)
+{
+#ifdef _WIN_
+    return -1;
+#else
+    return open(file.c_str(), O_RDONLY | O_NONBLOCK);
+#endif
+}
+
+bool PipeHasDataToRead(int fd)
+{
+#ifdef _WIN_
+    return false;
+#else
+    struct pollfd pfd;
+    memset(&pfd, 0, sizeof(pfd));
+    pfd.fd = fd;
+    pfd.events = POLLIN;
+
+    int err = poll(&pfd, 1, 0);
+
+    // If err is 0, the file has no data. If err is negative, an error
+    // occurred.
+    return err == 1 && pfd.revents & POLLIN;
+#endif
+}
+
+void FlushPipe(const std::string& file)
+{
+#ifndef _WIN_
+    int fd = open(file.c_str(), O_RDONLY | O_NONBLOCK);
+    char buf[65535];
+    int n = 0;
+    do
+    {
+        n = read(fd, buf, sizeof(buf));
+    } while(n > 0);
+    close(fd);
+#endif
+}
+
+#ifdef _WIN_
+
+#ifdef UNICODE
+    typedef std::codecvt_utf8<wchar_t> WinStringConvert;
+    typedef std::wstring WinString;
+
+    WinString s2ws(const std::string& str) {
+        std::wstring_convert<WinStringConvert, wchar_t> converter;
+        return converter.from_bytes(str);
+    }
+    std::string ws2s(const WinString& wstr) {
+        std::wstring_convert<WinStringConvert, wchar_t> converter;
+        return converter.to_bytes(wstr);
+    }
+#else
+    typedef std::string WinString;
+    // No conversions necessary
+#   define s2ws(X) (X)
+#   define ws2s(X) (X)
+#endif // UNICODE
+
+bool FilesMatchingWildcard(const std::string& wildcard, std::vector<std::string>& file_vec, 
+    SortMethod sort_method )
+{
+	size_t nLastSlash = wildcard.find_last_of("/\\");
+    
+    std::string sPath;
+    std::string sFileWc;
+    
+    if(nLastSlash != std::string::npos) {
+        sPath =   wildcard.substr(0, nLastSlash);                  
+        sFileWc = wildcard.substr(nLastSlash+1, std::string::npos);
+    }else{
+        sPath = ".";
+        sFileWc = wildcard;
+    }
+
+    sPath = PathExpand(sPath);
+    
+    WIN32_FIND_DATA wfd;
+    HANDLE fh = FindFirstFile( s2ws(sPath + "\\" + sFileWc).c_str(), &wfd);
+
+    std::vector<std::string> files;
+
+    if (fh != INVALID_HANDLE_VALUE) {
+        do {
+            if (!(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))  {
+                files.push_back( sPath + "\\" + ws2s(wfd.cFileName) );
+            }
+        } while (FindNextFile (fh, &wfd));
+        FindClose(fh);
+    }
+
+    // TOOD: Use different comparison to achieve better ordering.
+    switch(sort_method) {
+      case SortMethod::NATURAL:
+        SI::natural::sort(files.begin(), files.end());
+        break;
+      case SortMethod::STANDARD:
+      default:
+        std::sort(files.begin(), files.end() );
+    }
+    
+    // Put file list at end of file_vec
+    file_vec.insert(file_vec.end(), files.begin(), files.end() );
+
+    return files.size() > 0;
+}
+
+bool FileExists(const std::string& filename)
+{
+    std::string search_filename = filename;
+    if(filename.length() > 0 && 
+      (filename[filename.length()-1] == '\\' || filename[filename.length() - 1] == '/')) {
+        search_filename.resize(filename.length()-1);
+    }
+    WIN32_FIND_DATA wfd;
+    HANDLE fh = FindFirstFile( s2ws(search_filename).c_str(), &wfd);
+    const bool exists = fh != INVALID_HANDLE_VALUE;
+    FindClose(fh);
+    return exists;
+}
+
+#else // _WIN_
+
+bool FilesMatchingWildcard_(const std::string& in_wildcard, std::vector<std::string>& file_vec)
+{
+    const std::string wildcard = PathExpand(in_wildcard);
+    const size_t first_wildcard = wildcard.find_first_of("?*");
+    if(first_wildcard != std::string::npos) {
+        const std::string root = PathParent(wildcard.substr(0,first_wildcard));
+        struct dirent **namelist;
+        int n = scandir(root.c_str(), &namelist, 0, alphasort);
+        if (n >= 0) {
+            const size_t next_slash = wildcard.find_first_of("/\\",first_wildcard+1);
+            std::string dir_wildcard, rest;
+            if(next_slash != std::string::npos) {
+                dir_wildcard = wildcard.substr(root.size()+1, next_slash-root.size()-1);
+                rest = wildcard.substr(next_slash);
+            }else{
+                dir_wildcard = wildcard.substr(root.size()+1);
+            }
+
+            while(n--) {
+                const std::string file_name(namelist[n]->d_name);
+                if( file_name != "." && file_name != ".." && MatchesWildcard(file_name, dir_wildcard) ) {
+                    const std::string sub_wildcard = root + "/" + file_name + rest;
+                    FilesMatchingWildcard_(sub_wildcard, file_vec);
+                    if(dir_wildcard == "**") {
+                        const std::string sub_wildcard2 = root + "/" + file_name + "/**" + rest;
+                        FilesMatchingWildcard_(sub_wildcard2, file_vec);
+                    }
+                }
+            }
+        }
+    } else if(FileExists(wildcard)) {
+        file_vec.push_back(wildcard);
+    }
+    return file_vec.size() > 0;
+}
+
+bool FilesMatchingWildcard(const std::string& in_wildcard, std::vector<std::string>& file_vec, SortMethod sort_method)
+{
+    if (FilesMatchingWildcard_(in_wildcard, file_vec)) {
+        // sort all file entries in file_vec to make sure anything that was
+        // added is sorted in properly.
+        switch (sort_method) {
+          case SortMethod::NATURAL:
+            SI::natural::sort(file_vec.begin(), file_vec.end());
+            break;
+          case SortMethod::STANDARD:
+          default:
+            std::sort(file_vec.begin(), file_vec.end() );
+        }
+        return true;
+    }
+    return false;
+}
+
+
+bool FileExists(const std::string& filename)
+{
+    struct stat buf;
+    return stat(filename.c_str(), &buf) != -1;
+}
+
+#endif //_WIN_
+
+}

third-party/DPVO/Pangolin/components/pango_core/src/param_set.cpp

@@ -0,0 +1,58 @@
+#include <pangolin/utils/param_set.h>
+
+namespace pangolin
+{
+
+bool ParamReader::Contains( const std::string& param_name )
+{
+    const ParamSet::Param* param = GetMatchingParamFromParamSet( param_name );
+    if( param ){
+        return uri_.Contains( param_name );
+    }
+    throw ParamReaderException( param_name );
+}
+
+std::unordered_set<std::string> ParamReader::FindUnrecognizedUriParams()
+{
+    std::unordered_set<std::string> result;
+    for(const auto& param_pair: uri_.params){
+        if(GetMatchingParamFromParamSet( param_pair.first ) == nullptr ){
+            result.insert( param_pair.first );
+        }
+    }
+    return result;
+}
+
+const ParamSet::Param* ParamReader::GetMatchingParamFromParamSet( const std::string& param_name ) const
+{
+    for(const auto& param : param_set_.params){
+        std::regex name_regex( param.name_regex );
+        if (std::regex_match ( param_name, name_regex )){
+            return &param;
+        }
+    }
+    return nullptr;
+}
+
+std::string ParamSet::str() const
+{
+    std::stringstream ss;
+    if( params.size() > 0){
+        ss << "[";
+        size_t count = 0;
+        for(const auto& param : params){
+            ss << param.name_regex;
+            if(!param.default_value.empty()){
+                ss << "=" << param.default_value;
+            }
+            if(count < (params.size()-1)){
+                ss << ",";
+            }
+            count++;
+        }
+        ss << "]";
+    }
+    return ss.str();
+}
+
+}

third-party/DPVO/Pangolin/components/pango_core/src/posix/condition_variable.cpp

@@ -0,0 +1,89 @@
+#include <pangolin/utils/posix/condition_variable.h>
+
+#include <pangolin/utils/posix/shared_memory_buffer.h>
+
+#include <pthread.h>
+
+using namespace std;
+
+namespace pangolin {
+
+struct PThreadSharedData {
+  pthread_mutex_t lock;
+  pthread_cond_t cond;
+};
+
+class PThreadConditionVariable : public ConditionVariableInterface {
+public:
+  PThreadConditionVariable(std::shared_ptr<SharedMemoryBufferInterface> &shmem)
+      : _shmem(shmem),
+        _pthread_data(reinterpret_cast<PThreadSharedData *>(_shmem->ptr())) {}
+
+  ~PThreadConditionVariable() override {}
+
+  void wait() override {
+    _lock();
+    pthread_cond_wait(&_pthread_data->cond, &_pthread_data->lock);
+    _unlock();
+  }
+
+  bool wait(timespec abstime) override {
+    _lock();
+    int err = pthread_cond_timedwait(&_pthread_data->cond, &_pthread_data->lock,
+                           &abstime);
+    _unlock();
+
+    return 0 == err;
+  }
+
+  void signal() override { pthread_cond_signal(&_pthread_data->cond); }
+
+  void broadcast() override { pthread_cond_broadcast(&_pthread_data->cond); }
+
+private:
+  void _lock() { pthread_mutex_lock(&_pthread_data->lock); }
+
+  void _unlock() { pthread_mutex_unlock(&_pthread_data->lock); }
+
+  std::shared_ptr<SharedMemoryBufferInterface> _shmem;
+  PThreadSharedData *_pthread_data;
+};
+
+std::shared_ptr<ConditionVariableInterface>
+create_named_condition_variable(const string &name) {
+  std::shared_ptr<SharedMemoryBufferInterface> shmem =
+      create_named_shared_memory_buffer(name, sizeof(PThreadSharedData));
+  std::shared_ptr<ConditionVariableInterface> ptr;
+
+  PThreadSharedData *pthread_data =
+      reinterpret_cast<PThreadSharedData *>(shmem->ptr());
+
+  pthread_mutexattr_t mattr;
+  pthread_mutexattr_init(&mattr);
+  pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
+
+  pthread_condattr_t cattr;
+  pthread_condattr_init(&cattr);
+  pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_SHARED);
+
+  pthread_mutex_init(&pthread_data->lock, &mattr);
+  pthread_cond_init(&pthread_data->cond, &cattr);
+
+  ptr.reset(static_cast<ConditionVariableInterface *>(
+      new PThreadConditionVariable(shmem)));
+  return ptr;
+}
+
+std::shared_ptr<ConditionVariableInterface>
+open_named_condition_variable(const string &name) {
+  std::shared_ptr<SharedMemoryBufferInterface> shmem =
+    open_named_shared_memory_buffer(name, true);
+  std::shared_ptr<ConditionVariableInterface> ptr;
+
+  if(shmem) {
+    ptr.reset(new PThreadConditionVariable(shmem));
+  }
+  return ptr;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_core/src/posix/semaphore.cpp

@@ -0,0 +1,83 @@
+#include <pangolin/utils/posix/semaphore.h>
+
+#include <fcntl.h>
+#include <semaphore.h>
+#include <sys/stat.h>
+
+#include <string>
+
+using namespace std;
+
+namespace pangolin
+{
+
+// TODO(shaheen) register a signal handler for SIGTERM and unlink shared
+// semaphores.
+class PosixSemaphore : public SemaphoreInterface
+{
+public:
+  PosixSemaphore(sem_t *semaphore, bool ownership, const string& name) :
+    _semaphore(semaphore),
+    _ownership(ownership),
+    _name(name)
+  {
+  }
+
+  ~PosixSemaphore() override
+  {
+    if (_ownership) {
+      sem_unlink(_name.c_str());
+    } else {
+      sem_close(_semaphore);
+    }
+  }
+
+  bool tryAcquire() override
+  {
+    int err = sem_trywait(_semaphore);
+    return err == 0;
+  }
+
+  void acquire() override
+  {
+    sem_wait(_semaphore);
+  }
+
+  void release() override
+  {
+    sem_post(_semaphore);
+  }
+
+private:
+  sem_t *_semaphore;
+  bool _ownership;
+  string _name;
+};
+
+std::shared_ptr<SemaphoreInterface> create_named_semaphore(const string& name, unsigned int value)
+{
+  std::shared_ptr<SemaphoreInterface> ptr;
+  sem_t *semaphore = sem_open(name.c_str(), O_CREAT | O_EXCL,
+    S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP, value);
+  if (NULL == semaphore) {
+    return ptr;
+  }
+
+  ptr.reset(new PosixSemaphore(semaphore, true, name));
+  return ptr;
+}
+
+std::shared_ptr<SemaphoreInterface> open_named_semaphore(const string& name)
+{
+  std::shared_ptr<SemaphoreInterface> ptr;
+  sem_t *semaphore = sem_open(name.c_str(), 0);
+
+  if (NULL == semaphore) {
+    return ptr;
+  }
+
+  ptr.reset(new PosixSemaphore(semaphore, false, name));
+  return ptr;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_core/src/posix/shared_memory_buffer.cpp

@@ -0,0 +1,134 @@
+#include <pangolin/utils/posix/shared_memory_buffer.h>
+
+#include <fcntl.h>
+#include <limits.h>
+#include <sys/file.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+using namespace std;
+
+namespace pangolin
+{
+
+// TODO(shaheen) register a signal handler for SIGTERM and unlink shared memory
+// objects.
+class PosixSharedMemoryBuffer : public SharedMemoryBufferInterface
+{
+public:
+  PosixSharedMemoryBuffer(int fd, unsigned char *ptr, size_t size, bool ownership, const std::string& name) :
+    _fd(fd),
+    _ptr(ptr),
+    _size(size),
+    _ownership(ownership),
+    _name(name),
+    _lockCount(0)
+  {
+  }
+
+  ~PosixSharedMemoryBuffer() override
+  {
+    close(_fd);
+    munmap(_ptr, _size);
+
+    if (_ownership) {
+      shm_unlink(_name.c_str());
+    }
+  }
+
+  bool tryLock() override
+  {
+    if (_lockCount == 0) {
+      int err = flock(_fd, LOCK_EX|LOCK_NB);
+      if (0 == err) {
+        _lockCount++;
+      }
+    }
+    return _lockCount != 0;
+  }
+
+  void lock() override
+  {
+    if (_lockCount == 0) {
+      flock(_fd, LOCK_EX);
+    }
+    _lockCount++;
+  }
+
+  void unlock() override
+  {
+    if (_lockCount != 0) {
+      flock(_fd, LOCK_UN);
+    }
+    _lockCount--;
+  }
+
+  unsigned char *ptr() override
+  {
+    return _ptr;
+  }
+
+  std::string name() override
+  {
+    return _name;
+  }
+
+private:
+  int _fd;
+  unsigned char *_ptr;
+  size_t _size;
+  bool _ownership;
+  string _name;
+  unsigned int _lockCount;
+};
+
+std::shared_ptr<SharedMemoryBufferInterface> create_named_shared_memory_buffer(const
+  string& name, size_t size)
+{
+  std::shared_ptr<SharedMemoryBufferInterface> ptr;
+
+  int fd = shm_open(name.c_str(), O_RDWR | O_RDONLY | O_CREAT,
+    S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
+  if (-1 == fd) {
+    return ptr;
+  }
+
+  int err = ftruncate(fd, size);
+  if (-1 == err) {
+    shm_unlink(name.c_str());
+    return ptr;
+  }
+
+  unsigned char *buffer = reinterpret_cast<unsigned char *>(mmap(NULL, size,
+      PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0));
+
+  ptr.reset(new PosixSharedMemoryBuffer(fd, buffer, size, true, name));
+  return ptr;
+}
+
+std::shared_ptr<SharedMemoryBufferInterface> open_named_shared_memory_buffer(const
+  string& name, bool readwrite)
+{
+  std::shared_ptr<SharedMemoryBufferInterface> ptr;
+
+  int fd = shm_open(name.c_str(), readwrite ? O_RDWR | O_RDONLY : O_RDONLY, 0);
+  if (-1 == fd) {
+    return ptr;
+  }
+
+  struct stat sbuf;
+  int err = fstat(fd, &sbuf);
+  if (-1 == err) {
+    return ptr;
+  }
+
+  size_t size = sbuf.st_size;
+  unsigned char *buffer = reinterpret_cast<unsigned char *>(mmap(NULL, size,
+      PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0));
+
+  ptr.reset(new PosixSharedMemoryBuffer(fd, buffer, size, false, name));
+  return ptr;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_core/src/sigstate.cpp

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

third-party/DPVO/Pangolin/components/pango_core/src/threadedfilebuf.cpp

@@ -0,0 +1,353 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/utils/threadedfilebuf.h>
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/utils/sigstate.h>
+
+#include <cstring>
+#include <stdexcept>
+
+#ifdef USE_POSIX_FILE_IO
+#include <unistd.h>
+#include <fcntl.h>
+
+// Optionally use direct file i/o to avoid the cache.
+#define USE_DIRECT_FILE_IO
+#define POSIX_BLOCK_SIZE 4096
+#endif
+
+using namespace std;
+
+namespace pangolin
+{
+
+namespace
+{
+char* allocate_buffer(size_t mem_max_size)
+{
+#ifdef USE_DIRECT_FILE_IO
+    void *mem_alloc;
+    int result = posix_memalign(&mem_alloc, POSIX_BLOCK_SIZE, mem_max_size);
+    if(result)
+    {
+        throw std::runtime_error("posix_memalign failed with result: " + std::to_string(result));
+    }
+    return static_cast<char*>(mem_alloc);
+#else
+    return new char[static_cast<size_t>(mem_max_size)];
+#endif
+}
+
+void free_buffer(char* mem_buffer)
+{
+#ifdef USE_DIRECT_FILE_IO
+    free(mem_buffer);
+#else
+    delete mem_buffer;
+#endif
+}
+}
+
+threadedfilebuf::threadedfilebuf()
+    : mem_buffer(0), mem_size(0), mem_max_size(0), mem_start(0), mem_end(0), should_run(false), is_pipe(false)
+{
+}
+
+threadedfilebuf::threadedfilebuf(const std::string& filename, size_t buffer_size_bytes )
+    : mem_buffer(0), mem_size(0), mem_max_size(0), mem_start(0), mem_end(0), should_run(false), is_pipe(pangolin::IsPipe(filename))
+{
+    open(filename, buffer_size_bytes);
+}
+
+void threadedfilebuf::open(const std::string& filename, size_t buffer_size_bytes)
+{
+    is_pipe = pangolin::IsPipe(filename);
+
+#ifdef USE_POSIX_FILE_IO
+    if (filenum != -1) {
+#else
+    if (file.is_open()) {
+#endif
+        close();
+    }
+
+#ifdef USE_POSIX_FILE_IO
+
+    // File is read/write for user and group, read only for other.
+    mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH;
+#ifdef USE_DIRECT_FILE_IO
+    filenum = ::open(filename.c_str(), O_CREAT | O_TRUNC | O_WRONLY | O_DIRECT | O_SYNC, mode);
+#else
+    filenum = ::open(filename.c_str(), O_CREAT | O_TRUNC | O_WRONLY | O_SYNC, mode);
+#endif
+
+#else
+    file.open(filename.c_str(), ios::out | ios::binary);
+#endif
+
+#ifdef USE_POSIX_FILE_IO
+    if (filenum == -1) {
+#else
+    if(!file.is_open()) {
+#endif
+        throw std::runtime_error("Unable to open '" + filename + "' for writing.");
+    }
+
+    mem_buffer = 0;
+    mem_size = 0;
+    mem_start = 0;
+    mem_end = 0;
+    mem_max_size = static_cast<std::streamsize>(buffer_size_bytes);
+    mem_buffer = allocate_buffer(mem_max_size);
+    should_run = true;
+    write_thread = std::thread(std::ref(*this));
+}
+
+void threadedfilebuf::close()
+{
+    should_run = false;
+
+    cond_queued.notify_all();
+
+    if(write_thread.joinable())
+    {
+        write_thread.join();
+    }
+
+    if(mem_buffer)
+    {
+        free_buffer(mem_buffer);
+        mem_buffer = 0;
+    }
+
+#ifdef USE_POSIX_FILE_IO
+    ::close(filenum);
+    filenum = -1;
+#else
+    file.close();
+#endif
+}
+
+void threadedfilebuf::soft_close()
+{
+    // Forces sputn to write no bytes and exit early, results in lost data
+    mem_size = 0;
+}
+
+void threadedfilebuf::force_close()
+{
+    soft_close();
+    close();
+}
+
+threadedfilebuf::~threadedfilebuf()
+{
+    close();
+}
+
+std::streamsize threadedfilebuf::xsputn(const char* data, std::streamsize num_bytes)
+{
+    if( num_bytes > mem_max_size ) {
+        std::unique_lock<std::mutex> lock(update_mutex);
+        // Wait until queue is empty
+        while( mem_size > 0 ) {
+            cond_dequeued.wait(lock);
+        }
+
+        // Allocate bigger buffer
+        free_buffer(mem_buffer);
+        mem_start = 0;
+        mem_end = 0;
+        mem_max_size = num_bytes * 4;
+        mem_buffer = allocate_buffer(mem_max_size);
+    }
+
+    {
+        std::unique_lock<std::mutex> lock(update_mutex);
+
+        // wait until there is space to write into buffer
+        while( mem_size + num_bytes > mem_max_size ) {
+            cond_dequeued.wait(lock);
+        }
+
+        // add image to end of mem_buffer
+        const std::streamsize array_a_size =
+                (mem_start <= mem_end) ? (mem_max_size - mem_end) : (mem_start - mem_end);
+
+        if( num_bytes <= array_a_size )
+        {
+            // copy in one
+            memcpy(mem_buffer + mem_end, data, static_cast<size_t>(num_bytes));
+            mem_end += num_bytes;
+            mem_size += num_bytes;
+        }else{
+            const std::streamsize array_b_size = num_bytes - array_a_size;
+            memcpy(mem_buffer + mem_end, data, (size_t)array_a_size);
+            memcpy(mem_buffer, data+array_a_size, (size_t)array_b_size);
+            mem_end = array_b_size;
+            mem_size += num_bytes;
+        }
+
+        if(mem_end == mem_max_size)
+            mem_end = 0;
+    }
+
+    cond_queued.notify_one();
+
+    input_pos += num_bytes;
+    return num_bytes;
+}
+
+int threadedfilebuf::overflow(int c)
+{
+    const std::streamsize num_bytes = 1;
+
+    {
+        std::unique_lock<std::mutex> lock(update_mutex);
+
+        // wait until there is space to write into buffer
+        while( mem_size + num_bytes > mem_max_size ) {
+            cond_dequeued.wait(lock);
+        }
+
+        // add image to end of mem_buffer
+        mem_buffer[mem_end] = c;
+        mem_end += num_bytes;
+        mem_size += num_bytes;
+
+        if(mem_end == mem_max_size)
+            mem_end = 0;
+    }
+
+    cond_queued.notify_one();
+
+    input_pos += num_bytes;
+    return num_bytes;
+}
+
+std::streampos threadedfilebuf::seekoff(
+    std::streamoff off, std::ios_base::seekdir way,
+    std::ios_base::openmode /*which*/
+) {
+    if(off == 0 && way == ios_base::cur) {
+        return input_pos;
+    }else{
+        return -1;
+    }
+}
+
+void threadedfilebuf::operator()()
+{
+    std::streamsize data_to_write = 0;
+
+    while(true)
+    {
+        if(is_pipe)
+        {
+            try
+            {
+                if(SigState::I().sig_callbacks.at(SIGPIPE).value)
+                {
+                    soft_close();
+                    return;
+                }
+            } catch(std::out_of_range&)
+            {
+//                std::cout << "Please register a SIGPIPE handler for your writer" << std::endl;
+            }
+        }
+
+        {
+            std::unique_lock<std::mutex> lock(update_mutex);
+
+            // Wait until there is data to write or we are stopping the write thread.
+#ifdef USE_DIRECT_FILE_IO
+            while(mem_size < POSIX_BLOCK_SIZE && should_run) {
+#else
+            while(mem_size == 0 && should_run) {
+#endif
+                cond_queued.wait(lock);
+            }
+
+            if (mem_size == 0 && !should_run)
+            {
+                return;
+            }
+
+            data_to_write =
+                    (mem_start < mem_end) ?
+                        mem_end - mem_start :
+                        mem_max_size - mem_start;
+        }
+
+        // Adjust write size if appropriate.
+#ifdef USE_DIRECT_FILE_IO
+        if (!should_run && data_to_write < POSIX_BLOCK_SIZE)
+        {
+            // Stopping the write thread - allow non-direct write of final block.
+            int fopts = fcntl(filenum, F_GETFL);
+            int result = fcntl(filenum, F_SETFL, fopts & ~O_DIRECT);
+            if (result == -1)
+            {
+                throw std::runtime_error("fcntl failed with result: " + std::to_string(result));
+            }
+        }
+        else
+        {
+            // Direct writes are limited to block size boundaries
+            data_to_write = data_to_write - (data_to_write%POSIX_BLOCK_SIZE);
+        }
+#endif
+
+        // Write data through to disk.
+#ifdef USE_POSIX_FILE_IO
+        int bytes_written = ::write(filenum, mem_buffer + mem_start, data_to_write);
+        if(bytes_written == -1)
+        {
+            throw std::runtime_error("Unable to write data.");
+        }
+#else
+        std::streamsize bytes_written =
+                file.sputn(mem_buffer + mem_start, data_to_write );
+#endif
+
+        {
+            std::unique_lock<std::mutex> lock(update_mutex);
+
+            mem_size -= bytes_written;
+            mem_start += bytes_written;
+
+            if(mem_start == mem_max_size)
+                mem_start = 0;
+        }
+
+        cond_dequeued.notify_all();
+    }
+}
+
+}

third-party/DPVO/Pangolin/components/pango_core/src/uri.cpp

@@ -0,0 +1,105 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/utils/uri.h>
+
+#include <stdexcept>
+#include <vector>
+#include <string>
+
+namespace pangolin
+{
+
+Uri ParseUri(const std::string &str_uri)
+{
+    Uri uri;
+    uri.full_uri = str_uri;
+
+    // Find Scheme delimiter
+    size_t npos = 0;
+    const size_t ns = str_uri.find(':', npos);
+    if( ns != std::string::npos )
+    {
+        uri.scheme = str_uri.substr(0,ns);
+        npos = ns+1;
+    }else{
+        uri.scheme = "file";
+        uri.url = str_uri;
+        return uri;
+    }
+
+    // Find Options delimiters
+    if( str_uri.size() > npos && str_uri[npos] == '[' )
+    {
+        const size_t nob = npos;
+        const size_t ncb = str_uri.find(']', nob+1);
+        if(ncb != std::string::npos)
+        {
+            const std::string queries = str_uri.substr(nob+1, ncb - (ns+2) );
+            std::vector<std::string> params;
+            Split(queries, ',', params);
+            for(size_t i=0; i< params.size(); ++i)
+            {
+                std::vector<std::string> args;
+                Split(params[i], '=', args );
+                std::string key = Trim(args[0]);
+                std::string val = args.size() > 1 ? Trim(args[1]) : "";
+                uri.Set(key,val);
+            }
+        }else{
+            throw std::runtime_error("Unable to parse URI: '" + str_uri + "'");
+        }
+        npos = ncb + 1;
+    }
+
+    // Find url delimiter
+    size_t nurl = str_uri.find("//", npos);
+    if(nurl != std::string::npos)
+    {
+        uri.url = str_uri.substr(nurl+2);
+    }
+
+    return uri;
+}
+
+std::ostream& operator<< (std::ostream &out, Uri &uri)
+{
+    out << "scheme: " << uri.scheme << std::endl;
+    out << "url:    " << uri.url << std::endl;
+    out << "params:" << std::endl;
+
+    for( Uri::ParamMap::const_iterator ip = uri.params.begin();
+         ip != uri.params.end(); ++ip)
+    {
+        out << "\t" << ip->first << " = " << ip->second << std::endl;
+    }
+
+    return out;
+}
+
+} // pangolin

third-party/DPVO/Pangolin/components/pango_core/tests/tests_uri.cpp

@@ -0,0 +1,87 @@
+#define CATCH_CONFIG_MAIN
+#include <catch2/catch.hpp>
+
+#include <string>
+#include <limits>
+#include <functional>
+#include <pangolin/factory/factory_registry.h>
+
+template<typename T>
+inline void ExpectExceptionWithMessageFromAction(
+    std::function<void()> action,
+    const std::string& exceptionMessageBegin
+) {
+    try
+    {
+        action();
+
+        FAIL("The action succeeded when it should have failed.");
+    }
+    catch(const T& ex)
+    {
+        std::string exceptionMessage = std::string(ex.what());
+        std::string exceptionMessageRelevantPortion
+            = exceptionMessage.substr(0, exceptionMessageBegin.size());
+        REQUIRE(exceptionMessageRelevantPortion.compare(exceptionMessageBegin) == 0);
+    }
+    catch(...)
+    {
+        FAIL("Another kind of exception was thrown to the one expected");
+    }
+}
+
+TEST_CASE("Missing Closing Bracket Causes Exception")
+{
+    const std::string rawUri = "abc:[...";
+    auto testAction = [&](){pangolin::ParseUri(rawUri);};
+    ExpectExceptionWithMessageFromAction<std::runtime_error>(testAction,
+         "Unable to parse URI: '" + rawUri + "'");
+}
+
+TEST_CASE("Uri Equals Sign Character In Value Truncates The Rest")
+{
+    const std::string fullUri = "abc:[key=value=notfound,key2=value2]";
+    const pangolin::Uri pangoUri = pangolin::ParseUri(fullUri);
+
+    // parsing option list should have precendence over parsing individual option
+    REQUIRE(pangoUri.params.size() ==  2);
+
+    REQUIRE( pangoUri.params[0].first == std::string("key"));
+    REQUIRE( pangoUri.params[1].first == std::string("key2"));
+
+    const std::string truncated = pangoUri.Get<std::string>("key", "");
+    REQUIRE( truncated == std::string("value"));
+
+    const std::string otherValue = pangoUri.Get<std::string>("key2", "");
+    REQUIRE( otherValue == std::string("value2"));
+}
+
+TEST_CASE("Uri Multiple Occurrences Of Option Overrides Previous")
+{
+    const std::string fullUri = "abc:[key=value,key=value2]";
+    const pangolin::Uri pangoUri = pangolin::ParseUri(fullUri);
+
+    REQUIRE(pangoUri.params.size() == 2);
+    REQUIRE( pangoUri.params[0].first == std::string("key"));
+    REQUIRE( pangoUri.params[1].first == std::string("key"));
+
+    const std::string truncated = pangoUri.Get<std::string>("key", "");
+    REQUIRE( truncated == std::string("value2"));
+}
+
+
+TEST_CASE("Uri Url Contains Everything After Separator")
+{
+    const std::string expectedUrl = "abc:123[],=";
+    const std::string fullUri = "abc:[key=value,key=value2]//" + expectedUrl;
+    const pangolin::Uri pangoUri = pangolin::ParseUri(fullUri);
+    REQUIRE( pangoUri.url == expectedUrl);
+}
+
+TEST_CASE("Uri Invalid Characters After Closed Bracket Are Ignored")
+{
+    const std::string expectedUrl = "abc:123[],=";
+    const std::string fullUri = "abc:[key=value,key=value2]xyz//" + expectedUrl;
+    const pangolin::Uri pangoUri = pangolin::ParseUri(fullUri);
+    REQUIRE( pangoUri.url == expectedUrl);
+}

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

@@ -0,0 +1,26 @@
+get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME)
+
+target_sources( ${COMPONENT}
+PRIVATE
+    ${CMAKE_CURRENT_LIST_DIR}/src/display.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/process.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/pangolin_gl.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/handler.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/handler_image.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/handler_glbuffer.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/view.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/widgets.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/image_view.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/ConsoleView.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/default_font.cpp
+)
+
+target_link_libraries(${COMPONENT} PUBLIC pango_core pango_opengl pango_windowing pango_vars )
+
+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}
+)

third-party/DPVO/Pangolin/components/pango_display/include/pangolin/console/ConsoleView.h

@@ -0,0 +1,108 @@
+/* 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 <deque>
+
+#include <pangolin/gl/glfont.h>
+#include <pangolin/gl/colour.h>
+#include <pangolin/var/var.h>
+#include <pangolin/display/view.h>
+#include <pangolin/handler/handler.h>
+
+#include <pangolin/console/InterpreterInterface.h>
+
+namespace pangolin
+{
+
+class ConsoleView : public pangolin::View, pangolin::Handler
+{
+public:
+    struct Line
+    {
+        Line()
+            : linetype(ConsoleLineTypeCmd)
+        {
+        }
+
+        Line(const GlText& text, InterpreterLineType linetype = ConsoleLineTypeCmd )
+            : text(text), linetype(linetype)
+        {
+        }
+
+        GlText text;
+        InterpreterLineType linetype;
+    };
+
+
+    // Construct with interpreter (and take ownership)
+    ConsoleView(const std::shared_ptr<InterpreterInterface>& interpreter);
+
+    ~ConsoleView();
+
+    View& ShowWithoutAnimation(bool show=true);
+
+    // Replace implementation in View to account for hiding animation
+    View& Show(bool show=true);
+
+    // Replace implementation in View to account for hiding animation
+    void ToggleShow();
+
+    // Replace implementation in View to account for hiding animation
+    bool IsShown() const;
+
+    void Render() override;
+
+    void Keyboard(View&, unsigned char key, int x, int y, bool pressed) override;
+
+private:
+    void DrawLine(const ConsoleView::Line& l, int carat);
+
+    void ProcessOutputLines();
+
+    void AddLine(const std::string& text, InterpreterLineType linetype = ConsoleLineTypeCmd);
+
+    Line* GetLine(int id, InterpreterLineType line_type, const std::string& prefix = "");
+
+    std::shared_ptr<InterpreterInterface> interpreter;
+
+    GlFont& font;
+
+    int carat;
+    Line current_line;
+    std::deque<Line> line_buffer;
+
+    bool hiding;
+    GLfloat bottom;
+
+    Colour background_colour;
+    std::map<InterpreterLineType,pangolin::Colour> line_colours;
+    float animation_speed;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_display/include/pangolin/console/InterpreterInterface.h

@@ -0,0 +1,80 @@
+/* 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 <vector>
+#include <string>
+
+namespace pangolin
+{
+
+enum InterpreterLineType
+{
+    ConsoleLineTypeCmd,
+    ConsoleLineTypeCmdOptions,
+    ConsoleLineTypeStdout,
+    ConsoleLineTypeStderr,
+    ConsoleLineTypeOutput,
+    ConsoleLineTypeHelp,
+};
+
+class InterpreterLine
+{
+public:
+    inline InterpreterLine()
+        : linetype(ConsoleLineTypeCmd)
+    {
+    }
+
+    inline InterpreterLine(std::string text, InterpreterLineType linetype = ConsoleLineTypeOutput)
+        : text(text), linetype(linetype)
+    {
+    }
+
+    std::string text;
+    InterpreterLineType linetype;
+};
+
+class InterpreterInterface
+{
+public:
+    inline virtual ~InterpreterInterface()
+    {
+    }
+
+    virtual void PushCommand(const std::string& cmd) = 0;
+
+    virtual bool PullLine(InterpreterLine& line) = 0;
+
+    virtual std::vector<std::string> Complete(
+        const std::string& cmd, int max_options = 20
+    ) = 0;
+
+};
+
+}

third-party/DPVO/Pangolin/components/pango_display/include/pangolin/display/attach.h

@@ -0,0 +1,86 @@
+/* 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 <iostream>
+#include <string>
+#include <cmath>
+
+namespace pangolin
+{
+
+/// Units for measuring screen distances.
+enum Unit {
+    Fraction,
+    Pixel,
+    ReversePixel
+};
+
+/// Defines absolute or relative position from parent viewport edge.
+/// Constructors distinguised by whole pixels, or floating
+/// fraction in interval [0,1]
+struct PANGOLIN_EXPORT Attach {
+    /// Attach to Left/Bottom edge
+    Attach() : unit(Fraction), p(0) {}
+
+    /// General constructor
+    Attach(Unit unit, GLfloat p) : unit(unit), p(p) {}
+
+    /// Specify relative position in range [0,1].
+    /// 0 represents leftmost / bottom-most edge,
+    /// 1 represents rightmost / topmost edge
+    Attach(GLfloat p) : unit(Fraction), p(p) {
+        // Allow for numerical imprecision when checking usage.
+        if( p < -1E-3 || 1.001 < p ) {
+            std::cerr << "Pangolin API Change: Display::SetBounds must be used with Attach::Pix or Attach::ReversePix to specify pixel bounds relative to an edge. See the code samples for details." << std::endl;
+            throw std::exception();
+        }
+    }
+
+    /// Specify absolute position from leftmost / bottom-most edge.
+    static Attach Pix(int p) {
+        return Attach(p >=0 ? Pixel : ReversePixel, std::abs((float)p));
+    }
+
+    /// Specify absolute position from rightmost / topmost edge.
+    static Attach ReversePix(int p) {
+        return Attach(ReversePixel, (GLfloat)p);
+    }
+
+    /// Specify relative position in range [0,1].
+    /// 0 represents leftmost / bottom-most edge,
+    /// 1 represents rightmost / topmost edge
+    static Attach Frac(float frac) {
+        return Attach(frac);
+    }
+
+    Unit unit;
+    GLfloat p;
+};
+
+} // namespace pangolin

third-party/DPVO/Pangolin/components/pango_display/include/pangolin/display/default_font.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <pangolin/gl/glfont.h>
+
+namespace pangolin {
+GlFont& default_font();
+}

third-party/DPVO/Pangolin/components/pango_display/include/pangolin/display/display.h

@@ -0,0 +1,147 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove, Richard Newcombe
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/platform.h>
+#include <pangolin/gl/glinclude.h>
+#include <pangolin/gl/viewport.h>
+#include <pangolin/utils/params.h>
+#include <pangolin/windowing/window.h>
+
+#include <functional>
+#include <string>
+#include <memory>
+
+/*! \file display.h
+ * This file contains a number of global methods for creating and
+ * querying window state as well as handling user input.
+ */
+
+namespace pangolin
+{
+
+  // Forward Declarations
+  struct View;
+  class  UserApp;
+  
+  /// Give this OpenGL context a name or switch contexts.
+  /// This is required to initialise Pangolin for use with an
+  /// externally defined OpenGL context. You needn't call it
+  /// if you have used CreateWindowAndBind() to create a window
+  /// or launched a pangolin::UserApp
+  PANGOLIN_EXPORT
+  void BindToContext(std::string name);
+
+  /// Initialise OpenGL window (determined by platform) and bind context.
+  /// This method will choose an available windowing system if one is present.
+  PANGOLIN_EXPORT
+  WindowInterface& CreateWindowAndBind(std::string window_title, int w = 640, int h = 480, const Params& params = Params());
+
+  /// Return pointer to current Pangolin Window context, or nullptr if none bound.
+  PANGOLIN_EXPORT
+  WindowInterface* GetBoundWindow();
+
+  PANGOLIN_EXPORT
+  void DestroyWindow(const std::string& window_title);
+
+  /// Launch users derived UserApp, controlling OpenGL event loop.
+  /// This method will block until the application exits, calling app's
+  /// Init() method to start and Render() method subsequently to draw each frame.
+  /// @return exit code for use when returning from main. Currently always 0.
+  PANGOLIN_EXPORT
+  int LaunchUserApp(UserApp& app);
+  
+  /// Perform any post rendering, event processing and frame swapping.
+  PANGOLIN_EXPORT
+  void FinishFrame();
+
+  /// Request that the window close.
+  PANGOLIN_EXPORT
+  void Quit();
+
+  /// Request that all windows close.
+  PANGOLIN_EXPORT
+  void QuitAll();
+
+  /// Returns true if user has requested to close OpenGL window.
+  PANGOLIN_EXPORT
+  bool ShouldQuit();
+
+  /// Renders any views with default draw methods.
+  PANGOLIN_EXPORT
+  void RenderViews();
+  
+  /// Perform any post render events, such as screen recording.
+  PANGOLIN_EXPORT
+  void PostRender();
+
+  /// Request to be notified via functor when key is pressed.
+  PANGOLIN_EXPORT
+  void RegisterKeyPressCallback(int key, std::function<void(void)> func);
+
+  /// Request to be notified via functor when key is pressed.
+  /// Functor may take one parameter which will equal the key pressed
+  PANGOLIN_EXPORT
+  void RegisterKeyPressCallback(int key, std::function<void(int)> func);
+
+  /// Save the contents of current window within the specified viewport (whole window by default).
+  /// This will be called during pangolin::FinishFrame().
+  /// \param filename_hint can be a complete filename (absolute or relative to working directory).
+  /// \param the portion of the window to save. Default construction will save entire window.
+  PANGOLIN_EXPORT
+  void SaveWindowOnRender(const std::string& filename_hint, const Viewport& v = Viewport());
+
+  /// Save the contents of current window within the specified viewport (whole window by default).
+  /// This will block whilst waiting for pending draw calls to complete and then save the current contents.
+  /// \param filename_hint can be a complete filename (absolute or relative to working directory).
+  /// \param the portion of the window to save. Default construction will save entire window.
+  PANGOLIN_EXPORT
+  void SaveWindowNow(const std::string& filename_hint, const Viewport& v = Viewport());
+  
+  /// Retrieve 'base' display, corresponding to entire window.
+  PANGOLIN_EXPORT
+  View& DisplayBase();
+
+  /// Create or retrieve named display managed by pangolin (automatically deleted).
+  PANGOLIN_EXPORT
+  View& Display(const std::string& name);
+
+  /// Create unnamed display managed by pangolin (automatically deleted).
+  PANGOLIN_EXPORT
+  View& CreateDisplay();
+
+  /// Switch windows/fullscreenmode = fullscreen.
+  PANGOLIN_EXPORT
+  void ShowFullscreen(TrueFalseToggle on_off);
+
+  /// Toggle display of Pangolin console
+  PANGOLIN_EXPORT
+  void ShowConsole(TrueFalseToggle on_off);
+}
+
+#include <pangolin/display/display.hpp>

third-party/DPVO/Pangolin/components/pango_display/include/pangolin/display/display.hpp

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

third-party/DPVO/Pangolin/components/pango_display/include/pangolin/display/image_view.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <pangolin/display/display.h>
+#include <pangolin/gl/glpixformat.h>
+#include <pangolin/gl/glformattraits.h>
+#include <pangolin/gl/glsl.h>
+#include <pangolin/handler/handler_image.h>
+#include <pangolin/image/image_utils.h>
+
+#include <mutex>
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT ImageView : public pangolin::View, public pangolin::ImageViewHandler
+{
+  public:
+    ImageView(const std::string & title ="");
+
+    ~ImageView();
+
+    void Render() override;
+
+    void Mouse(View& view, pangolin::MouseButton button, int x, int y, bool pressed, int button_state) override;
+
+    void Keyboard(View& view, unsigned char key, int x, int y, bool pressed) override;
+
+    pangolin::GlTexture& Tex();
+
+    ImageView& SetImage(void* ptr, size_t w, size_t h, size_t pitch, pangolin::GlPixFormat img_fmt, bool delayed_upload = false);
+
+    ImageView& SetImage(const pangolin::Image<unsigned char>& img, const pangolin::GlPixFormat& glfmt, bool delayed_upload = false);
+
+    template<typename T> inline
+    ImageView& SetImage(const pangolin::Image<T>& img, bool delayed_upload = false)
+    {
+        return SetImage(img.template UnsafeReinterpret<unsigned char>(), GlPixFormat::FromType<T>(), delayed_upload);
+    }
+
+    ImageView& SetImage(const pangolin::TypedImage& img, bool delayed_upload = false);
+
+    ImageView& SetImage(const pangolin::GlTexture& texture);
+
+    void LoadPending();
+
+    ImageView& Clear();
+
+    std::pair<float, float>& GetOffsetScale();
+
+    bool MouseReleased() const;
+
+    bool MousePressed() const;
+
+    void SetRenderOverlay(const bool& val);
+
+//  private:
+    // img_to_load contains image data that should be uploaded to the texture on
+    // the next render cycle. The data is owned by this object and should be
+    // freed after use.
+    pangolin::ManagedImage<unsigned char> img_to_load;
+    pangolin::GlPixFormat img_fmt_to_load;
+
+    std::pair<float, float> offset_scale;
+    pangolin::GlPixFormat fmt;
+    pangolin::GlTexture tex;
+    bool lastPressed;
+    bool mouseReleased;
+    bool mousePressed;
+    bool overlayRender;
+
+    std::mutex texlock;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_display/include/pangolin/display/process.h

@@ -0,0 +1,59 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove, Richard Newcombe
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/platform.h>
+#include <pangolin/windowing/handler_bitsets.h>
+
+namespace pangolin
+{
+
+/// You can use these methods to drive Pangolin events when it
+/// doesn't own the OpenGL Context. You can probably ignore these.
+namespace process
+{
+  PANGOLIN_EXPORT
+  void Resize(int width, int height);
+
+  PANGOLIN_EXPORT
+  void Keyboard(unsigned char key, int x, int y, bool pressed, KeyModifierBitmask key_modifiers);
+
+  PANGOLIN_EXPORT
+  void Mouse(int button, bool pressed, int x, int y, KeyModifierBitmask key_modifiers);
+
+  PANGOLIN_EXPORT
+  void MouseMotion( int x, int y, KeyModifierBitmask key_modifiers);
+
+  PANGOLIN_EXPORT
+  void PassiveMouseMotion(int x, int y, KeyModifierBitmask key_modifiers);
+
+  PANGOLIN_EXPORT
+  void SpecialInput(InputSpecial inType, float x, float y, float p1, float p2, float p3, float p4, KeyModifierBitmask key_modifiers);
+}
+
+}

third-party/DPVO/Pangolin/components/pango_display/include/pangolin/display/user_app.h

@@ -0,0 +1,43 @@
+/* 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>
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT UserApp
+{
+public:
+    virtual ~UserApp() {}
+    virtual void Init() {}
+    virtual void Render() = 0;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_display/include/pangolin/display/view.h

@@ -0,0 +1,231 @@
+/* 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 <functional>
+#include <vector>
+
+#include <pangolin/gl/viewport.h>
+#include <pangolin/display/attach.h>
+
+namespace pangolin
+{
+
+enum Layout
+{
+    LayoutOverlay,
+    LayoutVertical,
+    LayoutHorizontal,
+    LayoutEqual,
+    LayoutEqualVertical,
+    LayoutEqualHorizontal
+};
+
+enum Lock {
+    LockLeft = 0,
+    LockBottom = 0,
+    LockCenter = 1,
+    LockRight = 2,
+    LockTop = 2
+};
+
+// Forward declarations
+struct Handler;
+
+class OpenGlRenderState;
+
+/// A Display manages the location and resizing of an OpenGl viewport.
+struct PANGOLIN_EXPORT View
+{
+    View(double aspect=0.0)
+        : aspect(aspect), top(1.0),left(0.0),right(1.0),bottom(0.0), hlock(LockCenter),vlock(LockCenter),
+          layout(LayoutOverlay), scroll_offset(0), show(1), zorder(0), handler(0), scroll_show(1) {}
+    
+    virtual ~View() {}
+    
+    //! Activate Displays viewport for drawing within this area
+    void Activate() const;
+    
+    //! Activate Displays and set State Matrices
+    void Activate(const OpenGlRenderState& state ) const;
+    
+    //! Activate Displays viewport and Scissor for drawing within this area
+    void ActivateAndScissor() const;
+    
+    //! Activate Displays viewport and Scissor for drawing within this area
+    void ActivateScissorAndClear() const;
+    
+    //! Activate Display and set State Matrices
+    void ActivateAndScissor(const OpenGlRenderState& state ) const;
+    
+    //! Activate Display and set State Matrices
+    void ActivateScissorAndClear(const OpenGlRenderState& state ) const;
+    
+    //! Activate Display and setup coordinate system for 2d pixel View coordinates
+    void ActivatePixelOrthographic() const;
+    
+    //! Activate Display and reset coordinate system to OpenGL default
+    void ActivateIdentity() const;
+    
+    //! Return closest depth buffer value within radius of window (winx,winy)
+    GLfloat GetClosestDepth(int winx, int winy, int radius) const;
+    
+    //! Obtain camera space coordinates of scene at pixel (winx, winy, winzdepth)
+    //! winzdepth can be obtained from GetClosestDepth
+    void GetCamCoordinates(const OpenGlRenderState& cam_state, double winx, double winy, double winzdepth, GLdouble& x, GLdouble& y, GLdouble& z) const;
+    
+    //! Obtain object space coordinates of scene at pixel (winx, winy, winzdepth)
+    //! winzdepth can be obtained from GetClosestDepth
+    void GetObjectCoordinates(const OpenGlRenderState& cam_state, double winx, double winy, double winzdepth, GLdouble& x, GLdouble& y, GLdouble& z) const;
+    
+    //! Given the specification of Display, compute viewport
+    virtual void Resize(const Viewport& parent);
+    
+    //! Instruct all children to resize
+    virtual void ResizeChildren();
+    
+    //! Perform any automatic rendering for this View.
+    //! Default implementation simply instructs children to render themselves.
+    virtual void Render();
+    
+    //! Instruct all children to render themselves if appropriate
+    virtual void RenderChildren();
+    
+    //! Set this view as the active View to receive input
+    View& SetFocus();
+
+    //! Returns true iff this view currently has focus and will receive user input
+    bool HasFocus() const;
+
+    //! Set bounds for the View using mixed fractional / pixel coordinates (OpenGl view coordinates)
+    View& SetBounds(Attach bottom, Attach top, Attach left, Attach right);
+   
+    //! Set bounds for the View using mixed fractional / pixel coordinates (OpenGl view coordinates)
+    View& SetBounds(Attach bottom, Attach top, Attach left, Attach right, bool keep_aspect);
+    
+    //! Set bounds for the View using mixed fractional / pixel coordinates (OpenGl view coordinates)
+    View& SetBounds(Attach bottom, Attach top, Attach left, Attach right, double aspect);
+    
+    //! Designate handler for accepting mouse / keyboard input.
+    View& SetHandler(Handler* handler);
+    
+    //! Set drawFunc as the drawing function for this view
+    View& SetDrawFunction(const std::function<void(View&)>& drawFunc);
+    
+    //! Force this view to have the given aspect, whilst fitting snuggly
+    //! within the parent. A negative value with 'over-draw', fitting the
+    //! smaller side of the parent.
+    View& SetAspect(double aspect);
+    
+    //! Set how this view should be positioned relative to its parent
+    View& SetLock(Lock horizontal, Lock vertical );
+    
+    //! Set layout policy for this view
+    View& SetLayout(Layout layout);
+    
+    //! Add view as child
+    View& AddDisplay(View& view);
+    
+    //! Show / hide this view
+    View& Show(bool show=true);
+    
+    //! Toggle this views visibility
+    void ToggleShow();
+    
+    //! Return whether this view should be shown.
+    //! This method should be checked if drawing manually
+    bool IsShown() const;
+    
+    //! Returns viewport reflecting space that will actually get drawn
+    //! The minimum of vp and v
+    Viewport GetBounds() const;
+    
+    //! Return number of child views attached to this view
+    size_t NumChildren() const;
+    
+    //! Return (i)th child of this view
+    View& operator[](size_t i);
+    
+    //! Return number of visible child views attached to this view.
+    size_t NumVisibleChildren() const;
+    
+    //! Return visible child by index.
+    View& VisibleChild(size_t i);
+    
+    //! Return visible child at window coords x,y
+    View* FindChild(int x, int y);  
+    
+    // Desired width / height aspect (0 if dynamic)
+    double aspect;
+    
+    // Bounds to fit display within
+    Attach top, left, right, bottom;
+    Lock hlock;
+    Lock vlock;
+    Layout layout;
+    
+    int scroll_offset;
+    
+    // Cached client area (space allocated from parent)
+    Viewport vp;
+    
+    // Cached absolute viewport (recomputed on resize - respects aspect)
+    Viewport v;
+    
+    // Should this view be displayed?
+    bool show;
+
+    // Child views are rendered in order of low to high z-order
+    // Views default to 0 z-order
+    int zorder;
+    
+    // Input event handler (if any)
+    Handler* handler;
+    
+    // Map for sub-displays (if any)
+    std::vector<View*> views;
+    
+    // External draw function
+    std::function<void(View&)> extern_draw_function;
+
+    ////////////////////////////////////////////////
+
+    PANGOLIN_DEPRECATED("Use pangolin::SaveWindowOnRender(...) instead.")
+    void SaveOnRender(const std::string& filename_hint);
+
+    PANGOLIN_DEPRECATED("Use pangolin::SaveWindowNow(...) instead.")
+    void SaveRenderNow(const std::string& filename_hint);
+    
+private:
+    // Private copy constructor
+    View(View&) { /* Do Not copy - take reference instead*/ }
+    
+    bool scroll_show;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_display/include/pangolin/display/widgets.h

@@ -0,0 +1,161 @@
+/* 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/display/view.h>
+#include <pangolin/var/var.h>
+#include <pangolin/handler/handler.h>
+#include <pangolin/gl/glfont.h>
+
+#include <functional>
+
+namespace pangolin
+{
+
+PANGOLIN_EXPORT
+View& CreatePanel(const std::string& name);
+
+struct PANGOLIN_EXPORT Panel : public View
+{
+    Panel();
+    Panel(const std::string& auto_register_var_prefix);
+    void Render();
+    void ResizeChildren();
+
+private:
+    void NewVarCallback(const VarState::Event& e);
+    void AddVariable(const std::string& name, const std::shared_ptr<VarValueGeneric> &var);
+    void RemoveVariable(const std::string& name);
+
+    sigslot::scoped_connection var_added_connection;
+    std::string auto_register_var_prefix;
+};
+
+template<typename T>
+struct Widget : public View, Handler, Var<T>
+{
+    Widget(std::string title, const std::shared_ptr<VarValueGeneric>& tv)
+        : Var<T>(tv), title(title)
+    {
+        handler = this;
+    }
+    
+    std::string title;
+};
+
+struct PANGOLIN_EXPORT Button : public Widget<bool>
+{
+    Button(std::string title, const std::shared_ptr<VarValueGeneric> &tv);
+    void Mouse(View&, MouseButton button, int x, int y, bool pressed, int mouse_state);
+    void Render();
+    
+    //Cache params on resize
+    void ResizeChildren();
+    GlText gltext;
+    GLfloat raster[2];
+    bool down;
+};
+
+struct PANGOLIN_EXPORT FunctionButton : public Widget<std::function<void(void)> >
+{
+    FunctionButton(std::string title, const std::shared_ptr<VarValueGeneric> &tv);
+    void Mouse(View&, MouseButton button, int x, int y, bool pressed, int mouse_state);
+    void Render();
+
+    //Cache params on resize
+    void ResizeChildren();
+    GlText gltext;
+    GLfloat raster[2];
+    bool down;
+};
+
+struct PANGOLIN_EXPORT Checkbox : public Widget<bool>
+{
+    Checkbox(std::string title, const std::shared_ptr<VarValueGeneric>& tv);
+    void Mouse(View&, MouseButton button, int x, int y, bool pressed, int mouse_state);
+    void Render();
+    
+    //Cache params on resize
+    void ResizeChildren();
+    GlText gltext;
+    GLfloat raster[2];
+    Viewport vcb;
+};
+
+struct PANGOLIN_EXPORT Slider : public Widget<double>
+{
+    Slider(std::string title, const std::shared_ptr<VarValueGeneric>& tv);
+    void Mouse(View&, MouseButton button, int x, int y, bool pressed, int mouse_state);
+    void MouseMotion(View&, int x, int y, int mouse_state);
+    void Keyboard(View&, unsigned char key, int x, int y, bool pressed);
+    void Render();
+    
+    //Cache params on resize
+    void ResizeChildren();
+    GlText gltext;
+    GLfloat raster[2];
+    bool lock_bounds;
+    bool logscale;
+    bool is_integral_type;
+};
+
+struct PANGOLIN_EXPORT TextInput : public Widget<std::string>
+{
+    TextInput(std::string title, const std::shared_ptr<VarValueGeneric>& tv);
+    void Mouse(View&, MouseButton button, int x, int y, bool pressed, int mouse_state);
+    void MouseMotion(View&, int x, int y, int mouse_state);
+    void Keyboard(View&, unsigned char key, int x, int y, bool pressed);
+    void Render();
+    
+    std::string edit;
+    GlText gledit;
+
+    //Cache params on resize
+    void ResizeChildren();
+    void CalcVisibleEditPart();
+    GlText gltext;
+    bool can_edit;
+    bool do_edit;
+    int sel[2];
+    GLfloat vertical_margin;
+    GLfloat horizontal_margin = 2.f;
+    int input_width;
+    int edit_visible_part[2] = {0,1};
+};
+
+
+inline bool GuiVarHasChanged() {
+    Var<bool> changed("pango.widgets.gui_changed");
+    return bool(changed) && !(changed = false);
+}
+
+inline void FlagVarChanged() {
+    Var<bool>("pango.widgets.gui_changed") = true;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_display/include/pangolin/handler/handler.h

@@ -0,0 +1,139 @@
+/* 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/opengl_render_state.h>
+#include <pangolin/gl/gl.h>
+#include <pangolin/windowing/handler_enums.h>
+
+#if defined(HAVE_EIGEN) && !defined(__CUDACC__) //prevent including Eigen in cuda files
+#define USE_EIGEN
+#endif
+
+#ifdef USE_EIGEN
+#include <Eigen/Core>
+#endif
+
+#ifdef _OSX_
+#define PANGO_DFLT_HANDLER3D_ZF (1.0f/50.0f)
+#else
+#define PANGO_DFLT_HANDLER3D_ZF (1.0f/10.0f)
+#endif
+
+namespace pangolin
+{
+
+// Forward declarations
+struct View;
+
+/// Input Handler base class.
+/// Virtual methods which recurse into sub-displays.
+struct PANGOLIN_EXPORT Handler
+{
+    virtual ~Handler() {}
+    virtual void Keyboard(View&, unsigned char key, int x, int y, bool pressed);
+    virtual void Mouse(View&, MouseButton button, int x, int y, bool pressed, int button_state);
+    virtual void MouseMotion(View&, int x, int y, int button_state);
+    virtual void PassiveMouseMotion(View&, int x, int y, int button_state);
+    virtual void Special(View&, InputSpecial inType, float x, float y, float p1, float p2, float p3, float p4, int button_state);
+};
+
+struct PANGOLIN_EXPORT HandlerScroll : Handler
+{
+    void Mouse(View&, MouseButton button, int x, int y, bool pressed, int button_state);
+    void Special(View&, InputSpecial inType, float x, float y, float p1, float p2, float p3, float p4, int button_state);
+};
+
+struct PANGOLIN_EXPORT HandlerBase3D : Handler
+{
+    HandlerBase3D(OpenGlRenderState& cam_state, AxisDirection enforce_up=AxisNone, float trans_scale=0.01f, float zoom_fraction= PANGO_DFLT_HANDLER3D_ZF);
+
+    virtual bool ValidWinDepth(GLprecision depth);
+    virtual void PixelUnproject( View& view, GLprecision winx, GLprecision winy, GLprecision winz, GLprecision Pc[3]);
+    virtual void GetPosNormal(View& view, int x, int y, GLprecision p[3], GLprecision Pw[3], GLprecision Pc[3], GLprecision nw[3], GLprecision default_z = 1.0);
+    virtual void GetPosNormalImpl(View& view, int x, int y, GLprecision p[3], GLprecision Pw[3], GLprecision Pc[3], GLprecision nw[3], GLprecision default_z, float *zs);
+
+    void Keyboard(View&, unsigned char key, int x, int y, bool pressed);
+    void Mouse(View&, MouseButton button, int x, int y, bool pressed, int button_state);
+    void MouseMotion(View&, int x, int y, int button_state);
+    void Special(View&, InputSpecial inType, float x, float y, float p1, float p2, float p3, float p4, int button_state);
+    
+#ifdef USE_EIGEN
+    // Return selected point in world coordinates
+    inline Eigen::Vector3d Selected_P_w() const {
+        return Eigen::Map<const Eigen::Matrix<GLprecision,3,1>>(Pw).cast<double>();
+    }
+#endif
+    inline int KeyState() const{
+        return funcKeyState;
+    }
+
+protected:
+    OpenGlRenderState* cam_state;
+    const static int hwin = 8;
+    AxisDirection enforce_up;
+    float tf; // translation factor
+    float zf; // zoom fraction
+    CameraSpec cameraspec;
+    GLprecision last_z;
+    float last_pos[2];
+    GLprecision rot_center[3];
+    
+    GLprecision p[3];
+    GLprecision Pw[3];
+    GLprecision Pc[3];
+    GLprecision n[3];
+
+    int funcKeyState;
+};
+
+#ifndef HAVE_GLES
+using Handler3D = HandlerBase3D;
+#else
+struct PANGOLIN_EXPORT Handler3DBlitCopy : public pangolin::HandlerBase3D
+{
+    Handler3DBlitCopy(pangolin::OpenGlRenderState& cam_state, pangolin::AxisDirection enforce_up=pangolin::AxisNone, float trans_scale=0.01f);
+    void GetPosNormal(pangolin::View& view, int x, int y, GLprecision p[3], GLprecision Pw[3], GLprecision Pc[3], GLprecision /*n*/[3], GLprecision default_z = 1.0);
+
+protected:
+    GlTexture rgb_blit;
+    GlTexture depth_blit;
+    GlFramebuffer fb_blit;
+
+    GlTexture rgb;
+    GlTexture depth;
+    GlFramebuffer fb;
+};
+using Handler3D = Handler3DBlitCopy;
+#endif
+
+
+static Handler StaticHandler;
+static HandlerScroll StaticHandlerScroll;
+
+}

third-party/DPVO/Pangolin/components/pango_display/include/pangolin/handler/handler_glbuffer.h

@@ -0,0 +1,48 @@
+/* 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 HANDLER_GLBUFFER_H
+#define HANDLER_GLBUFFER_H
+
+#include <pangolin/handler/handler.h>
+#include <pangolin/gl/gl.h>
+
+namespace pangolin
+{
+
+struct PANGOLIN_EXPORT Handler3DFramebuffer : public pangolin::HandlerBase3D
+{
+    Handler3DFramebuffer(GlFramebuffer& fb, pangolin::OpenGlRenderState& cam_state, pangolin::AxisDirection enforce_up=pangolin::AxisNone, float trans_scale=0.01f);
+    void GetPosNormal(pangolin::View& view, int x, int y, GLprecision p[3], GLprecision Pw[3], GLprecision Pc[3], GLprecision /*n*/[3], GLprecision default_z);
+
+protected:
+    GlFramebuffer& fb;
+};
+
+}
+
+#endif // HANDLER_GLBUFFER_H

third-party/DPVO/Pangolin/components/pango_display/include/pangolin/handler/handler_image.h

@@ -0,0 +1,166 @@
+/* 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/image/image_utils.h>
+#include <pangolin/display/view.h>
+#include <pangolin/handler/handler.h>
+#include <pangolin/gl/viewport.h>
+#include <pangolin/gl/gl.h>
+#include <pangolin/utils/range.h>
+
+#include <functional>
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT ImageViewHandler : public Handler
+{
+public:
+    struct EventData {
+        EventData(View& v, ImageViewHandler& h) : view(v), handler(h) {}
+        View& view;
+        ImageViewHandler& handler;
+    };
+
+    struct OnSelectionEventData : public EventData {
+        OnSelectionEventData(View& v, ImageViewHandler& h, bool dragging)
+            : EventData(v,h), dragging(dragging) {}
+        bool dragging;
+    };
+
+    typedef std::function<void(OnSelectionEventData)> OnSelectionCallbackFn;
+
+    // Default constructor: User must call SetDimensions() once image dimensions are known.
+    // Default range is [0,1] in x and y.
+    ImageViewHandler(const std::string & title = "");
+
+    // View ranges store extremes of image (boundary of pixels)
+    // in 'discrete' coords, where 0,0 is center of top-left pixel.
+    ImageViewHandler(size_t w, size_t h);
+
+    void SetDimensions(size_t w, size_t h);
+
+    void UpdateView();
+
+    void glSetViewOrtho();
+
+    void glRenderTexture(pangolin::GlTexture& tex);
+    void glRenderTexture(GLuint tex, GLint width, GLint height);
+    void glRenderTexture(GLuint tex, GLint width, GLint height, XYRangef tex_region);
+
+
+    void glRenderOverlay();
+
+    void ScreenToImage(Viewport& v, float xpix, float ypix, float& ximg, float& yimg);
+
+    void ImageToScreen(Viewport& v, float ximg, float yimg, float& xpix, float& ypix);
+
+    bool UseNN() const;
+
+    bool& UseNN();
+
+    bool& FlipTextureX();
+
+    bool& FlipTextureY();
+
+    pangolin::XYRangef& GetViewToRender();
+
+    float GetViewScale();
+
+    pangolin::XYRangef& GetView();
+
+    pangolin::XYRangef& GetDefaultView();
+
+    pangolin::XYRangef& GetSelection();
+
+    void GetHover(float& x, float& y);
+
+    void SetView(const pangolin::XYRangef& range);
+
+    void SetViewSmooth(const pangolin::XYRangef& range);
+
+    void ScrollView(float x, float y);
+
+    void ScrollViewSmooth(float x, float y);
+
+    void ScaleView(float x, float y, float cx, float cy);
+
+    void ScaleViewSmooth(float x, float y, float cx, float cy);
+
+    void ResetView();
+
+    ///////////////////////////////////////////////////////
+    /// pangolin::Handler
+    ///////////////////////////////////////////////////////
+
+    void Keyboard(View&, unsigned char key, int /*x*/, int /*y*/, bool pressed) override;
+
+    void Mouse(View& view, pangolin::MouseButton button, int x, int y, bool pressed, int button_state) override;
+
+    void MouseMotion(View& view, int x, int y, int button_state) override;
+
+    void PassiveMouseMotion(View&, int /*x*/, int /*y*/, int /*button_state*/) override;
+
+    void Special(View& view, pangolin::InputSpecial inType, float x, float y, float p1, float p2, float /*p3*/, float /*p4*/, int /*button_state*/) override;
+
+    ///////////////////////////////////////////////////////
+    /// Callbacks
+    ///////////////////////////////////////////////////////
+
+    OnSelectionCallbackFn OnSelectionCallback;
+
+protected:
+    void FixSelection(XYRangef& sel);
+
+    void AdjustScale();
+
+    void AdjustTranslation();
+
+    static ImageViewHandler* to_link;
+    static float animate_factor;
+
+    ImageViewHandler* linked_view_handler;
+
+    pangolin::XYRangef rview_default;
+    pangolin::XYRangef rview_max;
+    pangolin::XYRangef rview;
+    pangolin::XYRangef target;
+    pangolin::XYRangef selection;
+
+    float hover_img[2];
+    int last_mouse_pos[2];
+
+    bool use_nn;
+    bool flipTextureX;
+    bool flipTextureY;
+    std::string title;
+
+};
+
+}

third-party/DPVO/Pangolin/components/pango_display/src/ConsoleView.cpp

@@ -0,0 +1,327 @@
+#include <iterator>
+#include <pangolin/console/ConsoleView.h>
+#include <pangolin/utils/picojson.h>
+#include <pangolin/gl/gldraw.h>
+#include <pangolin/display/default_font.h>
+
+namespace pangolin
+{
+
+inline Colour ParseJson(const picojson::value& val)
+{
+    return Colour(
+        val.contains("r") ? val["r"].get<double>() : 0.0,
+        val.contains("g") ? val["g"].get<double>() : 0.0,
+        val.contains("b") ? val["b"].get<double>() : 0.0,
+        val.contains("a") ? val["a"].get<double>() : 1.0
+    );
+}
+
+inline picojson::value toJson(const Colour& colour)
+{
+    picojson::value ret(picojson::object_type,true);
+    ret["r"] = colour.r;
+    ret["g"] = colour.g;
+    ret["b"] = colour.b;
+    ret["a"] = colour.a;
+    return ret;
+}
+
+inline std::ostream& operator<<(std::ostream& os, const Colour& colour)
+{
+    os << toJson(colour).serialize();
+    return os;
+}
+
+inline std::istream& operator>>(std::istream& is, Colour& colour)
+{
+    picojson::value val;
+    picojson::parse(val,is);
+    colour = ParseJson(val);
+    return is;
+}
+
+inline void glColour(const Colour& c)
+{
+    glColor4f(c.r,c.g,c.b,c.a);
+}
+
+ConsoleView::ConsoleView(const std::shared_ptr<InterpreterInterface> &interpreter)
+    : interpreter(interpreter),
+      font(default_font()),
+      carat(0),
+      hiding(false),
+      bottom(1.0f),
+      background_colour(0.2f, 0.0f, 0.0f, 0.6f),
+      animation_speed(0.2)
+{
+    SetHandler(this);
+
+    line_colours[ConsoleLineTypeCmd]        = Colour(1.0f,1.0f,1.0f,1.0f);
+    line_colours[ConsoleLineTypeCmdOptions] = Colour(0.9f,0.9f,0.9f,1.0f);
+    line_colours[ConsoleLineTypeOutput]     = Colour(0.0f,1.0f,1.0f,1.0f);
+    line_colours[ConsoleLineTypeHelp]       = Colour(1.0f,0.8f,1.0f,1.0f);
+    line_colours[ConsoleLineTypeStdout]     = Colour(0.0f,0.0f,1.0f,1.0f);
+    line_colours[ConsoleLineTypeStderr]     = Colour(1.0f,0.8f,0.8f,1.0f);
+
+    Var<Colour>::Attach("pango.console.colours.Background", background_colour);
+    Var<Colour>::Attach("pango.console.colours.Cmd",        line_colours[ConsoleLineTypeCmd]);
+    Var<Colour>::Attach("pango.console.colours.CmdOptions", line_colours[ConsoleLineTypeCmdOptions]);
+    Var<Colour>::Attach("pango.console.colours.Stdout",     line_colours[ConsoleLineTypeStdout]);
+    Var<Colour>::Attach("pango.console.colours.Stderr",     line_colours[ConsoleLineTypeStderr]);
+    Var<Colour>::Attach("pango.console.colours.Output",     line_colours[ConsoleLineTypeOutput]);
+    Var<Colour>::Attach("pango.console.colours.Help",       line_colours[ConsoleLineTypeHelp]);
+
+    Var<float>::Attach("pango.console.animation_speed", animation_speed);
+
+    AddLine("Pangolin Console:", ConsoleLineTypeHelp);
+    AddLine("===============================", ConsoleLineTypeHelp);
+}
+
+ConsoleView::~ConsoleView() {
+}
+
+void ConsoleView::ProcessOutputLines()
+{
+    // empty output queue
+    InterpreterLine line_in;
+    while(interpreter->PullLine(line_in))
+    {
+        AddLine(line_in.text, line_in.linetype);
+    }
+}
+
+View& ConsoleView::ShowWithoutAnimation(bool should_show){
+    Show(should_show);
+    bottom = show ? 1.0 : 0.0;
+    return *this;
+}
+
+View& ConsoleView::Show(bool should_show)
+{
+    if(should_show) {
+        hiding = false;
+        show = true;
+    }else{
+        hiding = true;
+    }
+    return *this;
+}
+
+void ConsoleView::ToggleShow()
+{
+    Show(!IsShown());
+}
+
+bool ConsoleView::IsShown() const
+{
+    return show && !hiding;
+}
+
+void ConsoleView::DrawLine(const ConsoleView::Line& l, int carat=-1)
+{
+    glColour(line_colours[l.linetype]);
+    l.text.Draw();
+    if(carat >= 0) {
+        const double w = font.Text(l.text.str.substr(0,carat)).Width();
+        glDrawLine(w,-2,w,font.Height()-4);
+    }
+}
+
+void ConsoleView::Render()
+{
+    if(hiding) {
+        bottom += (1.0f - bottom) * animation_speed;
+        if(1.0 - bottom < 0.01) {
+            bottom = 1.0;
+            show = false;
+            hiding = false;
+            return;
+        }
+    }else{
+        if(bottom > 0.01f) {
+            bottom -= bottom*animation_speed;
+        }else{
+            bottom = 0.0f;
+        }
+    }
+
+    ProcessOutputLines();
+
+#ifndef HAVE_GLES
+    glPushAttrib(GL_CURRENT_BIT | GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT | GL_SCISSOR_BIT | GL_VIEWPORT_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT);
+#endif
+
+    this->ActivatePixelOrthographic();
+    glDisable(GL_DEPTH_TEST );
+    glDisable(GL_LIGHTING);
+    glDisable(GL_SCISSOR_TEST);
+    glDisable(GL_LINE_SMOOTH);
+    glDisable( GL_COLOR_MATERIAL );
+    glLineWidth(1.0);
+
+    glEnable(GL_BLEND);
+    glBlendFunc( GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA );
+
+    glColour(background_colour);
+
+    GLfloat verts[] = { 0.0f, (GLfloat)v.h,
+                        (GLfloat)v.w, (GLfloat)v.h,
+                        (GLfloat)v.w, bottom*v.h,
+                        0.0f, bottom*v.h };
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glVertexPointer(2, GL_FLOAT, 0, verts);
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+    glDisableClientState(GL_VERTEX_ARRAY);
+
+
+    const GLfloat line_space = font.Height();
+    glTranslatef(10.0f, 10.0f + bottom*v.h, 0.0f );
+    DrawLine(current_line, carat);
+    glTranslatef(0.0f, line_space, 0.0f);
+    for(size_t l=0; l < line_buffer.size(); ++l) {
+        DrawLine(line_buffer[l]);
+        glTranslatef(0.0f, line_space, 0.0f);
+    }
+
+#ifndef HAVE_GLES
+    glPopAttrib();
+#endif
+}
+
+inline std::string CommonPrefix(const std::vector<std::string>& vec)
+{
+    if(!vec.size()) return "";
+
+    size_t cmn = vec[0].size();
+    for(size_t i=1; i<vec.size(); ++i) {
+        cmn = std::min(vec[i].size(), cmn);
+        for(size_t p=0; p < cmn; ++p) {
+            if(vec[i][p] != vec[0][p]) {
+                cmn = p;
+                break;
+            }
+        }
+    }
+
+    return vec[0].substr(0,cmn);
+}
+
+void ConsoleView::Keyboard(View&, unsigned char key, int /*x*/, int /*y*/, bool pressed)
+{
+    static int hist_id = -1;
+    static std::string prefix;
+    static bool edited = true;
+
+    if(pressed) {
+        if(key=='\r') key = '\n';
+
+        GlText& txt = current_line.text;
+        const std::string cmd = txt.Text();
+
+        if(key=='`') {
+            ToggleShow();
+        } else if(key=='\n') {
+            interpreter->PushCommand(cmd);
+            line_buffer.push_front(current_line);
+            hist_id = -1;
+            prefix = "";
+            edited = true;
+            carat = 0;
+            txt.Clear();
+        }else if(key=='\t') {
+            std::vector<std::string> options = interpreter->Complete(cmd,100);
+            if(options.size()) {
+                const std::string common = CommonPrefix(options);
+                if(common.size() > cmd.size()) {
+                    current_line = font.Text("%s", common.c_str());
+                    carat = common.size();
+                }else{
+                    std::stringstream s;
+                    std::copy(options.begin(), options.end(), std::ostream_iterator<std::string>(s,", "));
+                    AddLine(s.str(), ConsoleLineTypeCmdOptions);
+                }
+            }
+        }else if(key==PANGO_SPECIAL + PANGO_KEY_UP) {
+            if(edited) {
+                prefix = cmd;
+                edited = false;
+            }
+            Line* hist_line = GetLine(hist_id+1, ConsoleLineTypeCmd, prefix);
+            if(hist_line) {
+                current_line = *hist_line;
+                hist_id++;
+            }
+        }else if(key==PANGO_SPECIAL + PANGO_KEY_DOWN) {
+            if(edited) {
+                prefix = cmd;
+                edited = false;
+            }
+            Line* hist_line = GetLine(hist_id-1, ConsoleLineTypeCmd, prefix);
+            if(hist_line) {
+                current_line = *hist_line;
+                hist_id--;
+            }
+        }else if(key==PANGO_SPECIAL + PANGO_KEY_LEFT) {
+            if(carat > 0) carat--;
+        }else if(key==PANGO_SPECIAL + PANGO_KEY_RIGHT) {
+            if(carat < (int)txt.str.size()) carat++;
+        }else if(key==PANGO_SPECIAL + PANGO_KEY_HOME) {
+            carat = 0;
+        }else if(key==PANGO_SPECIAL + PANGO_KEY_END) {
+            carat = txt.Text().size();
+        }else if(key=='\b') {
+            if(carat > 0) {
+                std::string newstr = txt.Text();
+                newstr.erase(newstr.begin()+carat-1);
+                txt = font.Text("%s", newstr.c_str() );
+                carat--;
+                edited = true;
+            }
+        }else if(key==127) { // delete
+            if(carat < (int)txt.Text().size() ) {
+                std::string newstr = txt.Text();
+                newstr.erase(newstr.begin()+carat);
+                txt = font.Text("%s", newstr.c_str() );
+                edited = true;
+            }
+        }else if(key==PANGO_CTRL + 'c') {
+            txt = font.Text("");
+            carat = 0;
+            edited = true;
+        }else if(key < PANGO_SPECIAL){
+            std::string newstr = txt.Text();
+            newstr.insert(carat, 1, key);
+            txt = font.Text("%s", newstr.c_str());
+            ++carat;
+            edited = true;
+        }
+    }
+}
+
+void ConsoleView::AddLine(const std::string& text, InterpreterLineType linetype )
+{
+    line_buffer.push_front( Line( font.Text("%s",text.c_str()), linetype) );
+}
+
+ConsoleView::Line* ConsoleView::GetLine(int id, InterpreterLineType line_type, const std::string& prefix )
+{
+    int match = 0;
+    for(Line& l : line_buffer)
+    {
+        if(l.linetype == line_type) {
+            const std::string substr = l.text.Text().substr(0,prefix.size());
+            if(substr == prefix  ) {
+                if(id == match) {
+                    return &l;
+                }else{
+                    ++match;
+                }
+            }
+        }
+    }
+
+    return nullptr;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_display/src/default_font.cpp

@@ -0,0 +1,19 @@
+#include <pangolin/display/default_font.h>
+
+#include "pangolin_gl.h"
+
+extern const unsigned char AnonymousPro_ttf[];
+
+namespace pangolin {
+
+GlFont& default_font()
+{
+    PangolinGl* context = GetCurrentContext();
+    PANGO_ASSERT(context);
+    if(!context->font) {
+        context->font = std::make_shared<GlFont>(AnonymousPro_ttf, 18);
+    }
+    return *(context->font.get());
+}
+
+}

third-party/DPVO/Pangolin/components/pango_display/src/display.cpp

@@ -0,0 +1,347 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove, Richard Newcombe
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/platform.h>
+
+
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <map>
+#include <mutex>
+#include <cstdlib>
+#include <memory>
+
+#include <pangolin/gl/gl.h>
+#include <pangolin/gl/gldraw.h>
+#include <pangolin/factory/factory_registry.h>
+#include <pangolin/display/display.h>
+#include <pangolin/display/process.h>
+#include <pangolin/console/ConsoleView.h>
+#include <pangolin/utils/simple_math.h>
+#include <pangolin/utils/timer.h>
+#include <pangolin/utils/type_convert.h>
+#include <pangolin/image/image_io.h>
+#include <pangolin/var/var.h>
+
+#include "pangolin_gl.h"
+
+extern const unsigned char AnonymousPro_ttf[];
+
+namespace pangolin
+{
+
+typedef std::map<std::string,std::shared_ptr<PangolinGl> > ContextMap;
+
+// Map of active contexts
+ContextMap contexts;
+std::recursive_mutex contexts_mutex;
+
+// Context active for current thread
+__thread PangolinGl* context = 0;
+
+void SetCurrentContext(PangolinGl* newcontext) {
+    context = newcontext;
+}
+
+PangolinGl* GetCurrentContext()
+{
+    return context;
+}
+
+PangolinGl *FindContext(const std::string& name)
+{
+    contexts_mutex.lock();
+    ContextMap::iterator ic = contexts.find(name);
+    PangolinGl* context = (ic == contexts.end()) ? 0 : ic->second.get();
+    contexts_mutex.unlock();
+    return context;
+}
+
+WindowInterface& CreateWindowAndBind(std::string window_title, int w, int h, const Params& params)
+{
+    std::unique_lock<std::recursive_mutex> l(contexts_mutex);
+
+    pangolin::Uri win_uri;
+
+    if(const char* extra_params = std::getenv("PANGOLIN_WINDOW_URI"))
+    {
+        // Take any defaults from the environment
+        win_uri = pangolin::ParseUri(extra_params);
+    }else{
+        // Otherwise revert to 'default' scheme.
+        win_uri.scheme = "default";
+    }
+
+    // Override with anything the program specified
+    for(const auto& param : params.params) {
+        if(param.first != "scheme") win_uri.params.push_back(param);
+    }
+
+    // Special params that shouldn't get passed to window factory
+    win_uri.scheme = win_uri.Get("scheme", win_uri.scheme);
+    const std::string default_font = win_uri.Get<std::string>("default_font","");
+    const int default_font_size = win_uri.Get("default_font_size", 18);
+    win_uri.Remove("scheme");
+    win_uri.Remove("default_font");
+    win_uri.Remove("default_font_size");
+
+    // Additional arguments we will send to factory
+    win_uri.Set("w", w);
+    win_uri.Set("h", h);
+    win_uri.Set("window_title", window_title);
+
+    auto context = std::make_shared<PangolinGl>();
+    context->window = ConstructWindow(win_uri);
+    assert(context->window);
+
+    RegisterNewContext(window_title, context);
+
+    context->window->CloseSignal.connect( [](){
+        pangolin::Quit();
+    });
+    context->window->ResizeSignal.connect( [](WindowResizeEvent event){
+        process::Resize(event.width, event.height);
+    });
+    context->window->KeyboardSignal.connect( [](KeyboardEvent event) {
+        process::Keyboard(event.key, event.x, event.y, event.pressed, event.key_modifiers);
+    });
+    context->window->MouseSignal.connect( [](MouseEvent event){
+        process::Mouse(event.button, event.pressed, event.x, event.y, event.key_modifiers);
+    });
+    context->window->MouseMotionSignal.connect( [](MouseMotionEvent event){
+        process::MouseMotion(event.x, event.y, event.key_modifiers);
+    });
+    context->window->PassiveMouseMotionSignal.connect( [](MouseMotionEvent event){
+        process::PassiveMouseMotion(event.x, event.y, event.key_modifiers);
+    });
+    context->window->SpecialInputSignal.connect( [](SpecialInputEvent event){
+        process::SpecialInput(event.inType, event.x, event.y, event.p[0], event.p[1], event.p[2], event.p[3], event.key_modifiers);
+    });
+
+    // If there is a special font request
+    if( !default_font.empty() ) {
+        const std::string font_filename = PathExpand(default_font);
+        context->font = std::make_shared<GlFont>(font_filename, default_font_size);
+    }else{
+        context->font = std::make_shared<GlFont>(AnonymousPro_ttf, default_font_size);
+    }
+
+    context->MakeCurrent();
+    glewInit();
+
+    // And finally process pending window events (such as resize) now that we've setup our callbacks.
+    context->window->ProcessEvents();
+
+    return *context->window;
+}
+
+// Assumption: unique lock is held on contexts_mutex for multi-threaded operation
+void RegisterNewContext(const std::string& name, std::shared_ptr<PangolinGl> newcontext)
+{
+    // Set defaults
+    newcontext->base.left = 0.0;
+    newcontext->base.bottom = 0.0;
+    newcontext->base.top = 1.0;
+    newcontext->base.right = 1.0;
+    newcontext->base.aspect = 0;
+    newcontext->base.handler = &StaticHandler;
+
+    // Create and add
+    if( contexts.find(name) != contexts.end() ) {
+        throw std::runtime_error("Context already exists.");
+    }
+    contexts[name] = newcontext;
+
+    // Process the following as if this context is now current.
+    PangolinGl *oldContext = context;
+    context = newcontext.get();
+
+    // Default key bindings can be overridden
+    RegisterKeyPressCallback(PANGO_KEY_ESCAPE, Quit );
+    RegisterKeyPressCallback('\t', [](){ShowFullscreen(TrueFalseToggle::Toggle);} );
+    RegisterKeyPressCallback('`',  [](){ShowConsole(TrueFalseToggle::Toggle);} );
+
+    context = oldContext;
+}
+
+WindowInterface* GetBoundWindow()
+{
+    return context->window.get();
+}
+
+void DestroyWindow(const std::string& name)
+{
+    contexts_mutex.lock();
+    ContextMap::iterator ic = contexts.find(name);
+    PangolinGl *context_to_destroy = (ic == contexts.end()) ? 0 : ic->second.get();
+    if (context_to_destroy == context) {
+        context = nullptr;
+    }
+    size_t erased = contexts.erase(name);
+    if(erased == 0) {
+        pango_print_warn("Context '%s' doesn't exist for deletion.\n", name.c_str());
+    }
+    contexts_mutex.unlock();
+}
+
+void BindToContext(std::string name)
+{
+    std::unique_lock<std::recursive_mutex> l(contexts_mutex);
+
+    // N.B. context is modified prior to invoking MakeCurrent so that
+    // state management callbacks (such as Resize()) can be correctly
+    // processed.
+    PangolinGl *context_to_bind = FindContext(name);
+    if( !context_to_bind )
+    {
+        std::shared_ptr<PangolinGl> newcontext(new PangolinGl());
+        RegisterNewContext(name, newcontext);
+    }else{
+        context_to_bind->MakeCurrent();
+    }
+}
+
+void Quit()
+{
+    context->quit = true;
+}
+
+void QuitAll()
+{
+    for(auto& nc : contexts) {
+        nc.second->quit = true;
+    }
+}
+
+bool ShouldQuit()
+{
+    return !context || context->quit;
+}
+
+void ShowFullscreen(TrueFalseToggle on_off)
+{
+    if(context && context->window)
+        context->window->ShowFullscreen(on_off);
+}
+
+
+void FinishFrame()
+{
+    if(context) context->FinishFrame();
+}
+
+View& DisplayBase()
+{
+    return context->base;
+}
+
+View& CreateDisplay()
+{
+    int iguid = rand();
+    std::stringstream ssguid;
+    ssguid << iguid;
+    return Display(ssguid.str());
+}
+
+void ShowConsole(TrueFalseToggle on_off)
+{
+    if( !context->console_view) {
+        Uri interpreter_uri = ParseUri("python://");
+
+        try {
+            // Instantiate interpreter
+            std::shared_ptr<InterpreterInterface> interpreter
+                    = FactoryRegistry::I()->Construct<InterpreterInterface>(interpreter_uri);
+            assert(interpreter);
+
+            // Create console and let the pangolin context take ownership
+            context->console_view = std::make_unique<ConsoleView>(interpreter);
+            context->console_view->zorder = std::numeric_limits<int>::max();
+            DisplayBase().AddDisplay(*context->console_view);
+            context->console_view->SetFocus();
+        }  catch (std::exception&) {
+        }
+    }else{
+        context->console_view->Show(
+            to_bool(on_off, context->console_view->IsShown())
+        );
+
+        if(context->console_view->IsShown()) {
+            context->console_view->SetFocus();
+        }
+    }
+
+}
+
+View& Display(const std::string& name)
+{
+    // Get / Create View
+    ViewMap::iterator vi = context->named_managed_views.find(name);
+    if( vi != context->named_managed_views.end() )
+    {
+        return *(vi->second);
+    }else{
+        View * v = new View();
+        context->named_managed_views[name] = v;
+        v->handler = &StaticHandler;
+        context->base.views.push_back(v);
+        return *v;
+    }
+}
+
+void RegisterKeyPressCallback(int key, std::function<void(int)> func)
+{
+    context->keypress_hooks[key] = func;
+}
+
+void RegisterKeyPressCallback(int key, std::function<void(void)> func)
+{
+    context->keypress_hooks[key] = [=](int){func();};
+}
+
+void SaveWindowOnRender(const std::string& filename, const Viewport& v)
+{
+    context->screen_capture.push(std::pair<std::string,Viewport>(filename, v) );
+}
+
+void SaveWindowNow(const std::string& filename_hint, const Viewport& v)
+{
+    const Viewport to_save = v.area() ? v.Intersect(DisplayBase().v) : DisplayBase().v;
+    std::string filename = filename_hint;
+    if(FileLowercaseExtention(filename) == "")  filename += ".png";
+
+    try {
+        glFlush();
+        TypedImage buffer = ReadFramebuffer(to_save, "RGBA32");
+        SaveImage(buffer, filename, false);
+    }  catch (std::exception& e) {
+        std::cerr << e.what() << std::endl;
+    }
+}
+
+}

third-party/DPVO/Pangolin/components/pango_display/src/handler.cpp

@@ -0,0 +1,472 @@
+/* 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.
+ */
+
+#include <pangolin/display/view.h>
+#include <pangolin/handler/handler.h>
+#include <pangolin/display/display.h>
+
+#include "pangolin_gl.h"
+
+namespace pangolin
+{
+
+void Handler::Keyboard(View& d, unsigned char key, int x, int y, bool pressed)
+{
+    View* child = d.FindChild(x,y);
+    if( child)
+    {
+        GetCurrentContext()->activeDisplay = child;
+        if( child->handler)
+            child->handler->Keyboard(*child,key,x,y,pressed);
+    }
+}
+
+void Handler::Mouse(View& d, MouseButton button, int x, int y, bool pressed, int button_state)
+{
+    View* child = d.FindChild(x,y);
+    if( child )
+    {
+        GetCurrentContext()->activeDisplay = child;
+        if( child->handler)
+            child->handler->Mouse(*child,button,x,y,pressed,button_state);
+    }
+}
+
+void Handler::MouseMotion(View& d, int x, int y, int button_state)
+{
+    View* child = d.FindChild(x,y);
+    if( child )
+    {
+        GetCurrentContext()->activeDisplay = child;
+        if( child->handler)
+            child->handler->MouseMotion(*child,x,y,button_state);
+    }
+}
+
+void Handler::PassiveMouseMotion(View& d, int x, int y, int button_state)
+{
+    View* child = d.FindChild(x,y);
+    if( child )
+    {
+        if( child->handler)
+            child->handler->PassiveMouseMotion(*child,x,y,button_state);
+    }
+}
+
+void Handler::Special(View& d, InputSpecial inType, float x, float y, float p1, float p2, float p3, float p4, int button_state)
+{
+    View* child = d.FindChild( (int)x, (int)y);
+    if( child )
+    {
+        GetCurrentContext()->activeDisplay = child;
+        if( child->handler)
+            child->handler->Special(*child,inType, x,y, p1, p2, p3, p4, button_state);
+    }
+}
+
+void HandlerScroll::Mouse(View& d, MouseButton button, int x, int y, bool pressed, int button_state)
+{
+    if( pressed && (button == MouseWheelUp || button == MouseWheelDown) )
+    {
+        if( button == MouseWheelUp) d.scroll_offset   -= 1;
+        if( button == MouseWheelDown) d.scroll_offset += 1;
+        d.scroll_offset = std::max(0, std::min(d.scroll_offset, (int)d.NumVisibleChildren()-1) );
+        d.ResizeChildren();
+    }else{
+        Handler::Mouse(d,button,x,y,pressed,button_state);
+    }
+}
+
+void HandlerScroll::Special(View& d, InputSpecial inType, float x, float y, float p1, float p2, float p3, float p4, int button_state)
+{
+    if( inType == InputSpecialScroll )
+    {
+        d.scroll_offset -= (int)(p2 / fabs(p2));
+        d.scroll_offset = std::max(0, std::min(d.scroll_offset, (int)d.NumVisibleChildren()-1) );
+        d.ResizeChildren();
+    }else{
+        Handler::Special(d,inType,x,y,p1,p2,p3,p4,button_state);
+    }
+}
+
+HandlerBase3D::HandlerBase3D(OpenGlRenderState& cam_state, AxisDirection enforce_up, float trans_scale, float zoom_fraction)
+    : cam_state(&cam_state), enforce_up(enforce_up), tf(trans_scale), zf(zoom_fraction), cameraspec(CameraSpecOpenGl), last_z(0.8)
+{
+    SetZero<3,1>(rot_center);
+}
+
+void HandlerBase3D::Keyboard(View&, unsigned char /*key*/, int /*x*/, int /*y*/, bool /*pressed*/)
+{
+    // TODO: hooks for reset / changing mode (perspective / ortho etc)
+}
+
+bool HandlerBase3D::ValidWinDepth(GLprecision depth)
+{
+    return depth != 1;
+}
+
+void HandlerBase3D::PixelUnproject( View& view, GLprecision winx, GLprecision winy, GLprecision winz, GLprecision Pc[3])
+{
+    const GLint viewport[4] = {view.v.l,view.v.b,view.v.w,view.v.h};
+    const pangolin::OpenGlMatrix proj = cam_state->GetProjectionMatrix();
+    glUnProject(winx, winy, winz, IdentityMatrix().m, proj.m, viewport, &Pc[0], &Pc[1], &Pc[2]);
+}
+
+void HandlerBase3D::GetPosNormalImpl(pangolin::View& view, int winx, int winy, GLprecision p[3], GLprecision Pw[3], GLprecision Pc[3], GLprecision nw[3], GLprecision default_z, float* zs)
+{
+    const int zl = (hwin*2+1);
+    const int zsize = zl*zl;
+
+    GLfloat mindepth = *(std::min_element(zs,zs+zsize));
+    if(mindepth == 1) mindepth = (GLfloat)default_z;
+
+    p[0] = winx; p[1] = winy; p[2] = mindepth;
+    PixelUnproject(view, winx, winy, mindepth, Pc);
+
+    const pangolin::OpenGlMatrix mv = cam_state->GetModelViewMatrix();
+
+    GLprecision T_wc[3*4];
+    LieSE3from4x4(T_wc, mv.Inverse().m );
+    LieApplySE3vec(Pw, T_wc, Pc);
+
+    // Neighboring points in camera coordinates
+    GLprecision Pl[3]; GLprecision Pr[3]; GLprecision Pb[3]; GLprecision Pt[3];
+    PixelUnproject(view, winx-hwin, winy, zs[hwin*zl + 0],    Pl );
+    PixelUnproject(view, winx+hwin, winy, zs[hwin*zl + zl-1], Pr );
+    PixelUnproject(view, winx, winy-hwin, zs[hwin+1],         Pb );
+    PixelUnproject(view, winx, winy+hwin, zs[zsize-(hwin+1)], Pt );
+
+    // n = ((Pr-Pl).cross(Pt-Pb)).normalized();
+    GLprecision PrmPl[3]; GLprecision PtmPb[3];
+    MatSub<3,1>(PrmPl,Pr,Pl);
+    MatSub<3,1>(PtmPb,Pt,Pb);
+
+    GLprecision nc[3];
+    CrossProduct(nc, PrmPl, PtmPb);
+    Normalise<3>(nc);
+
+    // T_wc is col major, so the rotation component is first.
+    LieApplySO3(nw,T_wc,nc);
+}
+
+void HandlerBase3D::GetPosNormal(pangolin::View& view, int winx, int winy, GLprecision p[3], GLprecision Pw[3], GLprecision Pc[3], GLprecision nw[3], GLprecision default_z)
+{
+    const int zl = (hwin*2+1);
+    const int zsize = zl*zl;
+    GLfloat zs[zsize];
+
+    GLint readid = 0;
+    glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &readid);
+    // Choose attachment based on the bound framebuffer since GL_FRONT doesn't exist for FBOs
+    glReadBuffer(readid == 0 ? GL_FRONT : GL_COLOR_ATTACHMENT0);
+    glReadPixels(winx-hwin,winy-hwin,zl,zl,GL_DEPTH_COMPONENT,GL_FLOAT,zs);
+    GetPosNormalImpl(view, winx, winy, p, Pw, Pc, nw, default_z, zs);
+}
+
+void HandlerBase3D::Mouse(View& display, MouseButton button, int x, int y, bool pressed, int button_state)
+{
+    // mouse down
+    last_pos[0] = (float)x;
+    last_pos[1] = (float)y;
+    
+    GLprecision T_nc[3*4];
+    LieSetIdentity(T_nc);
+
+    funcKeyState = 0;
+    if( pressed )
+    {
+        GetPosNormal(display,x,y,p,Pw,Pc,n,last_z);
+        if( ValidWinDepth(p[2]) )
+        {
+            last_z = p[2];
+            std::copy(Pc,Pc+3,rot_center);
+        }
+        
+        if( button == MouseWheelUp || button == MouseWheelDown)
+        {
+            LieSetIdentity(T_nc);
+            const GLprecision t[3] = { 0,0,(button==MouseWheelUp?1:-1)*100*tf};
+            LieSetTranslation<>(T_nc,t);
+            if( !(button_state & MouseButtonRight) && !(rot_center[0]==0 && rot_center[1]==0 && rot_center[2]==0) )
+            {
+                LieSetTranslation<>(T_nc,rot_center);
+                const GLprecision s = (button==MouseWheelUp?-1.0:1.0) * zf;
+                MatMul<3,1>(T_nc+(3*3), s);
+            }
+            OpenGlMatrix& spec = cam_state->GetModelViewMatrix();
+            LieMul4x4bySE3<>(spec.m,T_nc,spec.m);
+        }
+
+        funcKeyState = button_state;
+    }
+}
+
+void HandlerBase3D::MouseMotion(View& display, int x, int y, int button_state)
+{
+    const GLprecision rf = 0.01;
+    const float delta[2] = { (float)x - last_pos[0], (float)y - last_pos[1] };
+    const float mag = delta[0]*delta[0] + delta[1]*delta[1];
+
+    if((button_state & KeyModifierCtrl) && (button_state & KeyModifierShift))
+    {
+        GLprecision T_nc[3 * 4];
+        LieSetIdentity(T_nc);
+
+        GetPosNormal(display, x, y, p, Pw, Pc, n, last_z);
+        if(ValidWinDepth(p[2]))
+        {
+            last_z = p[2];
+            std::copy(Pc, Pc + 3, rot_center);
+        }
+
+        funcKeyState = button_state;
+    }
+    else
+    {
+        funcKeyState = 0;
+    }
+
+    // TODO: convert delta to degrees based of fov
+    // TODO: make transformation with respect to cam spec
+    if( mag < 50.0f*50.0f )
+    {
+        OpenGlMatrix& mv = cam_state->GetModelViewMatrix();
+        const GLprecision* up = AxisDirectionVector[enforce_up];
+        GLprecision T_nc[3*4];
+        LieSetIdentity(T_nc);
+        bool rotation_changed = false;
+        
+        if( button_state == MouseButtonMiddle )
+        {
+            // Middle Drag: Rotate around view
+
+            // Try to correct for different coordinate conventions.
+            GLprecision aboutx = -rf * delta[1];
+            GLprecision abouty = rf * delta[0];
+            OpenGlMatrix& pm = cam_state->GetProjectionMatrix();
+            abouty *= -pm.m[2 * 4 + 3];
+
+            Rotation<>(T_nc, aboutx, abouty, (GLprecision)0.0);
+        }else if( button_state == MouseButtonLeft )
+        {
+            // Left Drag: in plane translate
+            if( ValidWinDepth(last_z) )
+            {
+                GLprecision np[3];
+                PixelUnproject(display, x, y, last_z, np);
+                const GLprecision t[] = { np[0] - rot_center[0], np[1] - rot_center[1], 0};
+                LieSetTranslation<>(T_nc,t);
+                std::copy(np,np+3,rot_center);
+            }else{
+                const GLprecision t[] = { -10*delta[0]*tf, 10*delta[1]*tf, 0};
+                LieSetTranslation<>(T_nc,t);
+            }
+        }else if( button_state == (MouseButtonLeft | MouseButtonRight) )
+        {
+            // Left and Right Drag: in plane rotate about object
+            //        Rotation<>(T_nc,0.0,0.0, delta[0]*0.01);
+            
+            GLprecision T_2c[3*4];
+            Rotation<>(T_2c, (GLprecision)0.0, (GLprecision)0.0, delta[0]*rf);
+            GLprecision mrotc[3];
+            MatMul<3,1>(mrotc, rot_center, (GLprecision)-1.0);
+            LieApplySO3<>(T_2c+(3*3),T_2c,mrotc);
+            GLprecision T_n2[3*4];
+            LieSetIdentity<>(T_n2);
+            LieSetTranslation<>(T_n2,rot_center);
+            LieMulSE3(T_nc, T_n2, T_2c );
+            rotation_changed = true;
+        }else if( button_state == MouseButtonRight)
+        {
+            GLprecision aboutx = -rf * delta[1];
+            GLprecision abouty = -rf * delta[0];
+
+            // Try to correct for different coordinate conventions.
+            if(cam_state->GetProjectionMatrix().m[2*4+3] <= 0) {
+                abouty *= -1;
+            }
+            
+            if(enforce_up) {
+                // Special case if view direction is parallel to up vector
+                const GLprecision updotz = mv.m[2]*up[0] + mv.m[6]*up[1] + mv.m[10]*up[2];
+                if(updotz > 0.98) aboutx = std::min(aboutx, (GLprecision)0.0);
+                if(updotz <-0.98) aboutx = std::max(aboutx, (GLprecision)0.0);
+                // Module rotation around y so we don't spin too fast!
+                abouty *= (1-0.6*fabs(updotz));
+            }
+            
+            // Right Drag: object centric rotation
+            GLprecision T_2c[3*4];
+            Rotation<>(T_2c, aboutx, abouty, (GLprecision)0.0);
+            GLprecision mrotc[3];
+            MatMul<3,1>(mrotc, rot_center, (GLprecision)-1.0);
+            LieApplySO3<>(T_2c+(3*3),T_2c,mrotc);
+            GLprecision T_n2[3*4];
+            LieSetIdentity<>(T_n2);
+            LieSetTranslation<>(T_n2,rot_center);
+            LieMulSE3(T_nc, T_n2, T_2c );
+            rotation_changed = true;
+        }
+        
+        LieMul4x4bySE3<>(mv.m,T_nc,mv.m);
+        
+        if(enforce_up != AxisNone && rotation_changed) {
+            EnforceUpT_cw(mv.m, up);
+        }
+    }
+    
+    last_pos[0] = (float)x;
+    last_pos[1] = (float)y;
+}
+
+void HandlerBase3D::Special(View& display, InputSpecial inType, float x, float y, float p1, float p2, float /*p3*/, float /*p4*/, int button_state)
+{
+    if( !(inType == InputSpecialScroll || inType == InputSpecialRotate) )
+        return;
+    
+    // mouse down
+    last_pos[0] = x;
+    last_pos[1] = y;
+    
+    GLprecision T_nc[3*4];
+    LieSetIdentity(T_nc);
+    
+    GetPosNormal(display, (int)x, (int)y, p, Pw, Pc, n, last_z);
+    if(p[2] < 1.0) {
+        last_z = p[2];
+        std::copy(Pc,Pc+3,rot_center);
+    }
+    
+    if( inType == InputSpecialScroll ) {
+        if(button_state & KeyModifierCmd) {
+            const GLprecision rx = -p2 / 1000;
+            const GLprecision ry = -p1 / 1000;
+            
+            Rotation<>(T_nc,rx, ry, (GLprecision)0.0);
+            OpenGlMatrix& spec = cam_state->GetModelViewMatrix();
+            LieMul4x4bySE3<>(spec.m,T_nc,spec.m);
+        }else{
+            const GLprecision scrolly = p2/10;
+            
+            LieSetIdentity(T_nc);
+            const GLprecision t[] = { 0,0, -scrolly*100*tf};
+            LieSetTranslation<>(T_nc,t);
+            if( !(button_state & MouseButtonRight) && !(rot_center[0]==0 && rot_center[1]==0 && rot_center[2]==0) )
+            {
+                LieSetTranslation<>(T_nc,rot_center);
+                MatMul<3,1>(T_nc+(3*3), -scrolly * zf);
+            }
+            OpenGlMatrix& spec = cam_state->GetModelViewMatrix();
+            LieMul4x4bySE3<>(spec.m,T_nc,spec.m);
+        }
+    }else if(inType == InputSpecialRotate) {
+        const GLprecision r = p1 / 20;
+        
+        GLprecision T_2c[3*4];
+        Rotation<>(T_2c, (GLprecision)0.0, (GLprecision)0.0, r);
+        GLprecision mrotc[3];
+        MatMul<3,1>(mrotc, rot_center, (GLprecision)-1.0);
+        LieApplySO3<>(T_2c+(3*3),T_2c,mrotc);
+        GLprecision T_n2[3*4];
+        LieSetIdentity<>(T_n2);
+        LieSetTranslation<>(T_n2,rot_center);
+        LieMulSE3(T_nc, T_n2, T_2c );
+        OpenGlMatrix& spec = cam_state->GetModelViewMatrix();
+        LieMul4x4bySE3<>(spec.m,T_nc,spec.m);
+    }
+    
+}
+
+#ifdef HAVE_GLES
+Handler3DBlitCopy::Handler3DBlitCopy(pangolin::OpenGlRenderState& cam_state, pangolin::AxisDirection enforce_up, float trans_scale)
+    : pangolin::HandlerBase3D(cam_state,enforce_up, trans_scale)
+{
+}
+
+void Handler3DBlitCopy::GetPosNormal(pangolin::View& view, int winx, int winy, GLprecision p[3], GLprecision Pw[3], GLprecision Pc[3], GLprecision n[3], GLprecision default_z)
+{
+    // Go around the houses so we can get depth data...
+    // With GLES3 / WebGL 2.0, we can't read from the depth buffer or download ROI's of GL textures
+    // The process below is the simplest I could make work that avoids a large GPU -> CPU download.
+
+    const int w = pangolin::DisplayBase().v.w;
+    const int h = pangolin::DisplayBase().v.h;
+
+    GLint num_bits;
+    glGetIntegerv(GL_DEPTH_BITS, &num_bits);
+
+    // Make sure our buffers are the right size for the current screen buffer
+    if(!depth_blit.IsValid() || depth_blit.width != w || depth_blit.height != h)
+    {
+        // Reinitialize all buffers
+        fb_blit.Reinitialise();
+        rgb_blit.Reinitialise(w,h,GL_RGB, true, 0, GL_RGB, GL_UNSIGNED_BYTE);
+        depth_blit.Reinitialise(w,h,GL_DEPTH24_STENCIL8, false, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
+        fb_blit.AttachColour(rgb_blit);
+        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb_blit.fbid);
+        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, depth_blit.tid, 0);
+        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+
+        fb.Reinitialise();
+        rgb.Reinitialise(w,h,GL_R32F, true, 0, GL_RED, GL_FLOAT);
+        depth.Reinitialise(w,h,GL_DEPTH24_STENCIL8, false, 0, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
+        fb.AttachColour(rgb);
+        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb.fbid);
+        glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, depth.tid, 0);
+        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+    }
+
+    // Copy screens depth buffer to our blit framebuffer
+    glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fb_blit.fbid);
+    glBlitFramebuffer(0,0,w,h, 0,0,w,h, GL_DEPTH_BUFFER_BIT, GL_NEAREST);
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+    // Render the depth buffer to our regular buffer (so depth ends up in color buffer)
+    fb.Bind();
+    glViewport(0,0,w,h);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glColor4f(1.0,1.0,1.0,1.0);
+    depth_blit.RenderToViewport();
+    depth_blit.Unbind();
+
+    const int zl = (hwin*2+1);
+    const int zsize = zl*zl;
+    GLfloat zs[4*zsize];
+    GLfloat zsr[zsize];
+
+    // GLES3 only supports ReadPixels with GL_RGBA
+    glReadBuffer(GL_COLOR_ATTACHMENT0);
+    glReadPixels(winx-hwin,winy-hwin,zl,zl,GL_RGBA,GL_FLOAT,zs);
+    for(size_t i=0; i < zsize; ++i) zsr[i] = zs[4*i];
+    fb.Unbind();
+
+    HandlerBase3D::GetPosNormalImpl(view,winx,winy,p,Pw,Pc,n,default_z,zsr);
+}
+#endif
+
+}

third-party/DPVO/Pangolin/components/pango_display/src/handler_glbuffer.cpp

@@ -0,0 +1,45 @@
+/* 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.
+ */
+
+#include <pangolin/handler/handler_glbuffer.h>
+#include <pangolin/display/view.h>
+
+namespace pangolin {
+
+Handler3DFramebuffer::Handler3DFramebuffer(GlFramebuffer& fb, pangolin::OpenGlRenderState& cam_state, pangolin::AxisDirection enforce_up, float trans_scale)
+    : pangolin::HandlerBase3D(cam_state,enforce_up, trans_scale), fb(fb)
+{
+}
+
+void Handler3DFramebuffer::GetPosNormal(pangolin::View& view, int x, int y, GLprecision p[3], GLprecision Pw[3], GLprecision Pc[3], GLprecision n[3], GLprecision default_z)
+{
+    fb.Bind();
+    HandlerBase3D::GetPosNormal(view,x,y,p,Pw,Pc,n,default_z);
+    fb.Unbind();
+}
+
+}

third-party/DPVO/Pangolin/components/pango_display/src/handler_image.cpp

@@ -0,0 +1,526 @@
+#include <pangolin/handler/handler_image.h>
+#include <pangolin/display/default_font.h>
+
+namespace pangolin
+{
+
+ImageViewHandler::ImageViewHandler(const std::string & title)
+    : linked_view_handler(0), use_nn(false), flipTextureX(false), flipTextureY(false), title(title)
+{
+    SetDimensions(1, 1);
+}
+
+ImageViewHandler::ImageViewHandler(size_t w, size_t h)
+    : linked_view_handler(0),
+      use_nn(false), flipTextureX(false), flipTextureY(false)
+{
+    SetDimensions(w,h);
+}
+
+void ImageViewHandler::SetDimensions(size_t w, size_t h)
+{
+    rview_default = pangolin::XYRangef(-0.5f, w-0.5f, -0.5f, h-0.5f),
+    rview_max = pangolin::XYRangef(-0.5f, w-0.5f, -0.5f, h-0.5f),
+    rview = rview_default;
+    target = rview;
+}
+
+void ImageViewHandler::UpdateView()
+{
+    // TODO: Base this on current framerate.
+    const float animate_factor = 1.0f / 5.0f;
+
+    if( linked_view_handler ) {
+        // Synchronise rview and target with linked plotter
+        rview = linked_view_handler->rview;
+        target = linked_view_handler->target;
+        selection = linked_view_handler->selection;
+    }else{
+        // Clamp target to image dimensions.
+        AdjustScale();
+        AdjustTranslation();
+
+        // Animate view window toward target
+        pangolin::XYRangef d = target - rview;
+        rview += d * animate_factor;
+    }
+}
+
+void ImageViewHandler::glSetViewOrtho()
+{
+    const pangolin::XYRangef& xy = GetViewToRender();
+
+    glMatrixMode(GL_PROJECTION);
+    ProjectionMatrixOrthographic(xy.x.min, xy.x.max, xy.y.max, xy.y.min, -1.0f, 1.0f).Load();
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+}
+
+void ImageViewHandler::glRenderTexture(pangolin::GlTexture& tex)
+{
+    glRenderTexture(tex.tid, tex.width, tex.height);
+}
+
+void ImageViewHandler::glRenderTexture(GLuint tex, GLint width, GLint height)
+{
+    if(tex != 0) {
+        const pangolin::XYRangef& xy = GetViewToRender();
+        const float w = (float)width;
+        const float h = (float)height;
+
+        // discrete coords, (-0.5, -0.5) - (w-0.5, h-0.5)
+        const GLfloat l = xy.x.min;
+        const GLfloat r = xy.x.max;
+        const GLfloat b = xy.y.max;
+        const GLfloat t = xy.y.min;
+
+        // continuous coords, (0,0) - (1,1)
+        GLfloat ln = (l + 0.5f) / w;
+        GLfloat rn = (r + 0.5f) / w;
+        GLfloat bn = (b + 0.5f) / h;
+        GLfloat tn = (t + 0.5f) / h;
+
+        if(flipTextureX) {
+            ln = 1-ln;
+            rn = 1-rn;
+        }
+
+        if(flipTextureY) {
+            bn = 1-bn;
+            tn = 1-tn;
+        }
+
+        const GLfloat sq_vert[]  = { l,t,  r,t,  r,b,  l,b };
+        const GLfloat sq_tex[]  = { ln,tn,  rn,tn,  rn,bn,  ln,bn };
+
+        glBindTexture(GL_TEXTURE_2D, tex);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, UseNN() ? GL_NEAREST : GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, UseNN() ? GL_NEAREST : GL_LINEAR);
+
+        glEnable(GL_TEXTURE_2D);
+        glEnableClientState(GL_VERTEX_ARRAY);
+        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+        glTexCoordPointer(2, GL_FLOAT, 0, sq_tex);
+        glVertexPointer(2, GL_FLOAT, 0, sq_vert);
+        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+        glDisableClientState(GL_VERTEX_ARRAY);
+        glDisable(GL_TEXTURE_2D);
+        glBindTexture(GL_TEXTURE_2D, 0);
+    }
+}
+
+void ImageViewHandler::glRenderTexture(GLuint tex, GLint width, GLint height, XYRangef tex_region)
+{
+    if(tex != 0) {
+        const pangolin::XYRangef& xy = tex_region;
+        const float w = (float)width;
+        const float h = (float)height;
+
+        // discrete coords, (-0.5, -0.5) - (w-0.5, h-0.5)
+        const GLfloat l = xy.x.min;
+        const GLfloat r = xy.x.max;
+        const GLfloat b = xy.y.max;
+        const GLfloat t = xy.y.min;
+
+        // continuous coords, (0,0) - (1,1)
+        GLfloat ln = 0.0;
+        GLfloat rn = 1.0;
+        GLfloat bn = 0.0;
+        GLfloat tn = 1.0;
+
+        if(flipTextureX) {
+            ln = 1-ln;
+            rn = 1-rn;
+        }
+
+        if(flipTextureY) {
+            bn = 1-bn;
+            tn = 1-tn;
+        }
+
+        const GLfloat sq_vert[]  = { l,t,  r,t,  r,b,  l,b };
+        const GLfloat sq_tex[]  = { ln,tn,  rn,tn,  rn,bn,  ln,bn };
+
+        glBindTexture(GL_TEXTURE_2D, tex);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, UseNN() ? GL_NEAREST : GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, UseNN() ? GL_NEAREST : GL_LINEAR);
+
+        glEnable(GL_TEXTURE_2D);
+        glEnableClientState(GL_VERTEX_ARRAY);
+        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+        glTexCoordPointer(2, GL_FLOAT, 0, sq_tex);
+        glVertexPointer(2, GL_FLOAT, 0, sq_vert);
+        glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+        glDisableClientState(GL_VERTEX_ARRAY);
+        glDisable(GL_TEXTURE_2D);
+        glBindTexture(GL_TEXTURE_2D, 0);
+    }
+}
+
+void ImageViewHandler::glRenderOverlay()
+{
+    const pangolin::XYRangef& selxy = GetSelection();
+    const GLfloat sq_select[] = {
+        selxy.x.min, selxy.y.min,
+        selxy.x.max, selxy.y.min,
+        selxy.x.max, selxy.y.max,
+        selxy.x.min, selxy.y.max
+    };
+    glColor4f(1.0,0.0,0.0,1.0);
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glVertexPointer(2, GL_FLOAT, 0, sq_select);
+    glDrawArrays(GL_LINE_LOOP, 0, 4);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    glColor4f(1.0,1.0,1.0,1.0);
+
+    const bool have_text = std::abs(selxy.Area()) > 0 || !title.empty();
+
+    GLboolean gl_blend_enabled;
+    pangolin::Viewport v;
+
+    if( have_text ) {
+
+        glGetIntegerv( GL_VIEWPORT, &v.l );
+
+        // Save previous value
+        glGetBooleanv(GL_BLEND, &gl_blend_enabled);
+
+        // Ensure that blending is enabled for rendering text.
+        glEnable(GL_BLEND);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    }
+
+    if( std::abs(selxy.Area()) > 0) {
+        // Render text
+        float xpix, ypix;
+        ImageToScreen(v, selxy.x.max, selxy.y.max, xpix, ypix);
+
+        auto& font = pangolin::default_font();
+
+        font.Text(
+            "%.2f x %.2f",
+            selxy.x.Size(), selxy.y.Size()
+        ).DrawWindow(xpix,ypix);
+
+        font.Text(
+            "(%.1f,%.1f)->(%.1f,%.1f)",
+            selxy.x.min, selxy.y.min,
+            selxy.x.max, selxy.y.max
+        ).DrawWindow(xpix, ypix - 1.0f * font.Height());
+    }
+
+    if (!title.empty()) {
+        auto& font = pangolin::default_font();
+        font.Text(title).DrawWindow(v.l + 8, v.t() - 4 - font.Height());
+    }
+
+    if (have_text) {
+        // Restore previous value
+        if(!gl_blend_enabled) glDisable(GL_BLEND);
+    }
+}
+
+void ImageViewHandler::ScreenToImage(Viewport& v, float xpix, float ypix, float& ximg, float& yimg)
+{
+    ximg = rview.x.min + rview.x.Size() * (xpix - v.l) / (float)v.w;
+    yimg = rview.y.min + rview.y.Size() * ( 1.0f - (ypix - v.b) / (float)v.h);
+}
+
+void ImageViewHandler::ImageToScreen(Viewport& v, float ximg, float yimg, float& xpix, float& ypix)
+{
+    xpix = (ximg -rview.x.min) * (float)v.w / rview.x.Size() + v.l;
+    ypix = v.b - (float)v.h * ((yimg - rview.y.min) / rview.y.Size() - 1.0f);
+}
+
+bool ImageViewHandler::UseNN() const
+{
+    return use_nn;
+}
+
+bool& ImageViewHandler::UseNN()
+{
+    return use_nn;
+}
+
+bool& ImageViewHandler::FlipTextureX()
+{
+    return flipTextureX;
+}
+
+bool& ImageViewHandler::FlipTextureY()
+{
+    return flipTextureY;
+}
+
+pangolin::XYRangef& ImageViewHandler::GetViewToRender()
+{
+    return rview;
+}
+
+float ImageViewHandler::GetViewScale()
+{
+    return rview_max.x.Size() / rview.x.Size();
+}
+
+pangolin::XYRangef& ImageViewHandler::GetView()
+{
+    return target;
+}
+
+pangolin::XYRangef& ImageViewHandler::GetDefaultView()
+{
+    return rview_default;
+}
+
+pangolin::XYRangef& ImageViewHandler::GetSelection()
+{
+    return selection;
+}
+
+void ImageViewHandler::GetHover(float& x, float& y)
+{
+    ImageViewHandler& tv = linked_view_handler ? *linked_view_handler : *this;
+    x = tv.hover_img[0];
+    y = tv.hover_img[1];
+}
+
+void ImageViewHandler::SetView(const pangolin::XYRangef& range)
+{
+    ImageViewHandler& tv = linked_view_handler ? *linked_view_handler : *this;
+    tv.rview = range;
+    tv.target = range;
+}
+
+void ImageViewHandler::SetViewSmooth(const pangolin::XYRangef& range)
+{
+    ImageViewHandler& tv = linked_view_handler ? *linked_view_handler : *this;
+    tv.target = range;
+}
+
+void ImageViewHandler::ScrollView(float x, float y)
+{
+    ImageViewHandler& tv = linked_view_handler ? *linked_view_handler : *this;
+    ScrollViewSmooth(x,y);
+    tv.rview.x += x;
+    tv.rview.y += y;
+}
+
+void ImageViewHandler::ScrollViewSmooth(float x, float y)
+{
+    ImageViewHandler& tv = linked_view_handler ? *linked_view_handler : *this;
+    tv.target.x += x;
+    tv.target.y += y;
+}
+
+void ImageViewHandler::ScaleView(float x, float y, float cx, float cy)
+{
+    ImageViewHandler& tv = linked_view_handler ? *linked_view_handler : *this;
+    ScaleViewSmooth(x,y,cx,cy);
+    tv.rview.x.Scale(x,cx);
+    tv.rview.y.Scale(y,cy);
+}
+
+void ImageViewHandler::ScaleViewSmooth(float x, float y, float cx, float cy)
+{
+    ImageViewHandler& tv = linked_view_handler ? *linked_view_handler : *this;
+    tv.target.x.Scale(x,cx);
+    tv.target.y.Scale(y,cy);
+}
+
+void ImageViewHandler::ResetView()
+{
+    ImageViewHandler& tv = linked_view_handler ? *linked_view_handler : *this;
+    tv.target = tv.rview_default;
+}
+
+///////////////////////////////////////////////////////
+/// pangolin::Handler
+///////////////////////////////////////////////////////
+
+void ImageViewHandler::Keyboard(View&, unsigned char key, int /*x*/, int /*y*/, bool pressed)
+{
+    XYRangef& sel = linked_view_handler ? linked_view_handler->selection : selection;
+    const float mvfactor = 1.0f / 10.0f;
+    const float c[2] = { rview.x.Mid(), rview.y.Mid() };
+
+
+    if(pressed) {
+        if(key == '\r') {
+            if( sel.Area() != 0.0f && std::isfinite(sel.Area()) ) {
+                // Set view to equal selection
+                SetViewSmooth(sel);
+
+                // Reset selection
+                sel.x.max = sel.x.min;
+                sel.y.max = sel.y.min;
+            }
+        }else if(key == 'n') {
+            use_nn = !use_nn;
+        }else if(key == 'l') {
+            if(to_link) {
+                linked_view_handler = to_link;
+                to_link = 0;
+            }else{
+                to_link = this;
+            }
+        }else if(key == PANGO_SPECIAL + PANGO_KEY_LEFT) {
+            const float w = target.x.Size();
+            const float dx = mvfactor*w;
+            ScrollViewSmooth(-dx, 0);
+        }else if(key == PANGO_SPECIAL + PANGO_KEY_RIGHT) {
+            const float w = target.x.Size();
+            const float dx = mvfactor*w;
+            ScrollViewSmooth(+dx, 0);
+        }else if(key == PANGO_SPECIAL + PANGO_KEY_DOWN) {
+            const float h = target.y.Size();
+            const float dy = mvfactor*h;
+            ScrollViewSmooth(0, -dy);
+        }else if(key == PANGO_SPECIAL + PANGO_KEY_UP) {
+            const float h = target.y.Size();
+            const float dy = mvfactor*h;
+            ScrollViewSmooth(0, +dy);
+        }else if(key == '=') {
+            ScaleViewSmooth(0.5, 0.5, c[0], c[1]);
+        }else if(key == '-') {
+            ScaleViewSmooth(2.0, 2.0, c[0], c[1]);
+        }else if(key == '#') {
+            ResetView();
+        }else if(key == 1) {
+            // ctrl-a: select all.
+            sel = rview;
+        }else{
+            pango_print_debug("Unhandled ImageViewHandler::Keyboard. Key: %u\n", (unsigned int)key);
+        }
+    }
+}
+
+void ImageViewHandler::Mouse(View& view, pangolin::MouseButton button, int x, int y, bool pressed, int button_state)
+{
+    XYRangef& sel = linked_view_handler ? linked_view_handler->selection : selection;
+    ScreenToImage(view.v, (float)x, (float)y, hover_img[0], hover_img[1]);
+
+    const float scinc = 1.05f;
+    const float scdec = 1.0f/scinc;
+
+    if(button_state & KeyModifierCtrl) {
+        const float mvfactor = 1.0f/20.0f;
+
+        if(button == MouseWheelUp) {
+            ScrollViewSmooth(0.0f, +mvfactor*rview.y.Size() );
+        }else if(button == MouseWheelDown) {
+            ScrollViewSmooth(0.0f, -mvfactor*rview.y.Size() );
+        }else if(button == MouseWheelLeft) {
+            ScrollViewSmooth(+mvfactor*rview.x.Size(), 0.0f );
+        }else if(button == MouseWheelRight) {
+            ScrollViewSmooth(-mvfactor*rview.x.Size(), 0.0f );
+        }
+    }else{
+        if(button == MouseButtonLeft) {
+            // Update selected range
+            if(pressed) {
+                sel.x.min = hover_img[0];
+                sel.y.min = hover_img[1];
+            }
+            sel.x.max = hover_img[0];
+            sel.y.max = hover_img[1];
+        }else if(button == MouseWheelUp) {
+            ScaleViewSmooth(scdec, scdec, hover_img[0], hover_img[1]);
+        }else if(button == MouseWheelDown) {
+            ScaleViewSmooth(scinc, scinc, hover_img[0], hover_img[1]);
+        }
+    }
+
+    FixSelection(sel);
+    last_mouse_pos[0] = x;
+    last_mouse_pos[1] = y;
+
+    if(OnSelectionCallback) {
+        OnSelectionCallback( OnSelectionEventData(view,*this,pressed) );
+    }
+}
+
+void ImageViewHandler::MouseMotion(View& view, int x, int y, int button_state)
+{
+    XYRangef& sel = linked_view_handler ? linked_view_handler->selection : selection;
+    const int d[2] = {x-last_mouse_pos[0], y-last_mouse_pos[1]};
+
+    // Update hover status (after potential resizing)
+    ScreenToImage(view.v, (float)x, (float)y, hover_img[0], hover_img[1]);
+
+    if( button_state == MouseButtonLeft )
+    {
+        // Update selected range
+        sel.x.max = hover_img[0];
+        sel.y.max = hover_img[1];
+    }else if(button_state == MouseButtonRight )
+    {
+        Special(view, InputSpecialScroll, (float)x, (float)y, (float)d[0], (float)d[1], 0.0f, 0.0f, button_state);
+    }
+
+    last_mouse_pos[0] = x;
+    last_mouse_pos[1] = y;
+
+    if( button_state == MouseButtonLeft && OnSelectionCallback) {
+        OnSelectionCallback( OnSelectionEventData(view,*this,true) );
+    }
+}
+
+void ImageViewHandler::PassiveMouseMotion(View&, int /*x*/, int /*y*/, int /*button_state*/)
+{
+}
+
+void ImageViewHandler::Special(View& view, pangolin::InputSpecial inType, float x, float y, float p1, float p2, float /*p3*/, float /*p4*/, int /*button_state*/)
+{
+    ScreenToImage(view.v, x, y, hover_img[0], hover_img[1]);
+
+    if(inType == InputSpecialScroll) {
+        const float d[2] = {p1,p2};
+        const float is[2] = {rview.x.Size(),rview.y.Size() };
+        const float df[2] = {is[0]*d[0]/(float)view.v.w, is[1]*d[1]/(float)view.v.h};
+        ScrollView(-df[0], -df[1]);
+    } else if(inType == InputSpecialZoom) {
+        float scale = 1.0f - p1;
+        ScaleView(scale, scale, hover_img[0], hover_img[1]);
+    }
+
+    // Update hover status (after potential resizing)
+    ScreenToImage( view.v, x, y, hover_img[0], hover_img[1]);
+}
+
+void ImageViewHandler::FixSelection(XYRangef& sel)
+{
+    // Make sure selection matches sign of current viewport
+    if( (sel.x.min<sel.x.max) != (rview.x.min<rview.x.max) ) {
+        std::swap(sel.x.min, sel.x.max);
+    }
+    if( (sel.y.min<sel.y.max) != (rview.y.min<rview.y.max) ) {
+        std::swap(sel.y.min, sel.y.max);
+    }
+}
+
+void ImageViewHandler::AdjustScale()
+{
+    ImageViewHandler& tv = linked_view_handler ? *linked_view_handler : *this;
+    if(tv.target.x.AbsSize() > tv.rview_max.x.AbsSize())
+        tv.target.x.Scale(tv.rview_max.x.AbsSize() / tv.target.x.AbsSize(), tv.target.x.Mid());
+    if(tv.target.y.AbsSize() > tv.rview_max.y.AbsSize())
+        tv.target.y.Scale(tv.rview_max.y.AbsSize() / tv.target.y.AbsSize(), tv.target.y.Mid());
+}
+
+void ImageViewHandler::AdjustTranslation()
+{
+    ImageViewHandler& tv = linked_view_handler ? *linked_view_handler : *this;
+    if( tv.target.x.max > tv.rview_max.x.max) tv.target.x -= tv.target.x.max - tv.rview_max.x.max;
+    if( tv.target.x.min < tv.rview_max.x.min) tv.target.x -= tv.target.x.min - tv.rview_max.x.min;
+
+    if( tv.target.y.max > tv.rview_max.y.max) tv.target.y -= tv.target.y.max - tv.rview_max.y.max;
+    if( tv.target.y.min < tv.rview_max.y.min) tv.target.y -= tv.target.y.min - tv.rview_max.y.min;
+}
+
+float ImageViewHandler::animate_factor = 1.0f / 2.0f;
+ImageViewHandler* ImageViewHandler::to_link = 0;
+
+}

third-party/DPVO/Pangolin/components/pango_display/src/image_view.cpp

@@ -0,0 +1,227 @@
+#include <pangolin/display/image_view.h>
+#include <pangolin/image/image_utils.h>
+#include <pangolin/image/image_convert.h>
+
+namespace pangolin
+{
+
+ImageView::ImageView(const std::string & title)
+    : pangolin::ImageViewHandler(title), offset_scale(0.0f, 1.0f), lastPressed(false), mouseReleased(false), mousePressed(false), overlayRender(true)
+{
+    SetHandler(this);
+}
+
+ImageView::~ImageView()
+{
+}
+
+void ImageView::Render()
+{
+    LoadPending();
+
+#ifndef HAVE_GLES
+    glPushAttrib(GL_DEPTH_BITS);
+#endif
+    glDisable(GL_DEPTH_TEST);
+
+    Activate();
+    this->UpdateView();
+    this->glSetViewOrtho();
+
+    if(tex.IsValid())
+    {
+        if(offset_scale.first != 0.0 || offset_scale.second != 1.0)
+        {
+            pangolin::GlSlUtilities::OffsetAndScale(offset_scale.first, offset_scale.second);
+        }
+        else
+        {
+            glColor4f(1, 1, 1, 1);
+        }
+
+        this->glRenderTexture(tex);
+        pangolin::GlSlUtilities::UseNone();
+    }
+
+    if(overlayRender)
+    {
+        this->glRenderOverlay();
+    }
+
+    if(extern_draw_function)
+    {
+        extern_draw_function(*this);
+    }
+
+#ifndef HAVE_GLES
+    glPopAttrib();
+#endif
+}
+
+void ImageView::Mouse(View& view, pangolin::MouseButton button, int x, int y, bool pressed, int button_state)
+{
+    ImageViewHandler::Mouse(view, button, x, y, pressed, button_state);
+
+    mouseReleased = (!pressed && lastPressed);
+
+    mousePressed = lastPressed = (pressed && button == pangolin::MouseButtonLeft);
+}
+
+void ImageView::Keyboard(View& view, unsigned char key, int x, int y, bool pressed)
+{
+    if(key == 'a')
+    {
+        if(!tex.IsValid())
+        {
+            std::cerr << "ImageViewHandler does not contain valid texture." << std::endl;
+            return;
+        }
+
+        // compute scale
+        const bool have_selection = std::isfinite(GetSelection().Area()) && std::abs(GetSelection().Area()) >= 4;
+        const pangolin::XYRangef froi = have_selection ? GetSelection() : GetViewToRender();
+
+        // Download texture so that we can take min / max
+        pangolin::TypedImage img;
+        tex.Download(img);
+        offset_scale = pangolin::GetOffsetScale(img, pangolin::Round(froi), img.fmt);
+    }
+    else if(key == 'b')
+    {
+        if(!tex.IsValid())
+        {
+            std::cerr << "ImageViewHandler does not contain valid texture." << std::endl;
+            return;
+        }
+
+        // compute scale
+        const bool have_selection = std::isfinite(GetSelection().Area()) && std::abs(GetSelection().Area()) >= 4;
+        const pangolin::XYRangef froi = have_selection ? GetSelection() : GetViewToRender();
+
+        // Download texture so that we can take min / max
+        pangolin::TypedImage img;
+        tex.Download(img);
+        std::pair<float, float> mm = pangolin::GetMinMax(img, pangolin::Round(froi), img.fmt);
+
+        printf("Min / Max in Region: %f / %f\n", mm.first, mm.second);
+    }
+    else
+    {
+        pangolin::ImageViewHandler::Keyboard(view, key, x, y, pressed);
+    }
+}
+
+pangolin::GlTexture& ImageView::Tex() {
+    return tex;
+}
+
+ImageView& ImageView::SetImage(void* ptr, size_t w, size_t h, size_t pitch, pangolin::GlPixFormat img_fmt, bool delayed_upload )
+{
+    const size_t pix_bytes =
+            pangolin::GlFormatChannels(img_fmt.glformat) * pangolin::GlDataTypeBytes(img_fmt.gltype);
+
+    const bool convert_first = (img_fmt.gltype == GL_DOUBLE);
+
+    if(delayed_upload || !pangolin::GetBoundWindow() || IsDevicePtr(ptr) || convert_first )
+    {
+        texlock.lock();
+        if(!convert_first) {
+            img_to_load = ManagedImage<unsigned char>(w,h,w*pix_bytes);
+            PitchedCopy((char*)img_to_load.ptr, img_to_load.pitch, (char*)ptr, pitch, w * pix_bytes, h);
+            img_fmt_to_load = img_fmt;
+        }else if(img_fmt.gltype == GL_DOUBLE) {
+            Image<double> double_image( (double*)ptr, w, h, pitch);
+            img_to_load.OwnAndReinterpret(ImageConvert<float>(double_image));
+            img_fmt_to_load = GlPixFormat::FromType<float>();
+        }else{
+            pango_print_warn("TextureView: Unable to display image.\n");
+        }
+        texlock.unlock();
+        return *this;
+    }
+
+    PANGO_ASSERT(pitch % pix_bytes == 0);
+    const size_t stride = pitch / pix_bytes;
+    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, stride);
+
+    // Initialise if it didn't already exist or the size was too small
+    if(!tex.tid || tex.width != (int)w || tex.height != (int)h ||
+       tex.internal_format != img_fmt.scalable_internal_format)
+    {
+        fmt = img_fmt;
+        SetDimensions(w, h);
+        SetAspect((float)w / (float)h);
+        tex.Reinitialise(w, h, img_fmt.scalable_internal_format, true, 0, img_fmt.glformat, img_fmt.gltype, ptr);
+    }
+    else
+    {
+        tex.Upload(ptr, img_fmt.glformat, img_fmt.gltype);
+    }
+
+    glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+    return *this;
+}
+
+ImageView& ImageView::SetImage(const pangolin::Image<unsigned char>& img, const pangolin::GlPixFormat& glfmt, bool delayed_upload )
+{
+    return SetImage(img.ptr, img.w, img.h, img.pitch, glfmt, delayed_upload);
+}
+
+ImageView& ImageView::SetImage(const pangolin::TypedImage& img, bool delayed_upload )
+{
+    return SetImage(img.ptr, img.w, img.h, img.pitch, pangolin::GlPixFormat(img.fmt), delayed_upload);
+}
+
+ImageView& ImageView::SetImage(const pangolin::GlTexture& texture)
+{
+    // Initialise if it didn't already exist or the size was too small
+    if(!tex.tid || tex.width != texture.width || tex.height != texture.height ||
+       tex.internal_format != texture.internal_format)
+    {
+        SetDimensions(texture.width, texture.height);
+        SetAspect((float)texture.width / (float)texture.height);
+        tex.Reinitialise(texture.width, texture.height, texture.internal_format, true);
+    }
+
+    glCopyImageSubData(
+            texture.tid, GL_TEXTURE_2D, 0, 0, 0, 0, tex.tid, GL_TEXTURE_2D, 0, 0, 0, 0, tex.width, tex.height, 1);
+
+    return *this;
+}
+
+void ImageView::LoadPending()
+{
+    if(img_to_load.ptr)
+    {
+        // Scoped lock
+        texlock.lock();
+        SetImage(img_to_load, img_fmt_to_load, false);
+        img_to_load.Deallocate();
+        texlock.unlock();
+    }
+}
+
+ImageView& ImageView::Clear()
+{
+    tex.Delete();
+    return *this;
+}
+
+std::pair<float, float>& ImageView::GetOffsetScale() {
+    return offset_scale;
+}
+
+bool ImageView::MouseReleased() const {
+    return mouseReleased;
+}
+
+bool ImageView::MousePressed() const {
+    return mousePressed;
+}
+
+void ImageView::SetRenderOverlay(const bool& val) {
+    overlayRender = val;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_display/src/pangolin_gl.cpp

@@ -0,0 +1,94 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove, Richard Newcombe
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "pangolin_gl.h"
+#include <pangolin/display/display.h>
+#include <pangolin/console/ConsoleView.h>
+
+namespace pangolin
+{
+
+PangolinGl::PangolinGl()
+    : user_app(0), quit(false), mouse_state(0),activeDisplay(0)
+{
+}
+
+PangolinGl::~PangolinGl()
+{
+    // Free displays owned by named_managed_views
+    for(ViewMap::iterator iv = named_managed_views.begin(); iv != named_managed_views.end(); ++iv) {
+        delete iv->second;
+    }
+    named_managed_views.clear();
+}
+
+void PangolinGl::MakeCurrent()
+{
+    SetCurrentContext(this);
+    if(window) {
+        window->MakeCurrent();
+    }
+}
+
+void PangolinGl::RenderViews()
+{
+    Viewport::DisableScissor();
+    base.Render();
+}
+
+void PangolinGl::FinishFrame()
+{
+    RenderViews();
+
+    while(screen_capture.size()) {
+        std::pair<std::string,Viewport> fv = screen_capture.front();
+        screen_capture.pop();
+        SaveWindowNow(fv.first, fv.second);
+    }
+
+    if(window) {
+        window->SwapBuffers();
+        window->ProcessEvents();
+    }
+
+    Viewport::DisableScissor();
+}
+
+void PangolinGl::SetOnRender(std::function<void ()> on_render) {
+    this->on_render = on_render;
+}
+
+void PangolinGl::Run() {
+    while (!quit) {
+        if (on_render) {
+            on_render();
+        }
+        FinishFrame();
+    }
+}
+
+}

third-party/DPVO/Pangolin/components/pango_display/src/pangolin_gl.h

@@ -0,0 +1,102 @@
+/* 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/windowing/window.h>
+
+#include <pangolin/display/view.h>
+#include <pangolin/display/user_app.h>
+#include <functional>
+#include <memory>
+
+#include <map>
+#include <queue>
+
+namespace pangolin
+{
+
+// Forward Declarations
+class ConsoleView;
+class GlFont;
+
+typedef std::map<const std::string,View*> ViewMap;
+typedef std::map<int,std::function<void(int)> > KeyhookMap;
+
+struct PANGOLIN_EXPORT PangolinGl
+{
+    PangolinGl();
+    ~PangolinGl();
+
+    void Run();
+
+    void MakeCurrent();
+    void FinishFrame();
+
+    void RenderViews();
+    void PostRender();
+
+    void SetOnRender(std::function<void()> on_render);
+
+    // Callback for render loop
+    std::function<void()> on_render;
+
+    // Base container for displays
+    View base;
+    
+    // Named views which are managed by pangolin (i.e. created / deleted by pangolin)
+    ViewMap named_managed_views;
+
+    // Optional user app
+    UserApp* user_app;
+    
+    // Global keypress hooks
+    KeyhookMap keypress_hooks;
+    
+    // State relating to interactivity
+    bool quit;
+    int mouse_state;
+    View* activeDisplay;
+    
+    std::queue<std::pair<std::string,Viewport> > screen_capture;
+    
+    std::shared_ptr<WindowInterface> window;
+    std::shared_ptr<GlFont> font;
+
+    std::unique_ptr<ConsoleView> console_view;
+};
+
+PangolinGl* GetCurrentContext();
+void SetCurrentContext(PangolinGl* context);
+void RegisterNewContext(const std::string& name, std::shared_ptr<PangolinGl> newcontext);
+void DeleteContext(const std::string& name);
+PangolinGl *FindContext(const std::string& name);
+void SetCurrentContext(PangolinGl* newcontext);
+
+}
+

third-party/DPVO/Pangolin/components/pango_display/src/process.cpp

@@ -0,0 +1,161 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove, Richard Newcombe
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/display/process.h>
+#include <pangolin/console/ConsoleView.h>
+#include <pangolin/handler/handler.h>
+#include "pangolin_gl.h"
+
+namespace pangolin
+{
+namespace process
+{
+float last_x = 0;
+float last_y = 0;
+
+void Resize( int width, int height )
+{
+    PangolinGl* context = GetCurrentContext();
+
+    Viewport win(0,0,width,height);
+    context->base.Resize(win);
+}
+
+void Keyboard(unsigned char key, int x, int y, bool pressed, KeyModifierBitmask /*key_modifiers*/)
+{
+    PangolinGl* context = GetCurrentContext();
+
+    // Force coords to match OpenGl Window Coords
+    y = context->base.v.h - y;
+
+    if(pressed) {
+        // Check if global key hook exists
+        const KeyhookMap::iterator hook = context->keypress_hooks.find(key);
+
+        // Console receives all input when it is open
+        if( context->console_view && context->console_view->IsShown() ) {
+            context->console_view->Keyboard(*(context->console_view),key,x,y,true);
+        }else if(hook != context->keypress_hooks.end() ) {
+            hook->second(key);
+        } else if(context->activeDisplay && context->activeDisplay->handler) {
+            context->activeDisplay->handler->Keyboard(*(context->activeDisplay),key,x,y,true);
+        }
+    }else{
+        if(context->activeDisplay && context->activeDisplay->handler)
+        {
+            context->activeDisplay->handler->Keyboard(*(context->activeDisplay),key,x,y,false);
+        }
+    }
+}
+
+void Mouse( int button_raw, bool pressed, int x, int y, KeyModifierBitmask key_modifiers)
+{
+    PangolinGl* context = GetCurrentContext();
+
+    // Force coords to match OpenGl Window Coords
+    y = context->base.v.h - y;
+
+    last_x = (float)x;
+    last_y = (float)y;
+
+    const MouseButton button = (MouseButton)(1 << (button_raw & 0xf) );
+
+    const bool fresh_input = ( (context->mouse_state & 7) == 0);
+
+    if( pressed ) {
+        context->mouse_state |= (button&7);
+    }else{
+        context->mouse_state &= ~(button&7);
+    }
+
+#if defined(_WIN_)
+    context->mouse_state &= 0x0000ffff;
+    context->mouse_state |= (button_raw >> 4) << 16;
+#endif
+
+    const int button_state = context->mouse_state | key_modifiers.mask();
+
+    if(fresh_input) {
+        context->base.handler->Mouse(context->base,button,x,y,pressed,button_state);
+    }else if(context->activeDisplay && context->activeDisplay->handler) {
+        context->activeDisplay->handler->Mouse(*(context->activeDisplay),button,x,y,pressed,button_state);
+    }
+}
+
+void MouseMotion( int x, int y, KeyModifierBitmask key_modifiers)
+{
+    PangolinGl* context = GetCurrentContext();
+
+    // Force coords to match OpenGl Window Coords
+    y = context->base.v.h - y;
+
+    last_x = (float)x;
+    last_y = (float)y;
+
+    const int button_state = context->mouse_state | key_modifiers.mask();
+
+    if( context->activeDisplay)
+    {
+        if( context->activeDisplay->handler )
+            context->activeDisplay->handler->MouseMotion(*(context->activeDisplay),x,y,button_state);
+    }else{
+        context->base.handler->MouseMotion(context->base,x,y,button_state);
+    }
+}
+
+void PassiveMouseMotion(int x, int y, KeyModifierBitmask key_modifiers)
+{
+    PangolinGl* context = GetCurrentContext();
+
+    // Force coords to match OpenGl Window Coords
+    y = context->base.v.h - y;
+
+    const int button_state = context->mouse_state | key_modifiers.mask();
+    context->base.handler->PassiveMouseMotion(context->base,x,y,button_state);
+
+    last_x = (float)x;
+    last_y = (float)y;
+}
+
+void SpecialInput(InputSpecial inType, float x, float y, float p1, float p2, float p3, float p4, KeyModifierBitmask key_modifiers)
+{
+    PangolinGl* context = GetCurrentContext();
+
+    // Force coords to match OpenGl Window Coords
+    y = context->base.v.h - y;
+
+    const bool fresh_input = (context->mouse_state == 0);
+    const int button_state = context->mouse_state | key_modifiers.mask();
+
+    if(fresh_input) {
+        context->base.handler->Special(context->base,inType,x,y,p1,p2,p3,p4,button_state);
+    }else if(context->activeDisplay && context->activeDisplay->handler) {
+        context->activeDisplay->handler->Special(*(context->activeDisplay),inType,x,y,p1,p2,p3,p4,button_state);
+    }
+}
+}
+}

third-party/DPVO/Pangolin/components/pango_display/src/view.cpp

@@ -0,0 +1,508 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdexcept>
+#include <pangolin/display/display.h>
+#include <pangolin/display/view.h>
+#include <pangolin/gl/gl.h>
+#include <pangolin/gl/viewport.h>
+#include <pangolin/gl/opengl_render_state.h>
+#include <pangolin/platform.h>
+
+#include "pangolin_gl.h"
+
+namespace pangolin
+{
+
+const int panal_v_margin = 6;
+
+int AttachAbs( int low, int high, Attach a)
+{
+    if( a.unit == Pixel ) return low + (int)a.p;
+    if( a.unit == ReversePixel ) return high - (int)a.p;
+    return (int)(low + a.p * (high - low));
+}
+
+double AspectAreaWithinTarget(double target, double test)
+{
+    if( test < target )
+        return test / target;
+    else
+        return target / test;
+}
+
+void View::Resize(const Viewport& p)
+{
+    // Compute Bounds based on specification
+    v.l = AttachAbs(p.l,p.r(),left);
+    v.b = AttachAbs(p.b,p.t(),bottom);
+    int r = AttachAbs(p.l,p.r(),right);
+    int t = AttachAbs(p.b,p.t(),top);
+
+    // Make sure left and right, top and bottom are correct order
+    if( t < v.b ) std::swap(t,v.b);
+    if( r < v.l ) std::swap(r,v.l);
+
+    v.w = r - v.l;
+    v.h = t - v.b;
+
+    vp = v;
+
+    // Adjust based on aspect requirements
+    if( aspect != 0 )
+    {
+        const float current_aspect = (float)v.w / (float)v.h;
+        if( aspect > 0 )
+        {
+            // Fit to space
+            if( current_aspect < aspect )
+            {
+                //Adjust height
+                const int nh = (int)(v.w / aspect);
+                v.b += vlock == LockBottom ? 0 : (vlock == LockCenter ? (v.h-nh)/2 : (v.h-nh) );
+                v.h = nh;
+            }else if( current_aspect > aspect )
+            {
+                //Adjust width
+                const int nw = (int)(v.h * aspect);
+                v.l += hlock == LockLeft? 0 : (hlock == LockCenter ? (v.w-nw)/2 : (v.w-nw) );
+                v.w = nw;
+            }
+        }else{
+            // Overfit
+            double true_aspect = -aspect;
+            if( current_aspect < true_aspect )
+            {
+                //Adjust width
+                const int nw = (int)(v.h * true_aspect);
+                v.l += hlock == LockLeft? 0 : (hlock == LockCenter ? (v.w-nw)/2 : (v.w-nw) );
+                v.w = nw;
+            }else if( current_aspect > true_aspect )
+            {
+                //Adjust height
+                const int nh = (int)(v.w / true_aspect);
+                v.b += vlock == LockBottom ? 0 : (vlock == LockCenter ? (v.h-nh)/2 : (v.h-nh) );
+                v.h = nh;
+            }
+        }
+    }
+
+    ResizeChildren();
+}
+
+inline int zcompare(const View* lhs, const View* rhs)
+{
+    return lhs->zorder < rhs->zorder;
+}
+
+void View::ResizeChildren()
+{
+    if( layout == LayoutOverlay )
+    {
+        // Sort children into z-order
+        std::sort(views.begin(), views.end(), zcompare);
+
+        for(std::vector<View*>::iterator iv = views.begin(); iv != views.end(); ++iv ) {
+            (*iv)->Resize(v);
+        }
+    }else if( layout == LayoutVertical )
+    {
+        // Allocate space incrementally
+        Viewport space = v.Inset(panal_v_margin);
+        int num_children = 0;
+        for(std::vector<View*>::iterator iv = views.begin(); iv != views.end(); ++iv )
+        {
+            if (!(*iv)->show) continue;
+            num_children++;
+            if(scroll_offset >= num_children ) {
+                (*iv)->scroll_show = false;
+            }else{
+                (*iv)->scroll_show = true;
+                (*iv)->Resize(space);
+                space.h = (*iv)->v.b - panal_v_margin - space.b;
+            }
+        }
+    }else if(layout == LayoutHorizontal )
+    {
+        // Allocate space incrementally
+        const int margin = 8;
+        Viewport space = v.Inset(margin);
+        for(std::vector<View*>::iterator iv = views.begin(); iv != views.end(); ++iv )
+        {
+            (*iv)->Resize(space);
+            space.w = (*iv)->v.l + margin + space.l;
+        }
+    }else if(layout == LayoutEqualVertical )
+    {
+        // Allocate vertical space equally
+        const size_t visiblechildren = NumVisibleChildren();
+        const float height = (float)v.h / (float)visiblechildren;
+
+        for( size_t i=0; i < visiblechildren; ++i) {
+            Viewport space(v.l, (GLint)(v.b+(visiblechildren-1-i)*height), v.w, (GLint)(height) );
+            VisibleChild(i).Resize(space);
+        }
+    }else if(layout == LayoutEqualHorizontal )
+    {
+        // Allocate vertical space equally
+        const size_t visiblechildren = NumVisibleChildren();
+        const float width = (float)v.w / (float)visiblechildren;
+
+        for( size_t i=0; i < visiblechildren; ++i) {
+            Viewport space( (GLint)(v.l+i*width), v.b, (GLint)width, v.h);
+            VisibleChild(i).Resize(space);
+        }
+    }else if(layout == LayoutEqual )
+    {
+        const size_t visiblechildren = NumVisibleChildren();
+        // TODO: Make this neater, and make fewer assumptions!
+        if( visiblechildren > 0 )
+        {
+            // This containers aspect
+            const double this_a = std::fabs(v.aspect());
+
+            // Use first child with fixed aspect for all children
+            double child_a = std::fabs(VisibleChild(0).aspect);
+            for(size_t i=1; (child_a==0) && i < visiblechildren; ++i ) {
+                child_a = std::fabs(VisibleChild(i).aspect);
+            }
+
+            if(child_a == 0) {
+                child_a = 1;
+            }
+
+            double a = visiblechildren*child_a;
+            double area = AspectAreaWithinTarget(this_a, a);
+
+            size_t cols = visiblechildren-1;
+            for(; cols > 0; --cols)
+            {
+                const size_t rows = visiblechildren / cols + (visiblechildren % cols == 0 ? 0 : 1);
+                const double na = cols * child_a / rows;
+                const double new_area = visiblechildren*AspectAreaWithinTarget(this_a,na)/(rows*cols);
+                if( new_area <= area )
+                    break;
+                area = new_area;
+                a = na;
+            }
+
+            cols++;
+            const size_t rows = visiblechildren / cols + (visiblechildren % cols == 0 ? 0 : 1);
+            size_t cw, ch;
+            if( a > this_a )
+            {
+                cw = v.w / cols;
+                ch = (int)(cw / child_a); //v.h / rows;
+            }else{
+                ch = v.h / rows;
+                cw = (int)(ch * child_a);
+            }
+
+            for(size_t i=0; i< visiblechildren; ++i )
+            {
+                size_t c = i % cols;
+                size_t r = i / cols;
+                Viewport space( GLint(v.l + c*cw), GLint(v.t() - (r+1)*ch), GLint(cw), GLint(ch) );
+                VisibleChild(i).Resize(space);
+            }
+        }
+    }
+
+}
+
+void View::Render()
+{
+    if(extern_draw_function && show && scroll_show) {
+        extern_draw_function(*this);
+    }
+    RenderChildren();
+}
+
+void View::RenderChildren()
+{
+    for(std::vector<View*>::iterator iv = views.begin(); iv != views.end(); ++iv )
+    {
+        if((*iv)->show && (*iv)->scroll_show) (*iv)->Render();
+    }
+}
+
+void View::Activate() const
+{
+    v.Activate();
+}
+
+void View::ActivateAndScissor() const
+{
+    vp.Scissor();
+    v.Activate();
+}
+
+void View::ActivateScissorAndClear() const
+{
+    vp.Scissor();
+    v.Activate();
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+void View::Activate(const OpenGlRenderState& state ) const
+{
+    v.Activate();
+    state.Apply();
+}
+
+void View::ActivateAndScissor(const OpenGlRenderState& state) const
+{
+    vp.Scissor();
+    v.Activate();
+    state.Apply();
+}
+
+void View::ActivateScissorAndClear(const OpenGlRenderState& state ) const
+{
+    vp.Scissor();
+    v.Activate();
+    state.Apply();
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+void View::ActivatePixelOrthographic() const
+{
+    v.ActivatePixelOrthographic();
+}
+
+void View::ActivateIdentity() const
+{
+    v.ActivateIdentity();
+}
+
+GLfloat View::GetClosestDepth(int x, int y, int radius) const
+{
+    // TODO: Get to work on android
+
+#ifdef _MSC_VER
+    // MSVC Requires fixed sized arrays on stack
+    radius = 5;
+    const int zl = (5*2+1);
+#else
+    const int zl = (radius*2+1);
+#endif
+
+    const int zsize = zl*zl;
+    GLfloat zs[zsize];
+
+#ifndef HAVE_GLES
+    glReadBuffer(GL_FRONT);
+    glReadPixels(x-radius,y-radius,zl,zl,GL_DEPTH_COMPONENT,GL_FLOAT,zs);
+#else
+    std::fill(zs,zs+zsize, 0.8);
+#endif
+
+    const GLfloat mindepth = *(std::min_element(zs,zs+zsize));
+    return mindepth;
+}
+
+void View::GetObjectCoordinates(const OpenGlRenderState& cam_state, double winx, double winy, double winzdepth, GLdouble& x, GLdouble& y, GLdouble& z) const
+{
+    const GLint viewport[4] = {v.l,v.b,v.w,v.h};
+    const OpenGlMatrix proj = cam_state.GetProjectionMatrix();
+    const OpenGlMatrix mv = cam_state.GetModelViewMatrix();
+    glUnProject(winx, winy, winzdepth, mv.m, proj.m, viewport, &x, &y, &z);
+}
+
+void View::GetCamCoordinates(const OpenGlRenderState& cam_state, double winx, double winy, double winzdepth, GLdouble& x, GLdouble& y, GLdouble& z) const
+{
+    const GLint viewport[4] = {v.l, v.b, v.w, v.h};
+    const OpenGlMatrix proj = cam_state.GetProjectionMatrix();
+#ifndef HAVE_GLES
+    glUnProject(winx, winy, winzdepth, Identity4d, proj.m, viewport, &x, &y, &z);
+#else
+    glUnProject(winx, winy, winzdepth, Identity4f, proj.m, viewport, &x, &y, &z);
+#endif
+}
+
+View& View::SetFocus()
+{
+    GetCurrentContext()->activeDisplay = this;
+    return *this;
+}
+
+bool View::HasFocus() const
+{
+    return GetCurrentContext()->activeDisplay == this;
+}
+
+View& View::SetBounds(Attach bottom, Attach top, Attach left, Attach right)
+{
+    this->left = left;
+    this->top = top;
+    this->right = right;
+    this->bottom = bottom;
+    GetCurrentContext()->base.ResizeChildren();
+    return *this;
+}
+
+View& View::SetBounds(Attach bottom, Attach top,  Attach left, Attach right, bool keep_aspect)
+{
+    aspect = keep_aspect ? v.aspect() : 0;
+    SetBounds(top,bottom,left,right);
+    return *this;
+}
+
+View& View::SetBounds(Attach bottom, Attach top,  Attach left, Attach right, double aspect)
+{
+    this->aspect = aspect;
+    SetBounds(top,bottom,left,right);
+    return *this;
+}
+
+View& View::SetAspect(double aspect)
+{
+    this->aspect = aspect;
+    GetCurrentContext()->base.ResizeChildren();
+    return *this;
+}
+
+View& View::SetLock(Lock horizontal, Lock vertical )
+{
+    vlock = vertical;
+    hlock = horizontal;
+    return *this;
+}
+
+View& View::SetLayout(Layout l)
+{
+    layout = l;
+    return *this;
+}
+
+
+View& View::AddDisplay(View& child)
+{
+    // detach child from any other view, and add to this
+    std::vector<View*>::iterator f = std::find(
+                GetCurrentContext()->base.views.begin(), GetCurrentContext()->base.views.end(), &child
+                );
+
+    if( f != GetCurrentContext()->base.views.end() )
+        GetCurrentContext()->base.views.erase(f);
+
+    views.push_back(&child);
+    GetCurrentContext()->base.ResizeChildren();
+    return *this;
+}
+
+View& View::Show(bool show)
+{
+    this->show = show;
+    GetCurrentContext()->base.ResizeChildren();
+    return *this;
+}
+
+void View::ToggleShow()
+{
+    Show(!show);
+}
+
+bool View::IsShown() const
+{
+    return show;
+}
+
+Viewport View::GetBounds() const
+{
+    return Viewport( std::max(v.l, vp.l), std::max(v.b, vp.b), std::min(v.w, vp.w), std::min(v.h, vp.h) );
+}
+
+void View::SaveOnRender(const std::string& filename_hint)
+{
+    SaveWindowOnRender(filename_hint, this->v.Intersect(this->vp));
+}
+
+void View::SaveRenderNow(const std::string& filename_hint)
+{
+    SaveWindowNow(filename_hint, this->v);
+}
+
+View& View::operator[](size_t i)
+{
+    return *views[i];
+}
+
+size_t View::NumChildren() const
+{
+    return views.size();
+}
+
+size_t View::NumVisibleChildren() const
+{
+    int numvis = 0;
+    for(std::vector<View*>::const_iterator i=views.begin(); i!=views.end(); ++i)
+    {
+        if((*i)->show) {
+            numvis++;
+        }
+    }
+    return numvis;
+}
+
+View& View::VisibleChild(size_t i)
+{
+    size_t numvis = 0;
+    for(size_t v=0; v < views.size(); ++v ) {
+        if(views[v]->show) {
+            if( i == numvis ) {
+                return *views[v];
+            }
+            numvis++;
+        }
+    }
+    // Shouldn't get here
+    throw std::out_of_range("No such child.");
+}
+
+View* View::FindChild(int x, int y)
+{
+    // Find in reverse order to mirror draw order
+    for( std::vector<View*>::const_reverse_iterator i = views.rbegin(); i != views.rend(); ++i )
+        if( (*i)->show && (*i)->GetBounds().Contains(x,y) )
+            return (*i);
+    return 0;
+}
+
+View& View::SetHandler(Handler* h)
+{
+    handler = h;
+    return *this;
+}
+
+View& View::SetDrawFunction(const std::function<void(View&)>& drawFunc)
+{
+    extern_draw_function = drawFunc;
+    return *this;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_display/src/widgets.cpp

@@ -0,0 +1,787 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <thread>
+#include <mutex>
+#include <iostream>
+#include <iomanip>
+
+#include <pangolin/display/widgets.h>
+#include <pangolin/display/display.h>
+#include <pangolin/display/default_font.h>
+#include <pangolin/gl/gldraw.h>
+#include <pangolin/var/varextra.h>
+#include <pangolin/utils/file_utils.h>
+
+#include "pangolin_gl.h"
+
+
+using namespace std;
+
+namespace pangolin
+{
+
+const static GLfloat colour_s1[4] = {0.2f, 0.2f, 0.2f, 1.0f};
+const static GLfloat colour_s2[4] = {0.6f, 0.6f, 0.6f, 1.0f};
+const static GLfloat colour_bg[4] = {0.9f, 0.9f, 0.9f, 1.0f};
+const static GLfloat colour_fg[4] = {1.0f, 1.0f, 1.0f, 1.0f};
+const static GLfloat colour_tx[4] = {0.0f, 0.0f, 0.0f, 1.0f};
+const static GLfloat colour_dn[4] = {1.0f, 0.7f, 0.7f, 1.0f};
+
+// TODO: It doesn't look like this is doing anything meaningful right now...
+std::mutex display_mutex;
+
+// Render at (x,y) in window coordinates.
+inline void DrawWindow(GlText& text, GLfloat x, GLfloat y, GLfloat z = 0.0)
+{
+    // Backup viewport
+    GLint    view[4];
+    glGetIntegerv(GL_VIEWPORT, view );
+
+    glMatrixMode(GL_PROJECTION);
+    glPushMatrix();
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+
+    DisplayBase().ActivatePixelOrthographic();
+
+    glTranslatef( std::floor(x), std::floor(y), z);
+    text.Draw();
+
+    // Restore viewport
+    glViewport(view[0],view[1],view[2],view[3]);
+
+    // Restore modelview / project matrices
+    glMatrixMode(GL_PROJECTION);
+    glPopMatrix();
+    glMatrixMode(GL_MODELVIEW);
+    glPopMatrix();
+}
+
+static inline int cb_height()
+{
+    return (int)(default_font().Height() * 1.0);
+}
+
+static inline int tab_h()
+{
+    return (int)(default_font().Height() * 1.4);
+}
+
+static inline float x_width()
+{
+  return default_font().Text("x").Width();
+}
+
+template<typename T>
+inline void MarkVarChangedByGui(VarValueT<T>& var)
+{
+    var.Meta().gui_changed = true;
+    FlagVarChanged();
+}
+
+void glLine(GLfloat vs[4])
+{
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glVertexPointer(2, GL_FLOAT, 0, vs);
+    glDrawArrays( GL_LINE_STRIP, 0, 2);
+    glDisableClientState(GL_VERTEX_ARRAY);
+}
+
+void glRect(Viewport v)
+{
+    GLfloat vs[] = { (float)v.l,(float)v.b,
+                     (float)v.l,(float)v.t(),
+                     (float)v.r(),(float)v.t(),
+                     (float)v.r(),(float)v.b };
+
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glVertexPointer(2, GL_FLOAT, 0, vs);
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+    glDisableClientState(GL_VERTEX_ARRAY);
+}
+
+void glRect(Viewport v, int inset)
+{
+    glRect(v.Inset(inset));
+}
+
+void DrawShadowRect(Viewport& v)
+{
+    glColor4fv(colour_s2);
+    glDrawRectPerimeter((GLfloat)v.l, (GLfloat)v.b, (GLfloat)v.r(), (GLfloat)v.t());
+}
+
+void DrawShadowRect(Viewport& v, bool pushed)
+{
+    const GLfloat* c1 = pushed ? colour_s1 : colour_s2;
+    const GLfloat* c2 = pushed ? colour_s2 : colour_s1;
+
+    GLfloat vs[] = { (float)v.l,(float)v.b,
+                     (float)v.l,(float)v.t(),
+                     (float)v.r(),(float)v.t(),
+                     (float)v.r(),(float)v.b,
+                     (float)v.l,(float)v.b };
+
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glVertexPointer(2, GL_FLOAT, 0, vs);
+    glColor4fv(c1);
+    glDrawArrays(GL_LINE_STRIP, 0, 3);
+
+    glColor4fv(c2);
+    glDrawArrays(GL_LINE_STRIP, 2, 3);
+    glDisableClientState(GL_VERTEX_ARRAY);
+
+}
+
+Panel::Panel()
+{
+    handler = &StaticHandlerScroll;
+    layout = LayoutVertical;
+}
+
+Panel::Panel(const std::string& auto_register_var_prefix)
+    : auto_register_var_prefix(auto_register_var_prefix)
+{
+    handler = &StaticHandlerScroll;
+    layout = LayoutVertical;
+
+    // Register for notifications on var additions
+    var_added_connection = VarState::I().RegisterForVarEvents(
+        std::bind(&Panel::NewVarCallback,this,std::placeholders::_1),
+        true
+    );
+}
+
+void Panel::NewVarCallback(const VarState::Event& e)
+{
+    const std::string name = e.var->Meta().full_name;
+    if(!StartsWith(name, auto_register_var_prefix))
+        return;
+
+    switch(e.action) {
+    case VarState::Event::Action::Added:
+        AddVariable(name, e.var);
+        break;
+    case VarState::Event::Action::Removed:
+        RemoveVariable(name);
+        break;
+    }
+}
+
+void Panel::AddVariable(const std::string& name, const std::shared_ptr<VarValueGeneric>& var)
+{
+    const string& title = var->Meta().friendly;
+    
+    display_mutex.lock();
+    
+    ViewMap::iterator pnl = GetCurrentContext()->named_managed_views.find(name);
+    
+    // Only add if a widget by the same name doesn't already exist
+    if( pnl == GetCurrentContext()->named_managed_views.end() )
+    {
+        View* nv = NULL;
+        if( !strcmp(var->TypeId(), typeid(bool).name()) ) {
+            nv = (var->Meta().flags & META_FLAG_TOGGLE) ? (View*)new Checkbox(title,var) : (View*)new Button(title,var);
+        } else if (!strcmp(var->TypeId(), typeid(double).name()) ||
+                   !strcmp(var->TypeId(), typeid(float).name()) ||
+                   !strcmp(var->TypeId(), typeid(int8_t).name()) ||
+                   !strcmp(var->TypeId(), typeid(uint8_t).name()) ||
+                   !strcmp(var->TypeId(), typeid(int16_t).name()) ||
+                   !strcmp(var->TypeId(), typeid(uint16_t).name()) ||
+                   !strcmp(var->TypeId(), typeid(int32_t).name()) ||
+                   !strcmp(var->TypeId(), typeid(uint32_t).name()) ||
+                   !strcmp(var->TypeId(), typeid(int64_t).name()) ||
+                   !strcmp(var->TypeId(), typeid(uint64_t).name())
+                   )
+        {
+            nv = new Slider(title, var);
+        } else if (!strcmp(var->TypeId(), typeid(std::function<void(void)>).name() ) ) {
+            nv = (View*)new FunctionButton(title, var);
+        }else if(var->str){
+            nv = new TextInput(title,var);
+        }
+        if(nv) {
+            GetCurrentContext()->named_managed_views[name] = nv;
+            views.push_back( nv );
+            ResizeChildren();
+        }
+    }
+
+    display_mutex.unlock();
+}
+
+void Panel::RemoveVariable(const std::string& name)
+{
+    display_mutex.lock();
+
+    ViewMap::iterator pnl = GetCurrentContext()->named_managed_views.find(name);
+
+    if( pnl != GetCurrentContext()->named_managed_views.end() ) {
+      views.erase(std::remove(views.begin(), views.end(), pnl->second), views.end());
+      ResizeChildren();
+
+      delete pnl->second;
+      GetCurrentContext()->named_managed_views.erase(pnl);
+    }
+
+    display_mutex.unlock();
+}
+
+void Panel::Render()
+{
+#ifndef HAVE_GLES
+    glPushAttrib(GL_CURRENT_BIT | GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT | GL_SCISSOR_BIT | GL_VIEWPORT_BIT | GL_COLOR_BUFFER_BIT | GL_TRANSFORM_BIT);
+#endif
+    glEnable (GL_BLEND);
+    glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    DisplayBase().ActivatePixelOrthographic();
+    glDisable(GL_DEPTH_TEST);
+    glDisable(GL_LIGHTING);
+    glDisable(GL_SCISSOR_TEST);
+    glDisable(GL_LINE_SMOOTH);
+    glDisable( GL_COLOR_MATERIAL );
+    glLineWidth(1.0);
+
+    glColor4fv(colour_bg);
+    glRect(v);
+    DrawShadowRect(v);
+
+    RenderChildren();
+
+#ifndef HAVE_GLES
+    glPopAttrib();
+#else
+    glEnable(GL_LINE_SMOOTH);
+    glEnable(GL_DEPTH_TEST);
+#endif
+}
+
+void Panel::ResizeChildren()
+{
+    View::ResizeChildren();
+}
+
+
+View& CreatePanel(const std::string& name)
+{
+    if(GetCurrentContext()->named_managed_views.find(name) != GetCurrentContext()->named_managed_views.end()) {
+        throw std::runtime_error("Panel already registered with this name.");
+    }
+    Panel * p = new Panel(name);
+    GetCurrentContext()->named_managed_views[name] = p;
+    GetCurrentContext()->base.views.push_back(p);
+    return *p;
+}
+
+Button::Button(string title, const std::shared_ptr<VarValueGeneric>& tv)
+    : Widget<bool>(title,tv), down(false)
+{
+    top = 1.0; bottom = Attach::Pix(-tab_h());
+    left = 0.0; right = 1.0;
+    hlock = LockLeft;
+    vlock = LockBottom;
+    gltext = default_font().Text(title);
+}
+
+void Button::Mouse(View&, MouseButton button, int /*x*/, int /*y*/, bool pressed, int /*mouse_state*/)
+{
+    if(button == MouseButtonLeft )
+    {
+        down = pressed;
+        if( !pressed ) {
+            var->Set(!var->Get());
+            MarkVarChangedByGui(*var);
+        }
+    }
+}
+
+void Button::Render()
+{
+    glColor4fv(colour_fg );
+    glRect(v);
+    glColor4fv(colour_tx);
+    if(gltext.Text() != var->Meta().friendly) {
+        gltext = default_font().Text(var->Meta().friendly);
+    }
+    DrawWindow(gltext, raster[0],raster[1]-down);
+    DrawShadowRect(v, down);
+}
+
+void Button::ResizeChildren()
+{
+    raster[0] = floor(v.l + (v.w-gltext.Width())/2.0f);
+    raster[1] = floor(v.b + (v.h-gltext.Height())/2.0f);
+}
+
+FunctionButton::FunctionButton(string title, const std::shared_ptr<VarValueGeneric> &tv)
+    : Widget<std::function<void(void)> >(title, tv), down(false)
+{
+    top = 1.0; bottom = Attach::Pix(-tab_h());
+    left = 0.0; right = 1.0;
+    hlock = LockLeft;
+    vlock = LockBottom;
+    gltext = default_font().Text(title);
+}
+
+void FunctionButton::Mouse(View&, MouseButton button, int /*x*/, int /*y*/, bool pressed, int /*mouse_state*/)
+{
+    if (button == MouseButtonLeft)
+    {
+        down = pressed;
+        if (!pressed) {
+            var->Get()();
+            MarkVarChangedByGui(*var);
+        }
+    }
+}
+
+void FunctionButton::Render()
+{
+    glColor4fv(colour_fg);
+    glRect(v);
+    glColor4fv(colour_tx);
+    if(gltext.Text() != var->Meta().friendly) {
+        gltext = default_font().Text(var->Meta().friendly);
+    }
+    DrawWindow(gltext, raster[0],raster[1]-down);
+    DrawShadowRect(v, down);
+}
+
+void FunctionButton::ResizeChildren()
+{
+    raster[0] = v.l + (v.w - gltext.Width()) / 2.0f;
+    raster[1] = v.b + (v.h - gltext.Height()) / 2.0f;
+}
+
+Checkbox::Checkbox(std::string title, const std::shared_ptr<VarValueGeneric> &tv)
+    : Widget<bool>(title,tv)
+{
+    top = 1.0; bottom = Attach::Pix(-tab_h());
+    left = 0.0; right = 1.0;
+    hlock = LockLeft;
+    vlock = LockBottom;
+    handler = this;
+    gltext = default_font().Text(title);
+}
+
+void Checkbox::Mouse(View&, MouseButton button, int /*x*/, int /*y*/, bool pressed, int /*mouse_state*/)
+{
+    if( button == MouseButtonLeft && pressed ) {
+        var->Set(!var->Get());
+        MarkVarChangedByGui(*var);
+    }
+}
+
+void Checkbox::ResizeChildren()
+{
+    raster[0] = v.l + cb_height() + 4.0f;
+    raster[1] = v.b + (v.h-gltext.Height())/2.0f;
+    const int h = v.h;
+    const int t = (int)((h-cb_height()) / 2.0f);
+    vcb = Viewport(v.l,v.b+t,cb_height(),cb_height());
+}
+
+void Checkbox::Render()
+{
+    const bool val = var->Get();
+
+    if( val )
+    {
+        glColor4fv(colour_dn);
+        glRect(vcb);
+    }
+    glColor4fv(colour_tx);
+    if(gltext.Text() != var->Meta().friendly) {
+        gltext = default_font().Text(var->Meta().friendly);
+    }
+    DrawWindow(gltext, raster[0], raster[1]);
+    DrawShadowRect(vcb, val);
+}
+
+inline bool IsIntegral(const char* typeidname)
+{
+    // TODO: There must be a better way of doing this...
+    return !strcmp(typeidname, typeid(char).name()) ||
+           !strcmp(typeidname, typeid(short).name()) ||
+           !strcmp(typeidname, typeid(int).name())  ||
+           !strcmp(typeidname, typeid(long).name()) ||
+           !strcmp(typeidname, typeid(unsigned char).name()) ||
+           !strcmp(typeidname, typeid(unsigned short).name()) ||
+           !strcmp(typeidname, typeid(unsigned int).name()) ||
+           !strcmp(typeidname, typeid(unsigned long).name());
+}
+
+Slider::Slider(std::string title, const std::shared_ptr<VarValueGeneric> &tv)
+    : Widget<double>(title+":", tv), lock_bounds(true)
+{
+    top = 1.0; bottom = Attach::Pix(-tab_h());
+    left = 0.0; right = 1.0;
+    hlock = LockLeft;
+    vlock = LockBottom;
+    handler = this;
+    logscale = (int)tv->Meta().logscale;
+    gltext = default_font().Text(title);
+    is_integral_type = IsIntegral(tv->TypeId());
+}
+
+void Slider::Keyboard(View&, unsigned char key, int /*x*/, int /*y*/, bool pressed)
+{
+    if( pressed && var->Meta().range[0] < var->Meta().range[1] )
+    {
+        double val = !logscale ? var->Get() : log(var->Get());
+
+        if(key=='-' || key=='_' || key=='=' || key=='+') {
+            double inc = var->Meta().increment;
+            if (key == '-') inc *= -1.0;
+            if (key == '_') inc *= -0.1;
+            if (key == '+') inc *=  0.1;
+            const double newval = max(var->Meta().range[0], min(var->Meta().range[1], val + inc));
+            var->Set( logscale ? exp(newval) : newval );
+            MarkVarChangedByGui(*var);
+        }else if(key == 'r'){
+            Reset();
+            MarkVarChangedByGui(*var);
+        }else{
+            return;
+        }
+    }
+}
+
+void Slider::Mouse(View& view, MouseButton button, int x, int y, bool pressed, int mouse_state)
+{
+    if(pressed)
+    {
+        // Wheel
+        if( button == MouseWheelUp || button == MouseWheelDown )
+        {
+            // Change scale around current value
+            const double frac = max(0.0,min(1.0,(double)(x - v.l)/(double)v.w));
+            double val = frac * (var->Meta().range[1] - var->Meta().range[0]) + var->Meta().range[0];
+
+            if (logscale)
+            {
+                if (val<=0)
+                    val = std::numeric_limits<double>::min();
+                else
+                    val = log(val);
+            }
+
+            const double scale = (button == MouseWheelUp ? 1.2 : 1.0 / 1.2 );
+            var->Meta().range[1] = val + (var->Meta().range[1] - val)*scale;
+            var->Meta().range[0] = val - (val - var->Meta().range[0])*scale;
+        }else{
+            lock_bounds = (button == MouseButtonLeft);
+            MouseMotion(view,x,y,mouse_state);
+        }
+    }else{
+        if(!lock_bounds)
+        {
+            double val = !logscale ? var->Get() : log(var->Get());
+
+            var->Meta().range[0] = min(var->Meta().range[0], val);
+            var->Meta().range[1] = max(var->Meta().range[1], val);
+        }
+    }
+}
+
+void Slider::MouseMotion(View&, int x, int /*y*/, int /*mouse_state*/)
+{
+    if( var->Meta().range[0] != var->Meta().range[1] )
+    {
+        const double range = (var->Meta().range[1] - var->Meta().range[0]);
+        const double frac = (double)(x - v.l)/(double)v.w;
+        double val;
+
+        if( lock_bounds )
+        {
+            const double bfrac = max(0.0,min(1.0,frac));
+            val = bfrac * range + var->Meta().range[0] ;
+        }else{
+            val = frac * range + var->Meta().range[0];
+        }
+
+        if (logscale) {
+            val = exp(val);
+        }
+
+        if( is_integral_type ) {
+            val = std::round(val);
+        }
+
+        var->Set(val);
+        MarkVarChangedByGui(*var);
+    }
+}
+
+
+void Slider::ResizeChildren()
+{
+    raster[0] = v.l + 2.0f;
+    raster[1] = v.b + (v.h-gltext.Height())/2.0f;
+}
+
+void Slider::Render()
+{
+    const double val = var->Get();
+
+    if( var->Meta().range[0] != var->Meta().range[1] )
+    {
+        double rval = val;
+        if (logscale)
+        {
+            rval = log(val);
+        }
+        glColor4fv(colour_fg);
+        glRect(v);
+        glColor4fv(colour_dn);
+        const double norm_val = max(0.0,min(1.0,(rval - var->Meta().range[0]) / (var->Meta().range[1] - var->Meta().range[0])));
+        glRect(Viewport(v.l,v.b, (int)(v.w*norm_val),v.h));
+        DrawShadowRect(v);
+    }
+
+    glColor4fv(colour_tx);
+    if(gltext.Text() != var->Meta().friendly) {
+        gltext = default_font().Text(var->Meta().friendly);
+    }
+    DrawWindow(gltext, raster[0], raster[1]);
+
+    std::ostringstream oss;
+    oss << setprecision(4) << val;
+    string str = oss.str();
+    GlText glval = default_font().Text(str);
+    const float l = glval.Width() + 2.0f;
+    DrawWindow(glval,  v.l + v.w - l, raster[1] );
+}
+
+
+TextInput::TextInput(std::string title, const std::shared_ptr<VarValueGeneric> &tv)
+    : Widget<std::string>(title+":", tv), can_edit(!(tv->Meta().flags & META_FLAG_READONLY)), do_edit(false)
+{
+    top = 1.0; bottom = Attach::Pix(-2 * tab_h());
+    left = 0.0; right = 1.0;
+    hlock = LockLeft;
+    vlock = LockBottom;
+    handler = this;
+    sel[0] = -1;
+    sel[1] = -1;
+    gltext = default_font().Text(title);
+}
+
+void TextInput::Keyboard(View&, unsigned char key, int /*x*/, int /*y*/, bool pressed)
+{
+    if(can_edit && pressed && do_edit)
+    {
+        const bool selection = sel[1] > sel[0] && sel[0] >= 0;
+
+        if(key == 13)
+        {
+            var->Set(edit);
+            MarkVarChangedByGui(*var);
+
+            do_edit = false;
+            sel[0] = sel[1] = -1;
+        }else if(key == 8) {
+            // backspace
+            if(selection)
+            {
+                edit = edit.substr(0,sel[0]) + edit.substr(sel[1],edit.length()-sel[1]);
+                sel[1] = sel[0];
+            }else{
+                if(sel[0] >0)
+                {
+                    edit = edit.substr(0,sel[0]-1) + edit.substr(sel[0],edit.length()-sel[0]);
+                    sel[0]--;
+                    sel[1]--;
+                }
+            }
+        }else if(key == 127){
+            // delete
+            if(selection)
+            {
+                edit = edit.substr(0,sel[0]) + edit.substr(sel[1],edit.length()-sel[1]);
+                sel[1] = sel[0];
+            }else{
+                if(sel[0] < (int)edit.length())
+                {
+                    edit = edit.substr(0,sel[0]) + edit.substr(sel[0]+1,edit.length()-sel[0]+1);
+                }
+            }
+        }else if(key == 230){
+            // right
+            sel[0] = min((int)edit.length(),sel[0]+1);
+            sel[1] = sel[0];
+        }else if(key == 228){
+            // left
+            sel[0] = max(0,sel[0]-1);
+            sel[1] = sel[0];
+        }else if(key == 234){
+            // home
+            sel[0] = sel[1] = 0;
+        }else if(key == 235){
+            // end
+            sel[0] = sel[1] = (int)edit.length();
+        }else if(key < PANGO_SPECIAL){
+            edit = edit.substr(0,sel[0]).append(1,key) + edit.substr(sel[1],edit.length()-sel[1]);
+            sel[1] = sel[0];
+            sel[0]++;
+            sel[1]++;
+        }
+        CalcVisibleEditPart();
+    }
+}
+
+void TextInput::Mouse(View& /*view*/, MouseButton button, int x, int /*y*/, bool pressed, int /*mouse_state*/)
+{
+    if(can_edit && button != MouseWheelUp && button != MouseWheelDown )
+    {
+
+        if(do_edit)
+        {
+            const int sl = (int)gledit.Width() + vertical_margin;
+            const int rl = v.l + v.w - sl;
+            std::string edit_visible = edit.substr(edit_visible_part[0], edit_visible_part[1]);
+            int ep = (int)edit_visible.length();
+            
+            if( x < rl )
+            {
+                ep = 0;
+            }else{
+                for( unsigned i=0; i<edit_visible.length(); ++i )
+                {
+                    const int tl = (int)(rl + default_font().Text(edit_visible.substr(0,i)).Width());
+                    if(x < tl+2)
+                    {
+                        ep = i;
+                        break;
+                    }
+                }
+            }
+            if(pressed)
+            {
+                sel[0] = sel[1] = ep + edit_visible_part[0];
+            }else{
+                sel[1] = ep + edit_visible_part[0];
+            }
+
+            if(sel[0] > sel[1])
+                std::swap(sel[0],sel[1]);
+        }else{
+            do_edit = !pressed;
+            sel[0] = 0;
+            sel[1] = (int)edit.length();
+        }
+    }
+}
+
+void TextInput::MouseMotion(View&, int x, int /*y*/, int /*mouse_state*/)
+{
+    if(can_edit && do_edit)
+    {
+        const int sl = (int)gledit.Width() + 2;
+        const int rl = v.l + v.w - sl;
+        std::string edit_visible = edit.substr(edit_visible_part[0], edit_visible_part[1]);
+        int ep = (int)edit_visible.length();
+        
+        if( x < rl )
+        {
+            ep = 0;
+        }else{
+            for( unsigned i=0; i<edit.length(); ++i )
+            {
+                const int tl = (int)(rl + default_font().Text(edit_visible.substr(0,i)).Width());
+                if(x < tl+2)
+                {
+                    ep = i;
+                    break;
+                }
+            }
+        }
+        
+        sel[1] = ep + edit_visible_part[0];
+    }
+}
+
+
+void TextInput::ResizeChildren()
+{
+    vertical_margin = (v.h-2.f*gltext.Height()) / 4.0f;
+    input_width = v.w - 2 * horizontal_margin;
+    int max_possible_chars = floor(input_width / x_width());
+    edit_visible_part[1] = max_possible_chars;
+    CalcVisibleEditPart();
+}
+
+void TextInput::CalcVisibleEditPart()
+{
+    edit_visible_part[0] =  0;
+
+    if(default_font().Text(edit).Width() > input_width)
+    {
+      if(sel[1] >= 0 )
+      {
+        edit_visible_part[0] = max(0, sel[1] - edit_visible_part[1]);
+      }
+    }
+};
+
+void TextInput::Render()
+{
+    if(!do_edit) edit = var->Get();
+
+    Viewport input_v(v.l,v.b,v.w,v.h / 2);
+    
+    glColor4fv(colour_fg);
+    if(can_edit) glRect(input_v);
+
+    std::string edit_visible = edit.substr(edit_visible_part[0], edit_visible_part[1]);
+    gledit = default_font().Text(edit_visible);
+
+    const int sl = (int)gledit.Width() + horizontal_margin;
+    const int rl = v.l + v.w - sl;
+
+    if( do_edit && sel[0] >= 0)
+    {
+        const int tl = (int)(rl + default_font().Text(edit_visible.substr(0,sel[0] - edit_visible_part[0])).Width());
+        const int tr = (int)(rl + default_font().Text(edit_visible.substr(0,sel[1] - edit_visible_part[0])).Width());
+        glColor4fv(colour_dn);
+        glRect(Viewport(tl,input_v.b,tr-tl,input_v.h));
+
+        glColor4fv(colour_tx);
+        GLfloat caret[4] = {(float) tr, (float) input_v.b, (float) tr, (float) input_v.b + input_v.h};
+        glLine(caret);
+    }
+
+    glColor4fv(colour_tx);
+    DrawWindow(gltext, v.l + horizontal_margin, v.b + gltext.Height() + 3.f * vertical_margin);
+
+    DrawWindow(gledit, (GLfloat)(rl), input_v.b + vertical_margin);
+    if(can_edit) DrawShadowRect(input_v);
+}
+
+}

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

@@ -0,0 +1,21 @@
+get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME)
+
+find_package (Eigen3 REQUIRED QUIET)
+message(STATUS "Found Eigen: '${EIGEN3_INCLUDE_DIRS}'")
+target_compile_definitions(${COMPONENT} PUBLIC HAVE_EIGEN)
+
+target_sources( ${COMPONENT}
+PRIVATE
+    ${CMAKE_CURRENT_LIST_DIR}/src/geometry.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/geometry_obj.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/geometry_ply.cpp
+)
+
+target_link_libraries(${COMPONENT} pango_core pango_image tinyobj Eigen3::Eigen)
+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}
+)

third-party/DPVO/Pangolin/components/pango_geometry/include/pangolin/geometry/geometry.h

@@ -0,0 +1,93 @@
+/* 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_GEOMETRY_H
+#define PANGOLIN_GEOMETRY_H
+
+#include <map>
+#include <unordered_map>
+#include <vector>
+#include <variant>
+#include <pangolin/image/typed_image.h>
+
+#ifdef HAVE_EIGEN
+#include <Eigen/Geometry>
+#endif
+
+namespace pangolin
+{
+
+struct Geometry
+{
+    struct Element : public ManagedImage<uint8_t> {
+        Element() = default;
+        Element(Element&&) = default;
+        Element& operator=(Element&&) = default;
+
+        Element(size_t stride_bytes, size_t num_elements)
+            : ManagedImage<uint8_t>(stride_bytes, num_elements)
+        {}
+
+        using Attribute = std::variant<Image<float>,Image<uint32_t>,Image<uint16_t>,Image<uint8_t>>;
+        // "vertex", "rgb", "normal", "uv", "tris", "quads", ...
+        std::map<std::string, Attribute> attributes;
+    };
+
+    // Store vertices and attributes
+    std::map<std::string, Element> buffers;
+    // Stores index buffers for each sub-object
+    std::multimap<std::string, Element> objects;
+    // Stores pixmaps
+    std::map<std::string, TypedImage> textures;
+};
+
+pangolin::Geometry LoadGeometry(const std::string& filename);
+
+#ifdef HAVE_EIGEN
+inline Eigen::AlignedBox3f GetAxisAlignedBox(const Geometry& geom)
+{
+    Eigen::AlignedBox3f box;
+    box.setEmpty();
+
+    for(const auto& b : geom.buffers) {
+        const auto& it_vert = b.second.attributes.find("vertex");
+        if(it_vert != b.second.attributes.end()) {
+            const Image<float>& vs = std::get<Image<float>>(it_vert->second);
+            for(size_t i=0; i < vs.h; ++i) {
+                const Eigen::Map<const Eigen::Vector3f> v(vs.RowPtr(i));
+                box.extend(v);
+            }
+        }
+    }
+
+    return box;
+}
+#endif
+
+}
+
+#endif // PANGOLIN_GEOMETRY_H

third-party/DPVO/Pangolin/components/pango_geometry/include/pangolin/geometry/geometry_obj.h

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

third-party/DPVO/Pangolin/components/pango_geometry/include/pangolin/geometry/geometry_ply.h

@@ -0,0 +1,150 @@
+/* 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.
+ */
+
+#include <variant>
+#include <pangolin/platform.h>
+#include <pangolin/geometry/geometry.h>
+#include <pangolin/geometry/geometry.h>
+
+#include <fstream>
+#include <vector>
+#include <algorithm>
+
+namespace pangolin
+{
+
+#define PLY_GROUP_LIST(m)  m(PlyHeader) m(PlyFormat) m(PlyType)
+#define PLY_HEADER_LIST(m) m(ply) m(format) m(comment) m(property) m(element) m(end_header)
+#define PLY_FORMAT_LIST(m) m(ascii) m(binary_big_endian) m(binary_little_endian)
+#define PLY_TYPE_LIST(m)   m(char) m(uchar) m(short) m(ushort) m(int) m(uint) m(float) m(double) m(list) m(none)
+#define PLY_CTYPE_LIST(m)  m(int8_t) m(uint8_t) m(int16_t) m(uint16_t) m(int32_t) m(uint32_t) m(float) m(double) m(void*) m(void*)
+
+// Define Enums / strings
+enum PlyHeader {
+#define FORMAT_ENUM(x) PlyHeader_##x,
+    PLY_HEADER_LIST(FORMAT_ENUM)
+    PlyHeaderSize
+#undef FORMAT_ENUM
+};
+
+enum PlyFormat {
+#define FORMAT_ENUM(x) PlyFormat_##x,
+    PLY_FORMAT_LIST(FORMAT_ENUM)
+    PlyFormatSize
+#undef FORMAT_ENUM
+};
+
+enum PlyType {
+#define FORMAT_ENUM(x) PlyType_##x,
+    PLY_TYPE_LIST(FORMAT_ENUM)
+    PlyTypeSize
+#undef FORMAT_ENUM
+};
+const size_t PlyTypeSizeBytes[] = {
+#define FORMAT_ENUM(x) sizeof(x),
+    PLY_CTYPE_LIST(FORMAT_ENUM)
+#undef FORMAT_ENUM
+};
+
+struct PlyPropertyDetails
+{
+    std::string name;
+
+    // Type of property
+    PlyType type;
+
+    // Type of list index if a list, or 0 otherwise.
+    PlyType list_index_type;
+
+    // Offset from element start
+    size_t offset_bytes;
+
+    // Number of items in the list. 1 if not a list. -1 if unknown.
+    int num_items;
+
+    bool isList() const {
+        return list_index_type > 0;
+    }
+};
+
+struct PlyElementDetails
+{
+    std::string name;
+    int num_items;
+    int stride_bytes;
+    std::vector<PlyPropertyDetails> properties;
+
+    inline std::vector<PlyPropertyDetails>::iterator FindProperty(const std::string& name)
+    {
+        return std::find_if(properties.begin(), properties.end(),
+            [&name](const PlyPropertyDetails& p){ return p.name == name;}
+        );
+    }
+};
+
+struct PlyHeaderDetails
+{
+    PlyFormat format;
+    std::string version;
+    std::vector<PlyElementDetails> elements;
+
+    inline std::vector<PlyElementDetails>::iterator FindElement(const std::string& name)
+    {
+        return std::find_if(elements.begin(), elements.end(),
+            [&name](const PlyElementDetails& el){ return el.name == name;}
+        );
+    }
+};
+
+void ParsePlyHeader(PlyHeaderDetails& ply, std::istream& is);
+
+struct PlyBuffer
+{
+    size_t index_size_bytes;
+    size_t element_item_size_bytes;
+    std::vector<unsigned char> data;
+};
+
+void ParsePlyAscii(pangolin::Geometry& /*geom*/, const PlyHeaderDetails& /*ply*/, std::istream& /*is*/);
+
+// Convert Seperate "x","y","z" attributes into a single "vertex" attribute
+void StandardizeXyzToVertex(pangolin::Geometry& geom);
+
+// The Artec scanner saves with these attributes, for example
+void StandardizeMultiTextureFaceToXyzuv(pangolin::Geometry& geom);
+
+void Standardize(pangolin::Geometry& geom);
+
+void ParsePlyLE(pangolin::Geometry& geom, PlyHeaderDetails& ply, std::istream& is);
+
+void ParsePlyBE(pangolin::Geometry& /*geom*/, const PlyHeaderDetails& /*ply*/, std::istream& /*is*/);
+
+void AttachAssociatedTexturesPly(pangolin::Geometry& geom, const std::string& filename);
+
+pangolin::Geometry LoadGeometryPly(const std::string& filename);
+
+}