fdb148a938e069f29f1ee84c16b5db040cb743b8bffcc1ce2cfc429d88d8feea

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME)
+
+target_sources( ${COMPONENT}
+PRIVATE
+    ${CMAKE_CURRENT_LIST_DIR}/src/renderable.cpp
+)
+
+target_link_libraries(${COMPONENT} PUBLIC pango_opengl)
+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_scene/include/pangolin/scene/axis.h

@@ -0,0 +1,117 @@
+#pragma once
+
+#include <pangolin/gl/opengl_render_state.h>
+#include <pangolin/gl/viewport.h>
+#include <pangolin/gl/gldraw.h>
+
+#include <pangolin/scene/renderable.h>
+#include <pangolin/scene/interactive_index.h>
+
+#ifdef HAVE_EIGEN
+#  include <Eigen/Geometry>
+#endif
+
+namespace pangolin {
+
+struct Axis : public Renderable, public Interactive
+{
+    Axis()
+        : axis_length(1.0),
+          label_x(InteractiveIndex::I().Store(this)),
+          label_y(InteractiveIndex::I().Store(this)),
+          label_z(InteractiveIndex::I().Store(this))
+    {
+    }
+
+    void Render(const RenderParams&) override {
+        glColor4f(1,0,0,1);
+        glPushName(label_x.Id());
+        glDrawLine(0,0,0, axis_length,0,0);
+        glPopName();
+
+        glColor4f(0,1,0,1);
+        glPushName(label_y.Id());
+        glDrawLine(0,0,0, 0,axis_length,0);
+        glPopName();
+
+        glColor4f(0,0,1,1);
+        glPushName(label_z.Id());
+        glDrawLine(0,0,0, 0,0,axis_length);
+        glPopName();
+    }
+
+    bool Mouse(
+        int button,
+        const GLprecision /*win*/[3], const GLprecision /*obj*/[3], const GLprecision /*normal*/[3],
+        bool /*pressed*/, int button_state, int pickId
+    ) override
+    {
+        PANGOLIN_UNUSED(button);
+        PANGOLIN_UNUSED(button_state);
+        PANGOLIN_UNUSED(pickId);
+
+#ifdef HAVE_EIGEN
+        if((button == MouseWheelUp || button == MouseWheelDown) ) {
+            float scale = (button == MouseWheelUp) ? 0.01f : -0.01f;
+            if(button_state & KeyModifierShift) scale /= 10;
+
+            Eigen::Vector3d rot = Eigen::Vector3d::Zero();
+            Eigen::Vector3d xyz = Eigen::Vector3d::Zero();
+
+
+            if(button_state & KeyModifierCtrl) {
+                // rotate
+                if(pickId == label_x.Id()) {
+                    rot << 1,0,0;
+                }else if(pickId == label_y.Id()) {
+                    rot << 0,1,0;
+                }else if(pickId == label_z.Id()) {
+                    rot << 0,0,1;
+                }else{
+                    return false;
+                }
+            }else if(button_state & KeyModifierShift){
+                // translate
+                if(pickId == label_x.Id()) {
+                    xyz << 1,0,0;
+                }else if(pickId == label_y.Id()) {
+                    xyz << 0,1,0;
+                }else if(pickId == label_z.Id()) {
+                    xyz << 0,0,1;
+                }else{
+                    return false;
+                }
+            }else{
+                return false;
+            }
+
+            // old from new
+            Eigen::Matrix<double,4,4> T_on = Eigen::Matrix<double,4,4>::Identity();
+            T_on.block<3,3>(0,0) = Eigen::AngleAxis<double>(scale,rot).toRotationMatrix();
+            T_on.block<3,1>(0,3) = scale*xyz;
+
+            // Update
+            T_pc = (ToEigen<double>(T_pc) * T_on.inverse()).eval();
+
+            return true;
+        }
+#endif // HAVE_EIGEN
+
+        return false;
+    }
+
+    virtual bool MouseMotion(
+        const GLprecision /*win*/[3], const GLprecision /*obj*/[3], const GLprecision /*normal*/[3],
+        int /*button_state*/, int /*pickId*/
+    ) override
+    {
+        return false;
+    }
+
+    float axis_length;
+    const InteractiveIndex::Token label_x;
+    const InteractiveIndex::Token label_y;
+    const InteractiveIndex::Token label_z;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_scene/include/pangolin/scene/interactive.h

@@ -0,0 +1,69 @@
+/* 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/gl/glplatform.h>
+#include <pangolin/gl/opengl_render_state.h>
+
+namespace pangolin {
+
+
+struct Interactive
+{
+    static __thread GLuint current_id;
+
+    virtual ~Interactive() {}
+
+    virtual bool Mouse(
+        int button,
+        const GLprecision win[3], const GLprecision obj[3], const GLprecision normal[3],
+        bool pressed, int button_state, int pickId
+    )  = 0;
+
+    virtual bool MouseMotion(
+        const GLprecision win[3], const GLprecision obj[3], const GLprecision normal[3],
+        int button_state, int pickId
+    ) = 0;
+};
+
+struct RenderParams
+{
+    RenderParams()
+      : render_mode(GL_RENDER)
+    {
+    }
+
+    GLint render_mode;
+};
+
+struct Manipulator : public Interactive
+{
+    virtual void Render(const RenderParams& params) = 0;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_scene/include/pangolin/scene/interactive_index.h

@@ -0,0 +1,115 @@
+/* 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 <map>
+
+#include <pangolin/scene/interactive.h>
+
+namespace pangolin {
+
+class InteractiveIndex
+{
+public:
+    class Token
+    {
+    public:
+        friend class InteractiveIndex;
+
+        Token()
+            : id(0)
+        {
+        }
+
+        Token(Token&& o)
+            : id(o.id)
+        {
+            o.id = 0;
+        }
+
+        GLint Id() const
+        {
+            return id;
+        }
+
+        ~Token()
+        {
+            if(id) {
+                InteractiveIndex::I().Unstore(*this);
+            }
+        }
+
+    private:
+        Token(GLint id)
+            : id(id)
+        {
+        }
+
+
+        GLint id;
+    };
+
+    static InteractiveIndex& I()
+    {
+        static InteractiveIndex instance;
+        return instance;
+    }
+
+    Interactive* Find(GLuint id)
+    {
+        auto kv = index.find(id);
+        if(kv != index.end()) {
+            return kv->second;
+        }
+        return nullptr;
+    }
+
+    Token Store(Interactive* r)
+    {
+        index[next_id] = r;
+        return Token(next_id++);
+    }
+
+    void Unstore(Token& t)
+    {
+        index.erase(t.id);
+        t.id = 0;
+    }
+
+private:
+    // Private constructor.
+    InteractiveIndex()
+        : next_id(1)
+    {
+    }
+
+    GLint next_id;
+    std::map<GLint, Interactive*> index;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_scene/include/pangolin/scene/renderable.h

@@ -0,0 +1,79 @@
+/* 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 <memory>
+#include <map>
+#include <random>
+
+#include <pangolin/gl/opengl_render_state.h>
+#include <pangolin/scene/interactive.h>
+
+namespace pangolin {
+
+class Renderable
+{
+public:
+    using guid_t = GLuint;
+
+    static guid_t UniqueGuid();
+
+    Renderable(const std::weak_ptr<Renderable>& parent = std::weak_ptr<Renderable>());
+
+    virtual ~Renderable();
+
+    // Default implementation simply renders children.
+    virtual void Render(const RenderParams& params = RenderParams());
+
+    void RenderChildren(const RenderParams& params);
+
+    std::shared_ptr<Renderable> FindChild(guid_t guid);
+
+    Renderable& Add(const std::shared_ptr<Renderable>& child);
+
+    void Remove(const std::shared_ptr<Renderable>& child)
+    {
+        if(child) {
+            children.erase(child->guid);
+        }
+    }
+
+    // Renderable properties
+    const guid_t guid;
+    std::weak_ptr<Renderable> parent;
+    pangolin::OpenGlMatrix T_pc;
+    bool should_show;
+
+    // Children
+    std::map<guid_t, std::shared_ptr<Renderable>> children;
+
+    // Manipulator (handler, thing)
+    std::shared_ptr<Manipulator> manipulator;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_scene/include/pangolin/scene/scenehandler.h

@@ -0,0 +1,192 @@
+#pragma once
+
+#include <pangolin/handler/handler.h>
+#include <pangolin/scene/renderable.h>
+#include <pangolin/scene/interactive_index.h>
+
+namespace pangolin {
+
+inline void gluPickMatrix(
+    GLdouble x, GLdouble y,
+    GLdouble width, GLdouble height,
+    GLint viewport[4]
+) {
+    GLfloat m[16];
+    GLfloat sx, sy;
+    GLfloat tx, ty;
+    sx = viewport[2] / (GLfloat)width;
+    sy = viewport[3] / (GLfloat)height;
+    tx = (viewport[2] + 2.0f * (viewport[0] - (GLfloat)x)) / (GLfloat)width;
+    ty = (viewport[3] + 2.0f * (viewport[1] - (GLfloat)y)) / (GLfloat)height;
+#define M(row, col) m[col*4+row]
+    M(0, 0) = sx;
+    M(0, 1) = 0.0f;
+    M(0, 2) = 0.0f;
+    M(0, 3) = tx;
+    M(1, 0) = 0.0f;
+    M(1, 1) = sy;
+    M(1, 2) = 0.0f;
+    M(1, 3) = ty;
+    M(2, 0) = 0.0f;
+    M(2, 1) = 0.0f;
+    M(2, 2) = 1.0f;
+    M(2, 3) = 0.0f;
+    M(3, 0) = 0.0f;
+    M(3, 1) = 0.0f;
+    M(3, 2) = 0.0f;
+    M(3, 3) = 1.0f;
+#undef M
+    glMultMatrixf(m);
+}
+
+struct SelectedObject {
+
+  SelectedObject(const GLuint pickId, Interactive* const interactive)
+    : pickId(pickId), interactive(interactive) {}
+
+  GLuint pickId;
+  Interactive* interactive;
+};
+
+struct SceneHandler : public Handler3D
+{
+    SceneHandler(
+        Renderable& scene,
+        OpenGlRenderState& cam_state
+    ) : Handler3D(cam_state), scene(scene)
+    {
+
+    }
+
+    void ProcessHitBuffer(GLint hits, GLuint* buf, std::map<GLuint, SelectedObject>& hit_map )
+    {
+        for (int hit = 0; hit < hits; hit++)
+        {
+            // buf[0] is the amount of named objects
+            // buf[1] is the z distance
+            // buf[2] is an array of names (aka pickId) with length buf[0]
+            for(unsigned int name = 0; name < buf[0]; name++)
+            {
+                const int pickId = (buf + 3)[name];
+                hit_map.emplace(std::pair(buf[1],
+                                          SelectedObject(pickId, InteractiveIndex::I().Find(pickId))));
+            }
+            buf += buf[0] + 3;
+        }
+    }
+
+    void ComputeHits(pangolin::View& view,
+                     const pangolin::OpenGlRenderState& cam_state,
+                     int x, int y, int grab_width,
+                     std::map<GLuint, SelectedObject>& hit_objects )
+    {
+        // Get views viewport / modelview /projection
+        GLint viewport[4] = {view.v.l, view.v.b, view.v.w, view.v.h};
+        pangolin::OpenGlMatrix mv = cam_state.GetModelViewMatrix();
+        pangolin::OpenGlMatrix proj = cam_state.GetProjectionMatrix();
+
+        // Prepare hit buffer object
+        const unsigned int MAX_SEL_SIZE = 64;
+        GLuint vSelectBuf[MAX_SEL_SIZE];
+        glSelectBuffer(MAX_SEL_SIZE, vSelectBuf);
+
+        // Load and adjust modelview projection matrices
+        glMatrixMode(GL_PROJECTION);
+        glLoadIdentity();
+        gluPickMatrix(x, y, grab_width, grab_width, viewport);
+        proj.Multiply();
+        glMatrixMode(GL_MODELVIEW);
+        mv.Load();
+
+        // Render scenegraph in 'select' mode
+        glRenderMode(GL_SELECT);
+        glInitNames();
+        RenderParams select;
+        select.render_mode = GL_SELECT;
+        scene.Render(select);
+        glFlush();
+
+        GLint nHits = glRenderMode(GL_RENDER);
+        if (nHits > 0) {
+            ProcessHitBuffer(nHits, vSelectBuf, hit_objects);
+        }
+    }
+
+    void Mouse(pangolin::View& view, pangolin::MouseButton button,
+               int x, int y, bool pressed, int button_state)
+    {
+        GetPosNormal(view, x, y, p, Pw, Pc, n);
+        bool handled = false;
+
+        if (pressed) {
+            m_selected_objects.clear();
+            ComputeHits(view, *cam_state, x, y, 2*hwin+1, m_selected_objects);
+        }
+
+        for ( auto selected_object_it = m_selected_objects.begin();
+              !handled && selected_object_it != m_selected_objects.end();
+              selected_object_it++ )
+        {
+            Interactive* ir = dynamic_cast<Interactive*>(selected_object_it->second.interactive);
+            handled |= ir && ir->Mouse( button, p, Pw, n, pressed, button_state, selected_object_it->second.pickId);
+        }
+
+        if (!handled) {
+            Handler3D::Mouse(view, button, x, y, pressed, button_state);
+        }
+    }
+
+    void MouseMotion(pangolin::View& view, int x, int y, int button_state)
+    {
+        GetPosNormal(view, x, y, p, Pw, Pc, n);
+        bool handled = false;
+
+        for ( auto selected_object_it = m_selected_objects.begin();
+              !handled && selected_object_it != m_selected_objects.end();
+              selected_object_it++ )
+        {
+            Interactive* ir = dynamic_cast<Interactive*>(selected_object_it->second.interactive);
+            handled |= ir && ir->MouseMotion( p, Pw, n, button_state, selected_object_it->second.pickId);
+        }
+        if (!handled) {
+            pangolin::Handler3D::MouseMotion(view, x, y, button_state);
+        }
+    }
+
+    void Special(pangolin::View& view, pangolin::InputSpecial inType,
+                 float x, float y, float p1, float p2, float p3, float p4,
+                 int button_state)
+    {
+        GetPosNormal(view, (int)x, (int)y, p, Pw, Pc, n);
+
+        bool handled = false;
+
+        if (inType == pangolin::InputSpecialScroll)
+        {
+            m_selected_objects.clear();
+            ComputeHits(view, *cam_state, (int)x, (int)y, 2*hwin+1, m_selected_objects);
+
+            const MouseButton button = p2 > 0 ? MouseWheelUp : MouseWheelDown;
+
+            for ( auto selected_object_it = m_selected_objects.begin();
+                  !handled && selected_object_it != m_selected_objects.end();
+                  selected_object_it++ )
+            {
+                Interactive* ir = dynamic_cast<Interactive*>(selected_object_it->second.interactive);
+                handled |= ir && ir->Mouse( button, p, Pw, n, true, button_state, selected_object_it->second.pickId);
+            }
+        }
+
+        if (!handled) {
+            pangolin::Handler3D::Special(view, inType, x, y,
+                                         p1, p2, p3, p4, button_state);
+        }
+    }
+
+    // map from z distance to interactive element with pick id
+    std::map<GLuint, SelectedObject> m_selected_objects;
+    Renderable& scene;
+    unsigned int grab_width;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_scene/include/pangolin/scene/tree.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <map>
+#include <pangolin/gl/opengl_render_state.h>
+
+namespace pangolin {
+
+template<typename T, typename TEdge>
+struct TreeNode
+{
+    struct Edge
+    {
+        TEdge parent_child;
+        TreeNode node;
+    };
+
+    T item;
+    std::vector<Edge> edges;
+};
+
+template<typename T, typename TEdge>
+using NodeFunction = std::function<void(TreeNode<T,TEdge>&,const TEdge&)>;
+
+//template<typename T, typename TEdge>
+//void VisitDepthFirst(TreeNode<T,TEdge>& node, const NodeFunction<T,TEdge>& func, const TEdge& T_root_node = TEdge())
+//{
+//    func(node, T_root_node);
+//    for(auto& e : node.edges) {
+//        const TEdge T_root_child = T_root_node * e.parent_child;
+//        VisitDepthFirst(e.node, func, T_root_child);
+//    }
+//}
+
+//void Eg()
+//{
+//    using RenderNode = TreeNode<std::shared_ptr<Renderable>,OpenGlMatrix>;
+
+//    RenderNode root;
+//    VisitDepthFirst<std::shared_ptr<Renderable>,OpenGlMatrix>(
+//        root, [](RenderNode& node, const OpenGlMatrix& T_root_node) {
+//        if(node.item) {
+//            node.item->DoRender();
+//        }
+//    }, IdentityMatrix());
+
+//}
+
+
+}

third-party/DPVO/Pangolin/components/pango_scene/src/renderable.cpp

@@ -0,0 +1,66 @@
+#include <pangolin/scene/renderable.h>
+
+namespace pangolin {
+
+
+Renderable::guid_t Renderable::UniqueGuid()
+{
+    static std::random_device rd;
+    static std::mt19937 gen(rd());
+    return (guid_t)gen();
+}
+
+Renderable::Renderable(const std::weak_ptr<Renderable>& parent)
+    : guid(UniqueGuid()), parent(parent), T_pc(IdentityMatrix()), should_show(true)
+{
+}
+
+Renderable::~Renderable()
+{
+}
+
+// Default implementation simply renders children.
+void Renderable::Render(const RenderParams& params) {
+    RenderChildren(params);
+}
+
+void Renderable::RenderChildren(const RenderParams& params)
+{
+    for(auto& p : children) {
+        Renderable& r = *p.second;
+        if(r.should_show) {
+            glPushMatrix();
+            r.T_pc.Multiply();
+            r.Render(params);
+            if(r.manipulator) {
+                r.manipulator->Render(params);
+            }
+            glPopMatrix();
+        }
+    }
+}
+
+std::shared_ptr<Renderable> Renderable::FindChild(guid_t guid)
+{
+    auto o = children.find(guid);
+    if(o != children.end()) {
+        return o->second;
+    }
+
+    for(auto& kv : children ) {
+        std::shared_ptr<Renderable> c = kv.second->FindChild(guid);
+        if(c) return c;
+    }
+
+    return std::shared_ptr<Renderable>();
+}
+
+Renderable& Renderable::Add(const std::shared_ptr<Renderable>& child)
+{
+    if(child) {
+        children[child->guid] = child;
+    };
+    return *this;
+}
+
+}

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

@@ -0,0 +1,15 @@
+get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME)
+
+target_sources( ${COMPONENT}
+PRIVATE
+    ${CMAKE_CURRENT_LIST_DIR}/src/video_viewer.cpp
+)
+
+target_link_libraries(${COMPONENT} PUBLIC pango_display pango_video)
+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_tools/include/pangolin/tools/video_viewer.h

@@ -0,0 +1,106 @@
+#pragma once
+
+#include <pangolin/platform.h>
+#include <pangolin/windowing/window.h>
+#include <pangolin/video/video_input.h>
+
+#include <functional>
+#include <mutex>
+#include <string>
+#include <thread>
+
+namespace pangolin
+{
+
+PANGOLIN_EXPORT
+class VideoViewer
+{
+public:
+    typedef std::function<void(const unsigned char* data,
+                               const std::vector<Image<unsigned char> >& images,
+                               const picojson::value& properties)> FrameChangedCallbackFn;
+
+    static constexpr int FRAME_SKIP = 30;
+
+    VideoViewer(const std::string& window_name, const std::string& input_uri, const std::string& output_uri = "video.pango" );
+    VideoViewer(const VideoViewer&) = delete;
+
+    virtual ~VideoViewer();
+
+    void Run();
+    void RunAsync();
+
+    void Quit();
+    void QuitAndWait();
+
+    inline int TotalFrames() const
+    {
+        return video_playback ? video_playback->GetTotalFrames() : std::numeric_limits<int>::max();
+    }
+
+    // Control playback
+    void OpenInput(const std::string& input_uri);
+    void CloseInput();
+
+    // Control recording
+    void Record();
+    void RecordOneFrame();
+    void StopRecording();
+
+    // Useful for user-control
+    void TogglePlay();
+    void ToggleRecord();
+    void ToggleDiscardBufferedFrames();
+    void ToggleWaitForFrames();
+    void SetDiscardBufferedFrames(bool new_state);
+    void SetWaitForFrames(bool new_state);
+    void Skip(int frames);
+    bool ChangeExposure(int delta_us);
+    bool ChangeGain(float delta);
+    void SetActiveCamera(int delta);
+    void DrawEveryNFrames(int n);
+
+
+    // Register to be notified of new image data
+    void SetFrameChangedCallback(FrameChangedCallbackFn cb);
+
+    void WaitUntilExit();
+
+
+    VideoInput& Video() {return video;}
+    const VideoInput& Video() const {return video;}
+
+    void SetRecordNthFrame(int record_nth_frame_) {
+      record_nth_frame = record_nth_frame_;
+    }
+
+
+protected:
+    void RegisterDefaultKeyShortcutsAndPangoVariables();
+
+    std::mutex control_mutex;
+    std::string window_name;
+    std::thread vv_thread;
+
+    VideoInput video;
+    VideoPlaybackInterface* video_playback;
+    VideoInterface* video_interface;
+
+    std::string output_uri;
+
+    int current_frame;
+    int grab_until;
+    int record_nth_frame;
+    int draw_nth_frame;
+    bool video_grab_wait;
+    bool video_grab_newest;
+    bool should_run;
+    uint16_t active_cam;
+
+    FrameChangedCallbackFn frame_changed_callback;
+};
+
+
+void PANGOLIN_EXPORT RunVideoViewerUI(const std::string& input_uri, const std::string& output_uri);
+
+}

third-party/DPVO/Pangolin/components/pango_tools/src/video_viewer.cpp

@@ -0,0 +1,452 @@
+#include <pangolin/tools/video_viewer.h>
+
+#include <pangolin/gl/gldraw.h>
+#include <pangolin/gl/glpixformat.h>
+#include <pangolin/gl/gltexturecache.h>
+#include <pangolin/display/image_view.h>
+#include <pangolin/display/widgets.h>
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/utils/sigstate.h>
+#include <pangolin/video/video_input.h>
+#include <pangolin/handler/handler_image.h>
+#include <pangolin/var/var.h>
+
+
+namespace pangolin
+{
+
+void videoviewer_signal_quit(int) {
+    pango_print_info("Caught signal. Program will exit after any IO is complete.\n");
+    pangolin::QuitAll();
+}
+
+VideoViewer::VideoViewer(const std::string& window_name, const std::string& input_uri, const std::string& output_uri)
+    : window_name(window_name),
+      video_playback(nullptr),
+      video_interface(nullptr),
+      output_uri(output_uri),
+      current_frame(-1),
+      grab_until(std::numeric_limits<int>::max()),
+      record_nth_frame(1),
+      draw_nth_frame(1),
+      video_grab_wait(true),
+      video_grab_newest(false),
+      should_run(true),
+      active_cam(0)
+{
+    pangolin::Var<int>::Attach("ui.frame", current_frame);
+    pangolin::Var<int>::Attach("ui.record_nth_frame", record_nth_frame);
+    pangolin::Var<int>::Attach("ui.draw_nth_frame", draw_nth_frame);
+
+
+    if(!input_uri.empty()) {
+        OpenInput(input_uri);
+    }
+}
+
+VideoViewer::~VideoViewer()
+{
+    QuitAndWait();
+
+}
+
+void VideoViewer::Quit()
+{
+    // Signal any running thread to stop
+    should_run = false;
+}
+
+void VideoViewer::QuitAndWait()
+{
+    Quit();
+
+    if(vv_thread.joinable()) {
+        vv_thread.join();
+    }
+}
+
+void VideoViewer::RunAsync()
+{
+    if(!should_run) {
+        // Make sure any other thread has finished
+        if(vv_thread.joinable()) {
+            vv_thread.join();
+        }
+
+        // Launch in another thread
+        vv_thread = std::thread(&VideoViewer::Run, this);
+    }
+}
+
+void VideoViewer::Run()
+{
+    should_run = true;
+
+    /////////////////////////////////////////////////////////////////////////
+    /// Register pangolin variables
+    /////////////////////////////////////////////////////////////////////////
+
+    std::unique_ptr<unsigned char[]> buffer(new unsigned char[video.SizeBytes()+1]);
+
+    const int slider_size = (TotalFrames() < std::numeric_limits<int>::max() ? 20 : 0);
+
+    // Create OpenGL window - guess sensible dimensions
+    pangolin::CreateWindowAndBind( window_name,
+        (int)(video.Width() * video.Streams().size()),
+        (int)(video.Height() + slider_size)
+    );
+    glEnable (GL_BLEND);
+    glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    pangolin::Var<int> frame("ui.frame");
+    pangolin::Slider frame_slider("frame", frame.Ref() );
+
+    if(video_playback && TotalFrames() < std::numeric_limits<int>::max())
+    {
+        // frame_slider should be added first so that it can be rendered correctly.
+        pangolin::DisplayBase().AddDisplay(frame_slider);
+        frame_slider.SetBounds(0.0, pangolin::Attach::Pix(slider_size), 0.0, 1.0);
+    }
+
+    pangolin::View& container = pangolin::Display("streams");
+    container.SetLayout(pangolin::LayoutEqual)
+             .SetBounds(pangolin::Attach::Pix(slider_size), 1.0, 0.0, 1.0);
+
+    std::vector<ImageView> stream_views(video.Streams().size());
+    for(auto& sv : stream_views) {
+        container.AddDisplay(sv);
+    }
+
+    pangolin::View& record_graphic = pangolin::Display("record_glyph").
+            SetBounds(pangolin::Attach::Pix(-28),1.0f, pangolin::Attach::Pix(-28), 1.0f);
+    record_graphic.extern_draw_function = [&](pangolin::View& v){
+        if(video.IsRecording()) {
+            v.ActivatePixelOrthographic();
+            pangolin::glRecordGraphic(14.0f, 14.0f, 7.0f);
+        }
+    };
+
+    std::vector<pangolin::Image<unsigned char> > images;
+
+    /////////////////////////////////////////////////////////////////////////
+    /// Register key shortcuts
+    /////////////////////////////////////////////////////////////////////////
+
+    RegisterDefaultKeyShortcutsAndPangoVariables();
+
+    const char show_hide_keys[]  = {'1','2','3','4','5','6','7','8','9'};
+    const char screenshot_keys[] = {'!','@','#','$','%','^','&','*','('};
+
+    // Show/hide streams
+    for(size_t v=0; v < container.NumChildren() && v < 9; v++) {
+        pangolin::RegisterKeyPressCallback(show_hide_keys[v], [v,&container](){
+            container[v].ToggleShow();
+        } );
+        pangolin::RegisterKeyPressCallback(screenshot_keys[v], [this,v,&images](){
+            if(v < images.size() && images[v].ptr) {
+                try{
+                    pangolin::SaveImage(
+                        images[v], video.Streams()[v].PixFormat(),
+                        pangolin::MakeUniqueFilename("capture.png")
+                    );
+                }catch(const std::exception& e){
+                    pango_print_error("Unable to save frame: %s\n", e.what());
+                }
+            }
+        } );
+    }
+
+    video.Start();
+
+    // Stream and display video
+    while(should_run && !pangolin::ShouldQuit())
+    {
+        glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
+        glColor3f(1.0f, 1.0f, 1.0f);
+
+        {
+            std::lock_guard<std::mutex> lock(control_mutex);
+
+            if(frame.GuiChanged()) {
+                if(video_playback) {
+                    frame = video_playback->Seek(frame) -1;
+                }
+                grab_until = frame + 1;
+            }
+
+            if ( frame < grab_until && video.Grab(&buffer[0], images, video_grab_wait, video_grab_newest)) {
+                frame = frame +1;
+
+                if(frame_changed_callback) {
+                    frame_changed_callback(buffer.get(), images, GetVideoFrameProperties(video_interface));
+                }
+
+                // Update images
+                if((frame-1) % draw_nth_frame == 0) {
+                    for(unsigned int i=0; i<images.size(); ++i)
+                        if(stream_views[i].IsShown()) {
+                            stream_views[i].SetImage(images[i], pangolin::GlPixFormat(video.Streams()[i].PixFormat() ));
+                        }
+                }
+            }
+        }
+
+        // leave in pixel orthographic for slider to render.
+        pangolin::DisplayBase().ActivatePixelOrthographic();
+        pangolin::FinishFrame();
+    }
+
+    pangolin::DestroyWindow(window_name);
+}
+
+void VideoViewer::RegisterDefaultKeyShortcutsAndPangoVariables()
+{
+    pangolin::RegisterKeyPressCallback(' ', [this](){TogglePlay();} );
+    pangolin::RegisterKeyPressCallback('r', [this](){ToggleRecord();});
+    pangolin::RegisterKeyPressCallback('w', [this](){ToggleWaitForFrames();} );
+    pangolin::RegisterKeyPressCallback('d', [this](){ToggleDiscardBufferedFrames();} );
+    pangolin::RegisterKeyPressCallback(',', [this](){Skip(-1);} );
+    pangolin::RegisterKeyPressCallback('.', [this](){Skip(+1);} );
+    pangolin::RegisterKeyPressCallback('<', [this](){Skip(-FRAME_SKIP);} );
+    pangolin::RegisterKeyPressCallback('>', [this](){Skip(+FRAME_SKIP);} );
+    pangolin::RegisterKeyPressCallback('0', [this](){RecordOneFrame();} );
+    pangolin::RegisterKeyPressCallback('E', [this](){ChangeExposure(1000);} );
+    pangolin::RegisterKeyPressCallback('e', [this](){ChangeExposure(-1000);} );
+    pangolin::RegisterKeyPressCallback('G', [this](){ChangeGain(1);} );
+    pangolin::RegisterKeyPressCallback('g', [this](){ChangeGain(-1);} );
+    pangolin::RegisterKeyPressCallback('c', [this](){SetActiveCamera(+1);} );
+}
+
+void VideoViewer::OpenInput(const std::string& input_uri)
+{
+    std::lock_guard<std::mutex> lock(control_mutex);
+    video.Open(input_uri, output_uri);
+
+    // Output details of video stream
+    for(size_t s = 0; s < video.Streams().size(); ++s) {
+        const pangolin::StreamInfo& si = video.Streams()[s];
+        std::cout << FormatString(
+            "Stream %: % x % % (pitch: % bytes)",
+            s, si.Width(), si.Height(), si.PixFormat().format, si.Pitch()
+        ) << std::endl;
+    }
+
+    if(video.Streams().size() == 0) {
+        pango_print_error("No video streams from device.\n");
+        return;
+    }
+
+    video_playback = pangolin::FindFirstMatchingVideoInterface<pangolin::VideoPlaybackInterface>(video);
+    video_interface = pangolin::FindFirstMatchingVideoInterface<pangolin::VideoInterface>(video);
+
+    if(TotalFrames() < std::numeric_limits<int>::max() ) {
+        std::cout << "Video length: " << TotalFrames() << " frames" << std::endl;
+        grab_until = 0;
+    }
+
+    pangolin::Var<int> frame("ui.frame");
+    frame.Meta().range[0] = 0;
+    frame.Meta().range[1] = TotalFrames()-1;
+}
+
+void VideoViewer::CloseInput()
+{
+    std::lock_guard<std::mutex> lock(control_mutex);
+    video.Close();
+}
+
+void VideoViewer::Record()
+{
+    std::lock_guard<std::mutex> lock(control_mutex);
+    if(!video.IsRecording()) {
+        video.Record();
+    }
+}
+
+void VideoViewer::RecordOneFrame()
+{
+    std::lock_guard<std::mutex> lock(control_mutex);
+    video.RecordOneFrame();
+}
+
+void VideoViewer::StopRecording()
+{
+    std::lock_guard<std::mutex> lock(control_mutex);
+    if(video.IsRecording()) {
+        video.Stop();
+    }
+}
+
+void VideoViewer::TogglePlay()
+{
+    std::lock_guard<std::mutex> lock(control_mutex);
+    grab_until = (current_frame < grab_until) ? current_frame: std::numeric_limits<int>::max();
+}
+
+void VideoViewer::ToggleRecord()
+{
+    std::lock_guard<std::mutex> lock(control_mutex);
+    if(!video.IsRecording()) {
+        video.SetTimelapse( static_cast<size_t>(record_nth_frame) );
+        video.Record();
+        pango_print_info("Started Recording.\n");
+    }else{
+        video.Stop();
+        pango_print_info("Finished recording.\n");
+    }
+    fflush(stdout);
+}
+
+void VideoViewer::ToggleDiscardBufferedFrames()
+{
+    std::lock_guard<std::mutex> lock(control_mutex);
+    video_grab_newest = !video_grab_newest;
+    if(video_grab_newest) {
+        pango_print_info("Discarding old frames.\n");
+    }else{
+        pango_print_info("Not discarding old frames.\n");
+    }
+}
+
+void VideoViewer::ToggleWaitForFrames()
+{
+    std::lock_guard<std::mutex> lock(control_mutex);
+    video_grab_wait = !video_grab_wait;
+    if(video_grab_wait) {
+        pango_print_info("Gui wait's for video frame.\n");
+    }else{
+        pango_print_info("Gui doesn't wait for video frame.\n");
+    }
+}
+
+void VideoViewer::SetDiscardBufferedFrames(bool new_state)
+{
+    std::lock_guard<std::mutex> lock(control_mutex);
+    video_grab_newest = new_state;
+    if(video_grab_newest) {
+        pango_print_info("Discarding old frames.\n");
+    }else{
+        pango_print_info("Not discarding old frames.\n");
+    }
+}
+
+
+void VideoViewer::DrawEveryNFrames(int n)
+{
+    if(n <= 0) {
+        pango_print_warn("Cannot draw every %d frames. Ignoring request.\n",n);
+        return;
+    }
+
+    if(n != draw_nth_frame && n == 1)
+        pango_print_info("Drawing every frame.\n");
+    if(n != draw_nth_frame && n > 1)
+        pango_print_info("Drawing one in every %d frames.\n",n);
+
+    draw_nth_frame=n;
+}
+
+
+
+void VideoViewer::SetWaitForFrames(bool new_state)
+{
+    std::lock_guard<std::mutex> lock(control_mutex);
+    video_grab_wait = new_state;
+    if(video_grab_wait) {
+        pango_print_info("Gui wait's for video frame.\n");
+    }else{
+        pango_print_info("Gui doesn't wait for video frame.\n");
+    }
+}
+
+void VideoViewer::Skip(int frames)
+{
+    std::lock_guard<std::mutex> lock(control_mutex);
+
+    if(video_playback) {
+        const int next_frame = current_frame + frames;
+        if (next_frame >= 0) {
+            current_frame = video_playback->Seek(next_frame) -1;
+            grab_until = current_frame + 1;
+        }
+    }else{
+        if(frames >= 0) {
+            grab_until = current_frame + frames;
+        }else{
+            pango_print_warn("Unable to skip backward.");
+        }
+    }
+
+}
+
+bool VideoViewer::ChangeExposure(int delta_us)
+{
+    std::lock_guard<std::mutex> lock(control_mutex);
+
+    std::vector<pangolin::GenicamVideoInterface*> ifs = FindMatchingVideoInterfaces<pangolin::GenicamVideoInterface>(video);
+    std::string exposure_time;
+    if (ifs[active_cam]->GetParameter("ExposureTime",exposure_time))
+    {
+            return false;
+    }
+
+    int exp = atoi(exposure_time.c_str());
+
+    return ifs[active_cam]->SetParameter("ExposureTime", std::to_string(exp+delta_us));
+}
+
+bool VideoViewer::ChangeGain(float delta)
+{
+    std::lock_guard<std::mutex> lock(control_mutex);
+
+    std::vector<pangolin::GenicamVideoInterface*> ifs = FindMatchingVideoInterfaces<pangolin::GenicamVideoInterface>(video);
+
+    std::string gain_string;
+    if (!ifs[active_cam]->GetParameter("Gain", gain_string))
+    {
+        return false;
+    }
+    double gain = atoi(gain_string.c_str());
+
+    return ifs[active_cam]->SetParameter("Gain", std::to_string(gain+delta));
+}
+
+
+void VideoViewer::SetActiveCamera(int delta)
+{
+    std::lock_guard<std::mutex> lock(control_mutex);
+
+    std::vector<pangolin::GenicamVideoInterface*> ifs = FindMatchingVideoInterfaces<pangolin::GenicamVideoInterface>(video);
+
+    active_cam += delta;
+
+    if(active_cam >= ifs.size()) {active_cam = 0;}
+}
+
+
+void VideoViewer::SetFrameChangedCallback(FrameChangedCallbackFn cb)
+{
+    std::lock_guard<std::mutex> lock(control_mutex);
+    frame_changed_callback=cb;
+}
+
+
+
+void VideoViewer::WaitUntilExit()
+{
+    if(vv_thread.joinable()) {
+        vv_thread.join();
+    }
+}
+
+
+void RunVideoViewerUI(const std::string& input_uri, const std::string& output_uri)
+{
+    RegisterNewSigCallback(videoviewer_signal_quit, nullptr, SIGINT);
+    RegisterNewSigCallback(videoviewer_signal_quit, nullptr, SIGTERM);
+
+    VideoViewer vv("VideoViewer", input_uri, output_uri);
+    vv.Run();
+}
+
+}

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

@@ -0,0 +1,22 @@
+get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME)
+
+target_sources( ${COMPONENT}
+PRIVATE
+    ${CMAKE_CURRENT_LIST_DIR}/src/vars.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/varstate.cpp
+)
+
+target_link_libraries(${COMPONENT} PUBLIC pango_core)
+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}
+)
+
+if(BUILD_TESTS)
+    add_executable(test_vars ${CMAKE_CURRENT_LIST_DIR}/tests/test_all.cpp)
+    target_link_libraries(test_vars PRIVATE Catch2::Catch2 ${COMPONENT})
+    catch_discover_tests(test_vars)
+endif()

third-party/DPVO/Pangolin/components/pango_vars/include/pangolin/var/var.h

@@ -0,0 +1,172 @@
+/* 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 <stdexcept>
+#include <string.h>
+#include <cmath>
+
+#include <pangolin/utils/is_streamable.h>
+#include <pangolin/var/varvalue.h>
+#include <pangolin/var/varwrapper.h>
+#include <pangolin/var/varstate.h>
+
+namespace pangolin
+{
+
+template<typename T>
+class Var
+{
+public:
+    static T& Attach( T& variable, const VarMeta& meta ) {
+        VarState::I().AttachVar<T&>(variable,meta);
+        return variable;
+    }
+
+    static T& Attach( const std::string& name, T& variable )
+    {
+        return Attach(variable, VarMeta(name));
+    }
+
+    static T& Attach(
+        const std::string& name, T& variable,
+        double min, double max, bool logscale = false
+    ) {
+        return Attach(variable, VarMeta(name, min, max, DefaultIncrementForType<T>(min,max), META_FLAG_NONE, logscale));
+    }
+
+    static T& Attach( const std::string& name, T& variable, int flags )
+    {
+        return Attach(variable, VarMeta(name, 0., 0., 0., flags) );
+    }
+
+    static T& Attach( const std::string& name, T& variable, bool toggle )
+    {
+        return Attach(variable, VarMeta(name, 0., 0., 0., toggle ? META_FLAG_TOGGLE : META_FLAG_NONE) );
+    }
+
+    ~Var()
+    {
+    }
+
+    Var( const std::shared_ptr<VarValueGeneric>& v )
+        : var(InitialiseFromPreviouslyTypedVar<T>(v))
+    {
+    }
+
+    Var( const T& value, const VarMeta& meta )
+        : var(InitialiseFromPreviouslyTypedVar<T>(VarState::I().GetOrCreateVar<T>(value, meta)))
+    {
+    }
+
+    Var( const std::string& name, const T& value = T() )
+        : Var(value, VarMeta(name))
+    {
+    }
+
+    Var(const std::string& name, const T& value, int flags)
+        : Var(value, VarMeta(name, 0., 0.,0., flags))
+    {
+    }
+
+    Var(const std::string& name, const T& value, bool toggle)
+        : Var(value, VarMeta(name, 0., 0.,0., toggle ? META_FLAG_TOGGLE : META_FLAG_NONE))
+    {
+    }
+
+    Var(const std::string& name, const T& value,
+        double min, double max, bool logscale = false)
+        : Var(value, VarMeta(name, min, max, DefaultIncrementForType<T>(min,max), META_FLAG_NONE, logscale))
+    {
+    }
+
+    void Reset()
+    {
+        var->Reset();
+    }
+
+    void Detach()
+    {
+        VarState::I().Remove(Meta().full_name);
+    }
+
+    const T& Get() const
+    {
+        return var->Get();
+    }
+
+    operator const T& () const
+    {
+        return Get();
+    }
+
+    const T* operator->()
+    {
+        return &(var->Get());
+    }
+
+    Var<T>& operator=(const T& val)
+    {
+        var->Set(val);
+        return *this;
+    }
+
+    Var<T>& operator=(const Var<T>& v)
+    {
+        var->Set(v.var->Get());
+        return *this;
+    }
+
+    VarMeta& Meta()
+    {
+        return var->Meta();
+    }
+
+    bool GuiChanged()
+    {
+        return Meta().gui_changed && !(Meta().gui_changed = false);
+    }
+
+    std::shared_ptr<VarValueT<T>> Ref()
+    {
+        return var;
+    }
+
+    // Holds reference to stored variable object
+    // N.B. mutable because it is a cached value and Get() is advertised as const.
+    mutable std::shared_ptr<VarValueT<T>> var;
+};
+
+template<typename T>
+inline std::ostream& operator<<(std::ostream& s, Var<T>& rhs)
+{
+    s << rhs.operator const T &();
+    return s;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_vars/include/pangolin/var/varextra.h

@@ -0,0 +1,92 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/platform.h>
+#include <pangolin/var/var.h>
+#include <vector>
+
+namespace pangolin
+{
+
+PANGOLIN_EXPORT
+void ParseVarsFile(const std::string& filename);
+
+PANGOLIN_EXPORT
+void LoadJsonFile(const std::string& filename, const std::string& prefix="");
+
+PANGOLIN_EXPORT
+void SaveJsonFile(const std::string& filename, const std::string& prefix="");
+
+template<typename T>
+struct SetVarFunctor
+{
+    SetVarFunctor(const std::string& name, T val) : varName(name), setVal(val) {}
+    void operator()() { Var<T>(varName).Ref()->Set(setVal); }
+    std::string varName;
+    T setVal;
+};
+
+struct ToggleVarFunctor
+{
+    ToggleVarFunctor(const std::string& name) : varName(name) {}
+    void operator()() { Var<bool> val(varName,false); val = !val; }
+    std::string varName;
+};
+
+inline bool Pushed(bool& button)
+{
+    return button && !(button = false);
+}
+
+inline bool Pushed(Var<bool>& button)
+{
+    return (bool)button && !(button = false);
+}
+
+// Just forward to the static method
+// The benefit here is that we can get type inference
+template<typename T, typename... Ts>
+T& AttachVar(const std::string& name, T& var, Ts... ts)
+{
+    return Var<T>::Attach(name, var, ts...);
+}
+
+inline void DetachVarByName(const std::string& name)
+{
+    VarState::I().Remove(name);
+}
+
+template<typename T>
+void DetachVar(const T& value)
+{
+    auto var = VarState::I().GetByReference<T>(value);
+    if(var) DetachVarByName(var->Meta().full_name);
+}
+
+}

third-party/DPVO/Pangolin/components/pango_vars/include/pangolin/var/varinit.h

@@ -0,0 +1,71 @@
+#include <pangolin/var/varvalue.h>
+#include <cstring>
+
+namespace pangolin {
+
+template<typename T>
+inline double DefaultIncrementForType(double min, double max) {
+    return (std::is_integral<T>::value) ? 1.0 : (max - min) / 100.0;
+}
+
+template <typename T, typename S>
+typename std::enable_if<is_streamable<S>::value && is_streamable<T>::value, std::shared_ptr<VarValueT<T>>>::type
+Wrapped(const std::shared_ptr<VarValueT<S>>& src) noexcept
+{
+    return std::make_shared<VarWrapper<T,S>>(src);
+}
+
+template <typename T, typename S>
+typename std::enable_if<!(is_streamable<S>::value && is_streamable<T>::value), std::shared_ptr<VarValueT<T>>>::type
+Wrapped(const std::shared_ptr<VarValueT<S>>&)
+{
+    throw std::runtime_error("Unable to wrap Var");
+}
+
+template<typename T>
+typename std::enable_if<!is_streamable<T>::value, std::shared_ptr<VarValue<T>>>::type
+InitialiseFromPreviouslyGenericVar(const std::shared_ptr<VarValueGeneric>& v)
+{
+    // We can't initialize this variable from a 'generic' string type.
+    throw BadInputException();
+}
+template<typename T>
+typename std::enable_if<is_streamable<T>::value, std::shared_ptr<VarValue<T>>>::type
+InitialiseFromPreviouslyGenericVar(const std::shared_ptr<VarValueGeneric>& v)
+{
+    return std::make_shared<VarValue<T>>( Convert<T,std::string>::Do( v->str->Get() ) );
+}
+
+// Initialise from existing variable, obtain data / accessor
+template<typename T>
+std::shared_ptr<VarValueT<T>> InitialiseFromPreviouslyTypedVar(const std::shared_ptr<VarValueGeneric>& v)
+{
+    // Macro hack to prevent code duplication
+#   define PANGO_VAR_TYPES(x)                            \
+    x(bool) x(int8_t) x(uint8_t) x(int16_t) x(uint16_t)  \
+    x(int32_t) x(uint32_t) x(int64_t) x(uint64_t)        \
+    x(float) x(double)
+
+    if( !strcmp(v->TypeId(), typeid(T).name()) ) {
+        // Same type
+        return std::dynamic_pointer_cast<VarValueT<T>>(v);
+    }else if( std::is_same<T,std::string>::value ) {
+        // Use types string accessor
+        return std::dynamic_pointer_cast<VarValueT<T>>(v->str);
+    }else
+#       define PANGO_CHECK_WRAP(x)                                                       \
+    if( !strcmp(v->TypeId(), typeid(x).name() ) ) {                                      \
+        std::shared_ptr<VarValueT<x>> xval = std::dynamic_pointer_cast<VarValueT<x>>(v); \
+        return Wrapped<T,x>(xval);                                                       \
+    }else
+    PANGO_VAR_TYPES(PANGO_CHECK_WRAP)
+    {
+        // other types: have to go via string
+        // Wrapper, owned by this object
+        return Wrapped<T,std::string>(v->str);
+    }
+#undef PANGO_VAR_TYPES
+#undef PANGO_CHECK_WRAP
+}
+
+}

third-party/DPVO/Pangolin/components/pango_vars/include/pangolin/var/varstate.h

@@ -0,0 +1,269 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <map>
+#include <vector>
+#include <memory>
+#include <any>
+#include <cassert>
+#include <pangolin/platform.h>
+#include <pangolin/var/varvalue.h>
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/utils/signal_slot.h>
+#include <pangolin/var/varinit.h>
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT VarState
+{
+public:
+    static VarState& I();
+
+    VarState();
+    ~VarState();
+
+    /// \returns true iff a pangolin var with key name \param key exists in the index.
+    bool Exists(const std::string& key) const;
+
+    /// Register a user defined variable in memory into the VarState index.
+    /// Note that the user memory must have a lifetime which exceeds all accesses through
+    /// pangolin::Vars. The parameter remains owned by the user who must take care of
+    /// appropriate deallocation.
+    ///
+    /// \tparam T The type of \param variable to register
+    /// \param variable The variable to make available in the VarState index.
+    /// \param meta Meta information about the variable that will allow tools to introspect
+    ///             and modify it. In particular, \param meta.name is the user accessible name
+    ///             and is also used as input to lookup any Var in the index.
+    template<typename T>
+    std::shared_ptr<VarValueGeneric> AttachVar( T& variable, const VarMeta& meta );
+
+    /// Get a reference to an existing Var in the index, or create one if it doesn't exist.
+    /// The variable name to be used is inside of \param meta.name. Lifetime of Created
+    /// variables is managed through shared_ptr reference counting.
+    ///
+    /// \tparam T The underlying type of the Var to create
+    /// \param value The initial value for the Var if it doesn't already exist and gets created
+    /// \param meta Meta information about the variable that will allow tools to introspect
+    ///             and modify it. In particular, \param meta.name is the user accessible name
+    ///             and is also used as input to lookup any Var in the index.
+    template<typename T>
+    std::shared_ptr<VarValueGeneric> GetOrCreateVar( const T& value, const VarMeta& meta );
+
+    /// \return A reference to the corresponding var with name \param full_name, or nullptr
+    ///         if no such Var exists
+    std::shared_ptr<VarValueGeneric> GetByName(const std::string& full_name);
+
+    /// \return A reference to the corresponding var with underlying memory \param value, or nullptr
+    ///         if no such Var exists
+    template<typename T>
+    std::shared_ptr<VarValueGeneric> GetByReference(const T& value);
+
+    /// Callback Event structure for notification of Var Additions and Deletions
+    struct Event {
+        /// Function signature for user callbacks
+        using Function = std::function<void(const Event&)>;
+
+        /// Type of Var Event
+        enum class Action {
+            Added,    // A Var was added to the VarState index
+            Removed   // A Var was removed from the VarState index
+        };
+
+        /// The kind of event
+        Action action;
+
+        /// The Var in question
+        /// Note: removals occur immediately following the callback
+        std::shared_ptr<VarValueGeneric> var;
+    };
+
+    /// Register to be informed of Var additions and removals
+    /// \param callback_function User callback to use for notifications
+    /// \param include_historic Request to receive addition callbacks for current Vars
+    /// \returns A \class Connection object for handling \param callback_function lifetime
+    sigslot::connection RegisterForVarEvents( Event::Function callback_function, bool include_historic);
+
+    /// Type of Var settings file
+    enum class FileKind
+    {
+        detected, // detect based on filename / contents
+        json,     // use json format
+        config    // use config format
+    };
+
+    /// Clear the VarState index of pangolin Vars.
+    /// Any remaining user instances of pangolin::Vars will remain valid but the
+    /// underlying data will be deallocated appropriately when no longer referenced
+    void Clear();
+
+    /// Removes a Var with the given name from the VarState index if it exists
+    /// \returns true iff a var was found to remove
+    bool Remove(const std::string& name);
+
+    /// Load Var state from file
+    void LoadFromFile(const std::string& filename, FileKind kind = FileKind::detected);
+
+    /// Save current Var state to file
+    void SaveToFile(const std::string& filename, FileKind kind = FileKind::json);
+
+private:
+    typedef std::map<std::string, std::shared_ptr<VarValueGeneric>> VarStoreMap;
+    typedef std::map<const void*, std::weak_ptr<VarValueGeneric>> VarStoreMapReverse;
+    typedef std::vector<std::weak_ptr<VarValueGeneric>> VarStoreAdditions;
+
+    template<typename T>
+    VarStoreMap::iterator AddVar(
+        const std::shared_ptr<VarValue<T>>& var,
+        bool record_and_notify = true
+    );
+
+    template<typename T>
+    VarStoreMap::iterator AddUpgradedVar(
+        const std::shared_ptr<VarValue<T>>& var,
+        const VarStoreMap::iterator& existing,
+        bool record_and_notify = true
+    );
+
+    void AddOrSetGeneric(const std::string& name, const std::string& value);
+    std::string ProcessVal(const std::string& val );
+
+    void LoadFromJsonStream(std::istream& is);
+    void LoadFromConfigStream(std::istream& is);
+    void SaveToJsonStream(std::ostream& os);
+
+    sigslot::signal<Event> VarEventSignal;
+
+    VarStoreMap vars;
+    VarStoreMapReverse vars_reverse;
+    VarStoreAdditions vars_add_order;
+};
+
+
+/////////////////////////////////////////////////////////////////////////////
+/// Implementation
+/////////////////////////////////////////////////////////////////////////////
+
+template<typename T>
+std::shared_ptr<VarValueGeneric> VarState::AttachVar(
+    T& variable, const VarMeta& meta
+) {
+    VarStoreMap::iterator it = vars.find(meta.full_name);
+
+    if (it != vars.end()) {
+        std::shared_ptr<VarValueGeneric> generic = it->second;
+
+        // Variable already exists
+        std::shared_ptr<VarValue<T>> tval = std::dynamic_pointer_cast<VarValue<T>>(it->second);
+
+        // We have a problem if the variable doesn't point to the same thing.
+        if( !tval || (&(tval->Get()) != &variable) ) {
+            throw std::runtime_error("Different Var with that name already exists.");
+        }
+    }else{
+        it = AddVar(std::make_shared<VarValue<T>>(variable, meta) );
+    }
+    return it->second;
+}
+
+template<typename T>
+std::shared_ptr<VarValueGeneric> VarState::GetOrCreateVar(
+    const T& value, const VarMeta& meta
+) {
+    VarStoreMap::iterator it = vars.find(meta.full_name);
+
+    if (it != vars.end()) {
+        if(it->second->Meta().generic) {
+            // upgrade from untyped 'generic' type now we have first typed reference
+            AddUpgradedVar(InitialiseFromPreviouslyGenericVar<T>(it->second), it);
+        }
+    }else{
+        it = AddVar(std::make_shared<VarValue<T>>( value, meta ) );
+    }
+
+    return it->second;
+}
+
+inline std::shared_ptr<VarValueGeneric> VarState::GetByName(const std::string& full_name) {
+    VarStoreMap::iterator it = vars.find(full_name);
+
+    if (it != vars.end()) {
+        return it->second;
+    }
+
+    return nullptr;
+}
+
+template<typename T>
+std::shared_ptr<VarValueGeneric> VarState::GetByReference(const T& value)
+{
+    const void* backingValue = &value;
+    auto it = vars_reverse.find(backingValue);
+
+    if (it != vars_reverse.end())
+        if( auto p_var = it->second.lock())
+            return p_var;
+
+    return nullptr;
+}
+
+template<typename T>
+VarState::VarStoreMap::iterator VarState::AddVar(
+    const std::shared_ptr<VarValue<T>>& var,
+    bool record_and_notify
+) {
+    const auto [it, success] = vars.insert(VarStoreMap::value_type(var->Meta().full_name, var));
+    assert(success);
+
+    if(record_and_notify) {
+        vars_reverse[&var->Get()] = var;
+        vars_add_order.push_back(var);
+        VarEventSignal(Event{Event::Action::Added, var});
+    }
+    return it;
+}
+
+template<typename T>
+VarState::VarStoreMap::iterator VarState::AddUpgradedVar(
+    const std::shared_ptr<VarValue<T>>& var,
+    const VarStoreMap::iterator& existing,
+    bool record_and_notify
+) {
+    existing->second = var;
+
+    if(record_and_notify) {
+        vars_reverse[&var->Get()] = var;
+        vars_add_order.push_back(var);
+        VarEventSignal(Event{Event::Action::Added, var});
+    }
+    return existing;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_vars/include/pangolin/var/varvalue.h

@@ -0,0 +1,135 @@
+/* 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/var/varvaluet.h>
+#include <pangolin/var/varwrapper.h>
+#include <pangolin/utils/is_streamable.h>
+
+namespace pangolin
+{
+
+template<typename T>
+class VarValue : public VarValueT<typename std::remove_reference<T>::type>
+{
+public:
+    typedef typename std::remove_reference<T>::type VarT;
+
+
+    VarValue(const T& value, const VarT& default_value, const VarMeta& meta = VarMeta())
+        : value(value), default_value(default_value), meta(meta)
+    {
+        Init();
+    }
+
+    VarValue(const T& value, const VarMeta& meta = VarMeta())
+        : VarValue(value, value, meta)
+    {
+    }
+
+    VarValue()
+        : VarValue(T(), T())
+    {
+    }
+
+    const char* TypeId() const
+    {
+        return typeid(VarT).name();
+    }
+
+    void Reset()
+    {
+        value = default_value;
+    }
+
+    VarMeta& Meta()
+    {
+        return meta;
+    }
+
+    const VarT& Get() const
+    {
+        return value;
+    }
+
+    VarT& Get()
+    {
+        return value;
+    }
+
+    void Set(const VarT& val)
+    {
+        value = val;
+    }
+
+protected:
+    // Specialization dummy for non-serializable types
+    struct ExceptionVarValue : public VarValueT<std::string>
+    {
+        typedef typename std::string VarT;
+        ExceptionVarValue() {}
+        const char* TypeId() const override { throw BadInputException(); }
+        virtual void Reset() override { throw BadInputException(); }
+        VarMeta& Meta() override  { throw BadInputException(); }
+        const VarT& Get() const override { throw BadInputException(); }
+        void Set(const VarT& val) override { throw BadInputException(); }
+    };
+
+    template<typename TT> static
+    typename std::enable_if<is_streamable<TT>::value, std::shared_ptr<VarValueT<std::string>>>::type
+    MakeStringWrapper( const std::shared_ptr<VarValueT<TT>>& v )
+    {
+        return std::make_shared<VarWrapper<std::string,VarT>>(v);
+    }
+
+    template<typename TT> static
+    typename std::enable_if<!is_streamable<TT>::value, std::shared_ptr<VarValueT<std::string>>>::type
+    MakeStringWrapper( const std::shared_ptr<VarValueT<TT>>& v )
+    {
+        return std::make_shared<ExceptionVarValue>();
+    }
+
+    void Init()
+    {
+        // shared_ptr reference to self without deleter.
+        auto self = std::shared_ptr<VarValueT<VarT>>(this, [](VarValueT<VarT>*){} );
+
+        if(std::is_same<VarT,std::string>::value) {
+            // str is reference to this - remove shared_ptr's deleter
+            this->str = std::dynamic_pointer_cast<VarValueT<std::string>>(self);
+        }else{
+            this->str = MakeStringWrapper<VarT>(self);
+        }
+    }
+
+    T value;
+    VarT default_value;
+    VarMeta meta;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_vars/include/pangolin/var/varvaluegeneric.h

@@ -0,0 +1,111 @@
+/* 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 <string>
+#include <memory>
+#include <cmath>
+#include <pangolin/utils/file_utils.h>
+
+namespace pangolin
+{
+constexpr int META_FLAG_NONE      = 0x0000;
+constexpr int META_FLAG_TOGGLE    = 0x0001;
+constexpr int META_FLAG_READONLY  = 0x0002;
+
+struct VarMeta
+{
+    VarMeta(
+        const std::string& full_name = "",
+        double min_val = 0.0, double max_val = 0.0,
+        double increment = 0.0, int flags = META_FLAG_NONE,
+        bool logscale = false, bool generic = false
+    ) :
+        full_name(full_name),
+        increment(increment),
+        flags(flags),
+        gui_changed(false),
+        logscale(logscale),
+        generic(generic)
+    {
+        SetName(full_name);
+        if(logscale) {
+            if (min_val <= 0 || max_val <= 0) {
+                throw std::runtime_error("LogScale: range of numbers must be positive!");
+            }
+            range[0] = std::log(min_val);
+            range[1] = std::log(max_val);
+        }else{
+            range[0] = min_val;
+            range[1] = max_val;
+        }
+    }
+
+    void SetName(const std::string& full_name)
+    {
+        this->full_name = full_name;
+        const std::vector<std::string> parts = pangolin::Split(full_name, '.');
+        friendly = parts.size() > 0 ? parts[parts.size()-1] : "";
+    }
+
+    std::string full_name;
+    std::string friendly;
+    double range[2];
+    double increment;
+    int flags;
+    bool gui_changed;
+    bool logscale;
+    bool generic;
+};
+
+// Forward declaration
+template<typename T>
+class VarValueT;
+
+//! Abstract base class for named Pangolin variables
+class VarValueGeneric
+{
+public:
+    VarValueGeneric()
+    {
+    }
+
+    virtual ~VarValueGeneric()
+    {
+    }
+
+    virtual const char* TypeId() const = 0;
+    virtual void Reset() = 0;
+    virtual VarMeta& Meta() = 0;
+
+//protected:
+    // String serialisation object.
+    std::shared_ptr<VarValueT<std::string>> str;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_vars/include/pangolin/var/varvaluet.h

@@ -0,0 +1,46 @@
+/* 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/var/varvaluegeneric.h>
+#include <pangolin/compat/type_traits.h>
+
+namespace pangolin
+{
+
+template<typename T>
+class VarValueT : public VarValueGeneric
+{
+public:
+    typedef typename std::remove_reference<T>::type VarT;
+
+    virtual const VarT& Get() const = 0;
+    virtual void Set(const VarT& val) = 0;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_vars/include/pangolin/var/varwrapper.h

@@ -0,0 +1,87 @@
+/* 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/var/varvaluegeneric.h>
+#include <pangolin/compat/type_traits.h>
+#include <pangolin/utils/type_convert.h>
+
+namespace pangolin
+{
+
+template<typename T, typename S>
+class VarWrapper : public VarValueT<T>
+{
+public:
+    typedef typename std::remove_reference<S>::type VarS;
+
+    VarWrapper(const std::shared_ptr<VarValueT<S>>& src)
+        : src(src)
+    {
+        this->str = src->str;
+    }
+
+    const char* TypeId() const
+    {
+        return typeid(T).name();
+    }
+
+    void Reset()
+    {
+        src->Reset();
+
+        // If reset throws, it will go up to the user, since there is nothing
+        // more we can do
+        cache = Convert<T,VarS>::Do(src->Get());
+    }
+
+    VarMeta& Meta()
+    {
+        return src->Meta();
+    }
+
+    const T& Get() const
+    {
+        // This might throw, but we can't reset because this is a const method
+        cache = Convert<T,VarS>::Do(src->Get());
+        return cache;
+    }
+
+    void Set(const T& val)
+    {
+        cache = val;
+        // This might throw - needs to be dealt with by user
+        src->Set( Convert<VarS, T>::Do(val) );
+    }
+
+protected:
+    mutable T cache;
+    std::shared_ptr<VarValueT<S>> src;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_vars/src/vars.cpp

@@ -0,0 +1,57 @@
+/* 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/var/varextra.h>
+#include <pangolin/var/varstate.h>
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/utils/picojson.h>
+#include <pangolin/utils/transform.h>
+
+#include <iostream>
+#include <fstream>
+
+using namespace std;
+
+namespace pangolin
+{
+
+void ParseVarsFile(const string& filename)
+{
+    VarState::I().LoadFromFile(filename, VarState::FileKind::config);
+}
+
+void LoadJsonFile(const std::string& filename, const string &prefix)
+{
+    VarState::I().LoadFromFile(filename, VarState::FileKind::json);
+}
+
+void SaveJsonFile(const std::string& filename, const string &prefix)
+{
+    VarState::I().SaveToFile(filename, VarState::FileKind::json);
+}
+
+}

third-party/DPVO/Pangolin/components/pango_vars/src/varstate.cpp

@@ -0,0 +1,233 @@
+#include <iostream>
+#include <fstream>
+#include <pangolin/var/varstate.h>
+#include <pangolin/utils/picojson.h>
+#include <pangolin/utils/transform.h>
+
+namespace pangolin
+{
+
+namespace  {
+template< typename ContainerT, typename PredicateT >
+void erase_if( ContainerT& items, const PredicateT& predicate ) {
+    for( auto it = items.begin(); it != items.end(); ) {
+        if( predicate(*it) ) it = items.erase(it);
+        else ++it;
+    }
+}
+}
+
+VarState& VarState::I() {
+    static VarState singleton;
+    return singleton;
+}
+
+VarState::VarState()
+{
+}
+
+VarState::~VarState() {
+    Clear();
+}
+
+void VarState::Clear() {
+    vars.clear();
+    vars_reverse.clear();
+    vars_add_order.clear();
+}
+
+bool VarState::Remove(const std::string& name)
+{
+    VarStoreMap::iterator it = vars.find(name);
+    if(it != vars.end()) {
+        auto to_remove = it->second;
+        erase_if(vars_reverse, [&to_remove](auto el){return to_remove == el.second.lock();} );
+        erase_if(vars_add_order, [&to_remove](auto el){return to_remove == el.lock();} );
+        vars.erase(it);
+        VarEventSignal(Event{Event::Action::Removed, to_remove});
+        return true;
+    }
+    return false;
+}
+
+bool VarState::Exists(const std::string& key) const
+{
+    return vars.find(key) != vars.end();
+}
+
+sigslot::connection VarState::RegisterForVarEvents( Event::Function callback_function, bool include_historic)
+{
+    if(include_historic) {
+        for (auto it = vars_add_order.begin(); it != vars_add_order.end(); ++it)
+        {
+            if (auto p_var = it->lock()) {
+                callback_function({Event::Action::Added, p_var});
+            }
+        }
+    }
+    return VarEventSignal.connect(callback_function);
+}
+
+//void AddAlias(const string& alias, const string& name)
+//{
+//    std::map<std::string,_Var*>::iterator vi = vars.find(name);
+
+//    if( vi != vars.end() )
+//    {
+//        _Var * v = vi->second;
+//        vars[alias].create(v->val,v->val_default,v->type_name);
+//        vars[alias].Meta().friendly = alias;
+//        v->generic = false;
+//        vars[alias].generic = false;
+//    }else{
+//        pango_print_error("Variable %s does not exist to alias.\n", name);
+//    }
+//}
+
+void VarState::AddOrSetGeneric(const std::string& name, const std::string& value)
+{
+    const auto it = vars.find(name);
+
+    if (it != vars.end()) {
+        it->second->str->Set(value);
+    }else{
+        AddVar(std::make_shared<VarValue<std::string>>(
+            value, VarMeta(name, 0.0, 0.0, 0.0, 0, false, true)), false);
+    }
+}
+
+void VarState::LoadFromJsonStream(std::istream& is)
+{
+    picojson::value file_json(picojson::object_type,true);
+    const std::string err = picojson::parse(file_json,is);
+    if(err.empty()) {
+        if(file_json.contains("vars") ) {
+            picojson::value var_json = file_json["vars"];
+            if(var_json.is<picojson::object>()) {
+                for(picojson::object::iterator
+                    i = var_json.get<picojson::object>().begin();
+                    i!= var_json.get<picojson::object>().end();
+                    ++i)
+                {
+                    const std::string& name = i->first;
+                    const std::string& val = i->second.get<std::string>();
+                    AddOrSetGeneric(name, val);
+                }
+            }
+        }
+    }else{
+        pango_print_error("%s\n", err.c_str());
+    }
+}
+
+// Recursively expand val
+std::string VarState::ProcessVal(const std::string& val )
+{
+    return Transform(val, [this](const std::string& k) -> std::string {
+        auto var = GetByName(k);
+        if( var && var->str ) {
+            return var->str->Get();
+        }else{
+            return std::string("#");
+        }
+    });
+}
+
+void VarState::LoadFromConfigStream(std::istream& is)
+{
+    while( !is.bad() && !is.eof()) {
+        const int c = is.peek();
+
+        if( isspace(c) ) {
+            // ignore leading whitespace
+            is.get();
+        }else{
+            if( c == '#' || c == '%' ) {
+                // ignore lines starting # or %
+                std::string comment;
+                getline(is,comment);
+            }else{
+                // Otherwise, find name and value, seperated by '=' and ';'
+                std::string name;
+                std::string val;
+                getline(is,name,'=');
+                getline(is,val,';');
+                name = Trim(name, " \t\n\r");
+                val = Trim(val, " \t\n\r");
+
+                if( name.size() >0 && val.size() > 0 ) {
+                    if( !val.substr(0,1).compare("@") ) {
+//                            AddAlias(name,val.substr(1));
+                    }else{
+                        AddOrSetGeneric(name, val);
+                    }
+                }
+            }
+        }
+    }
+}
+
+void VarState::SaveToJsonStream(std::ostream &os)
+{
+    picojson::value json_vars(picojson::object_type,true);
+
+    for(const auto& key_value : vars)
+    {
+        const std::string& name = key_value.first;
+        try{
+            json_vars[name] = key_value.second->str->Get();
+        }catch(const BadInputException&)
+        {
+            // Ignore things we can't serialise
+        }
+    }
+
+    picojson::value file_json(picojson::object_type,true);
+    file_json["vars"] = json_vars;
+    os << file_json.serialize(true);
+}
+
+void VarState::LoadFromFile(const std::string& filename, FileKind kind)
+{
+    std::ifstream f(filename.c_str());
+    if( f.is_open() ) {
+        switch(kind)
+        {
+        case FileKind::detected:
+        {
+            const auto fl = ToLowerCopy(filename);
+            if(EndsWith(fl, ".json") || EndsWith(fl, ".jsn")) {
+                LoadFromJsonStream(f);
+            }else{
+                LoadFromConfigStream(f);
+            }
+            break;
+        }
+        case FileKind::config:
+            LoadFromConfigStream(f);
+            break;
+        case FileKind::json:
+            LoadFromJsonStream(f);
+            break;
+        }
+    }else{
+        pango_print_error("Unable to open file %s\n", filename.c_str());
+    }
+}
+
+void VarState::SaveToFile(const std::string& filename, FileKind kind)
+{
+    std::ofstream f(filename);
+    if(f.is_open()) {
+        if(kind == FileKind::json) {
+            SaveToJsonStream(f);
+        }else{
+            throw std::runtime_error("Only support saving to JSON file right now.");
+        }
+
+    }else{
+        pango_print_error("Unable to serialise to %s\n", filename.c_str());
+    }
+}
+
+}

third-party/DPVO/Pangolin/components/pango_vars/tests/test_all.cpp

@@ -0,0 +1,409 @@
+#define CATCH_CONFIG_MAIN
+#include <catch2/catch.hpp>
+
+#include <pangolin/var/var.h>
+#include <pangolin/var/varextra.h>
+
+using namespace pangolin;
+
+struct CustomType{
+    float a; int b;
+};
+std::ostream& operator<<(std::ostream& os, const CustomType& x)
+{
+    return os << x.a << "," << x.b;
+}
+std::istream& operator>>(std::istream& is, CustomType& x)
+{
+    is >> x.a;
+    if( is.get() != ',') throw BadInputException();
+    is >> x.b;
+    return is;
+}
+
+struct CustomTypeNoStream{
+    float a; int b;
+};
+
+
+SCENARIO( "Native Var Types" ) {
+    // Pangolin Var's have enduring lifetime and we must reset state
+    VarState::I().Clear();
+
+    GIVEN( "A Var with some type" ) {
+        Var<double> x1("some_double", 3.14);
+
+        REQUIRE( x1 == 3.14 );
+        REQUIRE( x1.Get() == 3.14 );
+        REQUIRE( x1.Meta().full_name == "some_double" );
+        REQUIRE( x1.Meta().friendly == "some_double" );
+        REQUIRE( x1.Meta().generic == false );
+
+        WHEN( "the Var is set" ) {
+            x1 = 6.7;
+
+            THEN( "the Var and underlying variable change" ) {
+                REQUIRE( x1 == 6.7 );
+                REQUIRE( x1.Get() == 6.7 );
+            }
+        }
+
+        WHEN( "a new Var with the same name is created" ) {
+            Var<double> alias_x1("some_double", 9.2);
+
+            THEN( "the Var references the original unchanged value" ) {
+                REQUIRE( alias_x1 == x1);
+                REQUIRE( alias_x1 == 3.14);
+                REQUIRE( &(alias_x1.Get()) == &(x1.Get()) );
+            }
+
+            WHEN( "the original Var is changed") {
+                x1 = 10.2;
+
+                THEN( "The new Var also changes") {
+                    REQUIRE(alias_x1 == 10.2);
+                }
+            }
+
+            WHEN( "the new Var is changed") {
+                alias_x1 = 10.3;
+
+                THEN( "The original var is also changed") {
+                    REQUIRE(x1 == 10.3);
+                }
+            }
+        }
+
+        WHEN( "a new Var of compatible type is created with the same name" ) {
+            Var<float> x2("some_double", 1.2);
+            Var<int> x3("some_double", 4);
+
+            THEN( "The variables are linked, and converted") {
+                REQUIRE(x2 == 3.14f);
+                REQUIRE(x3 == 3);
+                REQUIRE((void*)&(x2.Get()) != (void*)&(x1.Get()));
+                REQUIRE((void*)&(x3.Get()) != (void*)&(x1.Get()));
+            }
+
+            WHEN( "The new Var is changed") {
+                x3 = 2101;
+
+                THEN( "So is the original") {
+                    REQUIRE(x1 == 2101.0);
+                }
+
+            }
+        }
+
+        WHEN( "a string Var is created with the same name") {
+            Var<std::string> xs("some_double", "test");
+
+            REQUIRE( xs.Get() == "3.14" );
+
+            WHEN( "it's changed to a compatible value") {
+                xs = "4.14";
+
+                THEN( "the original is updated") {
+                    REQUIRE( x1 == 4.14 );
+                }
+            }
+
+            WHEN( "it's changed to an incompatible value") {
+                // This should really throw
+                REQUIRE_THROWS_AS(xs = "chortle", BadInputException);
+
+                THEN( "the original remains unchanged") {
+                    REQUIRE( x1 == 3.14);
+                }
+            }
+        }
+
+        WHEN( "a new Var of incompatible type is created with the same name") {
+            // TODO: Should probably throw here instead
+            Var<CustomType> x4("some_double", {1.0,2});
+
+            THEN( "access results in a serialization exception") {
+                REQUIRE_THROWS_AS(x4.Get(), BadInputException);
+            }
+        }
+
+    }
+}
+
+SCENARIO( "String Var types" ) {
+    // Pangolin Var's have enduring lifetime and we must reset state
+    VarState::I().Clear();
+
+    GIVEN( "A string Pangolin Var") {
+        Var<std::string> x1("some_string", "0.7");
+
+//        REQUIRE( x1 == "0.7" ); // compile error?
+        REQUIRE( x1.Get() == "0.7");
+        REQUIRE( x1.Meta().generic == false );
+
+        WHEN( "A specialized Var is instantiated") {
+            Var<double> x2("some_string", 0.2);
+
+            THEN( "It takes the original value if compatible'") {
+                REQUIRE(x2 == 0.7);
+            }
+
+            WHEN( "The specialized Var is updated" ) {
+                x2 = 104.89;
+
+                THEN( "The original Var is also updated") {
+                    REQUIRE( x1.Get() == "104.89" );
+                }
+            }
+
+            WHEN( "The original Var is updated" ) {
+                x1 = "55.0";
+
+                THEN( "The new var is also updated") {
+                    REQUIRE( x2 == 55.0);
+                }
+            }
+
+            WHEN( "the original var is updated and not compatible") {
+                x1 = "sheeple";
+
+                REQUIRE( x1.Get() == std::string("sheeple") );
+
+                THEN( "Accessing the specialized new var causes an exception") {
+                    REQUIRE_THROWS_AS(x2.Ref()->Get(), BadInputException);
+                    // TODO: Var.Get() current catches and ignores this exception!?
+                    REQUIRE_THROWS_AS(x2.Get(), BadInputException);
+                }
+            }
+        }
+    }
+}
+
+SCENARIO( "Custom Var Types" )
+{
+    // Pangolin Var's have enduring lifetime and we must reset state
+    VarState::I().Clear();
+
+    GIVEN("A Var with custom type with stream operators") {
+        Var<CustomType> x1("x1", {1.2f,3});
+
+        THEN("We can access and set it") {
+            REQUIRE(x1.Get().a == 1.2f);
+            REQUIRE(x1.Get().b == 3);
+
+            x1 = CustomType{4.3f, 90};
+            REQUIRE(x1.Get().a == 4.3f);
+            REQUIRE(x1.Get().b == 90);
+        }
+
+        THEN("We can access it as a string type") {
+            Var<std::string> str_x1("x1");
+            REQUIRE(str_x1.Get() == "1.2,3");
+
+            str_x1 = "5.6,100";
+            REQUIRE(x1.Get().a == 5.6f);
+            REQUIRE(x1.Get().b == 100);
+        }
+    }
+
+    GIVEN("A Var with custom type without stream operators") {
+        Var<CustomTypeNoStream> x2("x2", {7.7f, 40});
+
+        THEN("We can access and set it") {
+            REQUIRE(x2.Get().a == 7.7f);
+            REQUIRE(x2.Get().b == 40);
+
+            x2 = CustomTypeNoStream{4.4f, 91};
+            REQUIRE(x2.Get().a == 4.4f);
+            REQUIRE(x2.Get().b == 91);
+        }
+
+        THEN("Can be accessed through an aliasing Var") {
+            Var<CustomTypeNoStream> alias_x2("x2");
+
+            REQUIRE(alias_x2.Get().a == 7.7f);
+            REQUIRE(alias_x2.Get().b == 40);
+
+            alias_x2 = CustomTypeNoStream{4.4f, 91};
+            REQUIRE(x2.Get().a == 4.4f);
+            REQUIRE(x2.Get().b == 91);
+        }
+
+        THEN("Generic use through string accessors throws") {
+            Var<std::string> str_x2("x2");
+
+            REQUIRE_THROWS(str_x2.Get());
+            REQUIRE_THROWS(str_x2 = "1.2,3");
+        }
+    }
+}
+
+SCENARIO("Attaching Vars")
+{
+    // Pangolin Var's have enduring lifetime and we must reset state
+    VarState::I().Clear();
+
+    GIVEN( "An attached Pangolin Var") {
+        double x1 = 0.5;
+        Var<double>::Attach("x1", x1);
+
+        THEN("The var is accessible through standard vars") {
+            REQUIRE( Var<double>("x1").Get() == 0.5 );
+            REQUIRE( Var<std::string>("x1").Get() == "0.5");
+        }
+
+        WHEN("The attached var is changed") {
+            x1 = 10.0;
+            REQUIRE(Var<double>("x1").Get() == x1 );
+        }
+
+        WHEN("The pangolin var is set") {
+            Var<double>("x1") = 2.6;
+            REQUIRE(x1 == 2.6);
+
+            Var<std::string>("x1") = "7.8";
+            REQUIRE(x1 == 7.8);
+        }
+
+        WHEN("Another var is attached with the same name") {
+            int x1_int;
+            REQUIRE_THROWS_AS(Var<int>::Attach("x1", x1_int), std::runtime_error);
+        }
+
+    }
+
+    GIVEN( "An ordinary Pangolin Var") {
+        Var<double> x1("x1", 0.5);
+
+        THEN( "Trying to attach a Var with the same name throws") {
+            double x1_attach = 1.0;
+            REQUIRE_THROWS_AS(Var<double>::Attach("x1",x1_attach) = 2.0, std::runtime_error);
+        }
+    }
+}
+
+SCENARIO("Detaching Vars")
+{
+    // Pangolin Var's have enduring lifetime and we must reset state
+    VarState::I().Clear();
+
+    GIVEN( "An attached Pangolin Var") {
+        double x1 = 0.5;
+        Var<double>::Attach("x1", x1);
+
+        REQUIRE(VarState::I().Exists("x1"));
+
+        WHEN("An alias is created")
+        {
+            Var<double> alias_x1("x1");
+            REQUIRE(alias_x1.Get() == x1);
+
+            THEN("Changes are synchronized") {
+                x1=0.7;
+                REQUIRE(alias_x1 == 0.7);
+
+                alias_x1 = 0.9;
+                REQUIRE(x1 == 0.9);
+            }
+
+            WHEN("Var is detached") {
+                DetachVar(x1);
+
+                REQUIRE(!VarState::I().Exists("x1"));
+
+                THEN("Changes are still synchronized since alias still in scope") {
+                    x1=0.7;
+                    REQUIRE(alias_x1 == 0.7);
+
+                    alias_x1 = 0.9;
+                    REQUIRE(x1 == 0.9);
+                }
+
+                THEN("Var with same name created is independent") {
+                    Var<double> new_x1("x1");
+                    REQUIRE(VarState::I().Exists("x1"));
+
+                    new_x1 = 1.2;
+                    REQUIRE(x1 == 0.5);
+
+                    x1 = 2.3;
+                    REQUIRE(new_x1 == 1.2);
+
+                    WHEN("New Var for x1 created and changed") {
+                        Var<double> alias_new_x1("x1");
+                        REQUIRE(alias_new_x1 == 1.2);
+
+                        alias_new_x1 = 3.7;
+                        REQUIRE(new_x1 == 3.7);
+                        REQUIRE(x1 == 2.3);
+                    }
+                }
+            }
+        }
+    }
+}
+
+SCENARIO("Var Events")
+{
+    // Pangolin Var's have enduring lifetime and we must reset state
+    VarState::I().Clear();
+
+    Var<double> x1("x1");
+    Var<std::string> x2("x2");
+
+    WHEN("Registering for callbaks without historically added vars") {
+        std::vector<std::string> names;
+
+        sigslot::scoped_connection conn = VarState::I().RegisterForVarEvents([&names](const VarState::Event& e){
+            REQUIRE(e.action == VarState::Event::Action::Added);
+            names.push_back(e.var->Meta().full_name);
+        }, false);
+
+        THEN("We dont get them") {
+            REQUIRE(names.size() == 0);
+        }
+    }
+
+    WHEN("Registering for historic events") {
+        std::vector<std::string> added;
+        std::vector<std::string> removed;
+        sigslot::scoped_connection conn1 = VarState::I().RegisterForVarEvents([&added,&removed](const VarState::Event& e){
+            auto& vec = (e.action == VarState::Event::Action::Added) ? added : removed;
+            vec.push_back(e.var->Meta().full_name);
+        }, true);
+
+        THEN("We get them") {
+            REQUIRE(added.size() == 2);
+            REQUIRE(added[0] == "x1");
+            REQUIRE(added[1] == "x2");
+        }
+
+        WHEN("We remove a var, we get an event") {
+            DetachVarByName("x2");
+            REQUIRE(removed.size() == 1);
+            REQUIRE(removed[0] == "x2");
+        }
+
+        WHEN("We add another listener") {
+            sigslot::scoped_connection conn2 = VarState::I().RegisterForVarEvents([&added,&removed](const VarState::Event& e){
+                auto& vec = (e.action == VarState::Event::Action::Added) ? added : removed;
+                vec.push_back(e.var->Meta().full_name + "_");
+            }, false);
+
+            THEN("They both get called!")
+            {
+                double x3 = 99.0;
+                AttachVar("x3", x3);
+
+                REQUIRE(added.size() == 4);
+                REQUIRE(added[2] == "x3");
+                REQUIRE(added[3] == "x3_");
+
+                DetachVar(x3);
+                REQUIRE(removed.size() == 2);
+                REQUIRE(removed[0] == "x3");
+                REQUIRE(removed[1] == "x3_");
+            }
+        }
+    }
+}

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

@@ -0,0 +1,241 @@
+get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME)
+
+set(DRIVER_DIR "${CMAKE_CURRENT_LIST_DIR}/src/drivers")
+
+target_sources( ${COMPONENT}
+PRIVATE
+    ${CMAKE_CURRENT_LIST_DIR}/src/stream_encoder_factory.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/video_input.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/video_output.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/video.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/video_help.cpp
+    ${DRIVER_DIR}/test.cpp
+    ${DRIVER_DIR}/images.cpp
+    ${DRIVER_DIR}/images_out.cpp
+    ${DRIVER_DIR}/split.cpp
+    ${DRIVER_DIR}/truncate.cpp
+    ${DRIVER_DIR}/pango.cpp
+    ${DRIVER_DIR}/pango_video_output.cpp
+    ${DRIVER_DIR}/debayer.cpp
+    ${DRIVER_DIR}/shift.cpp
+    ${DRIVER_DIR}/transform.cpp
+    ${DRIVER_DIR}/unpack.cpp
+    ${DRIVER_DIR}/pack.cpp
+    ${DRIVER_DIR}/join.cpp
+    ${DRIVER_DIR}/merge.cpp
+    ${DRIVER_DIR}/json.cpp
+    ${DRIVER_DIR}/thread.cpp
+    ${DRIVER_DIR}/mjpeg.cpp
+)
+
+PangolinRegisterFactory(
+    VideoInterface
+    TestVideo ImagesVideo SplitVideo TruncateVideo PangoVideo
+    DebayerVideo ShiftVideo TransformVideo UnpackVideo PackVideo
+    JoinVideo MergeVideo JsonVideo MjpegVideo
+)
+
+PangolinRegisterFactory(
+    VideoOutputInterface
+    ImagesVideoOutput PangoVideoOutput
+)
+
+
+
+#########################################################
+# Search for third-party libraries
+
+if (UNIX)
+    target_sources( ${COMPONENT} PRIVATE ${DRIVER_DIR}/shared_memory.cpp )
+    PangolinRegisterFactory( VideoInterface ThreadVideo )
+endif()
+
+option(BUILD_PANGOLIN_LIBDC1394 "Build support for libdc1394 video input" ON)
+if(BUILD_PANGOLIN_LIBDC1394)
+  find_package(DC1394 QUIET)
+  if(DC1394_FOUND)
+    target_sources( ${COMPONENT} PRIVATE ${DRIVER_DIR}/firewire.cpp ${DRIVER_DIR}/deinterlace.cpp)
+    target_link_libraries(${COMPONENT} PRIVATE ${DC1394_LIBRARY} )
+    target_include_directories(${COMPONENT} PRIVATE ${DC1394_INCLUDE_DIR} )
+    PangolinRegisterFactory( VideoInterface   FirewireVideo DeinterlaceVideo)
+    message(STATUS "libdc1394 Found and Enabled")
+  endif()
+endif()
+
+option(BUILD_PANGOLIN_V4L "Build support for V4L video input" ON)
+if(BUILD_PANGOLIN_V4L AND _LINUX_)
+    target_sources( ${COMPONENT} PRIVATE ${DRIVER_DIR}/v4l.cpp)
+    PangolinRegisterFactory( VideoInterface V4lVideo )
+    message(STATUS "V4L Found and Enabled")
+endif()
+
+option(BUILD_PANGOLIN_FFMPEG "Build support for ffmpeg video input" ON)
+if(BUILD_PANGOLIN_FFMPEG)
+  find_package(FFMPEG QUIET)
+  if(FFMPEG_FOUND)
+      target_sources( ${COMPONENT} PRIVATE
+          ${DRIVER_DIR}/ffmpeg.cpp
+          ${DRIVER_DIR}/ffmpeg_convert.cpp
+          ${DRIVER_DIR}/ffmpeg_output.cpp
+      )
+      target_link_libraries(${COMPONENT} PRIVATE ${FFMPEG_LIBRARIES} )
+      target_include_directories(${COMPONENT} PRIVATE ${FFMPEG_INCLUDE_DIRS} )
+      PangolinRegisterFactory( VideoInterface FfmpegVideo)
+      PangolinRegisterFactory( VideoInterface FfmpegVideo FfmpegVideoConvert)
+      PangolinRegisterFactory( VideoOutputInterface FfmpegVideoOutput)
+      if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        # FFMPEG is a real pain for deprecating the API.
+        set_source_files_properties(${DRIVER_DIR}/ffmpeg.cpp  PROPERTIES COMPILE_FLAGS "-Wno-deprecated-declarations")
+      endif()
+      message(STATUS "ffmpeg Found and Enabled: ${FFMPEG_INCLUDE_DIRS}")
+  endif()
+endif()
+
+option(BUILD_PANGOLIN_REALSENSE "Build support for RealSense video input" ON)
+if(BUILD_PANGOLIN_REALSENSE)
+  find_package(RealSense QUIET)
+  if(REALSENSE_FOUND)
+      target_sources( ${COMPONENT} PRIVATE ${DRIVER_DIR}/realsense.cpp)
+      target_link_libraries(${COMPONENT} PRIVATE ${REALSENSE_LIBRARIES} )
+      target_include_directories(${COMPONENT} PRIVATE ${REALSENSE_INCLUDE_DIRS} )
+      PangolinRegisterFactory( VideoInterface RealSenseVideo )
+      message(STATUS "RealSense Found and Enabled")
+  endif()
+endif()
+
+option(BUILD_PANGOLIN_REALSENSE2 "Build support for RealSense2 video input" ON)
+if(BUILD_PANGOLIN_REALSENSE2)
+  find_package(RealSense2 QUIET)
+  if(REALSENSE2_FOUND)
+      target_sources( ${COMPONENT} PRIVATE ${DRIVER_DIR}/realsense2.cpp)
+      target_link_libraries(${COMPONENT} PRIVATE ${REALSENSE2_LIBRARIES} )
+      target_include_directories(${COMPONENT} PRIVATE ${REALSENSE2_INCLUDE_DIRS} )
+      PangolinRegisterFactory( VideoInterface RealSense2Video )
+      message(STATUS "RealSense2 Found and Enabled")
+  endif()
+endif()
+
+option(BUILD_PANGOLIN_OPENNI "Build support for OpenNI video input" ON)
+if(BUILD_PANGOLIN_OPENNI)
+  find_package(OpenNI QUIET)
+  if(OPENNI_FOUND)
+    target_sources( ${COMPONENT} PRIVATE ${DRIVER_DIR}/openni.cpp)
+    target_link_libraries(${COMPONENT} PRIVATE ${OPENNI_LIBRARIES} )
+    target_include_directories(${COMPONENT} PRIVATE ${OPENNI_INCLUDE_DIRS} )
+    PangolinRegisterFactory( VideoInterface OpenNiVideo )
+    message(STATUS "OpenNI Found and Enabled")
+  endif()
+endif()
+
+option(BUILD_PANGOLIN_OPENNI2 "Build support for OpenNI2 video input" ON)
+if(BUILD_PANGOLIN_OPENNI2)
+  find_package(OpenNI2 QUIET)
+  if(OPENNI2_FOUND)
+      if(LINUX)
+          target_compile_definitions(${COMPONENT} PRIVATE linux)
+      endif()
+
+    target_sources( ${COMPONENT} PRIVATE ${DRIVER_DIR}/openni2.cpp)
+    target_link_libraries(${COMPONENT} PRIVATE ${OPENNI2_LIBRARIES} )
+    target_include_directories(${COMPONENT} PRIVATE ${OPENNI2_INCLUDE_DIRS} )
+    PangolinRegisterFactory( VideoInterface OpenNi2Video )
+    message(STATUS "OpenNI2 Found and Enabled")
+  endif()
+endif()
+
+option(BUILD_PANGOLIN_LIBUVC "Build support for libuvc video input" ON)
+if(BUILD_PANGOLIN_LIBUVC)
+  find_package(uvc QUIET)
+  if(uvc_FOUND)
+      target_sources( ${COMPONENT} PRIVATE ${DRIVER_DIR}/uvc.cpp)
+      target_link_libraries(${COMPONENT} PRIVATE ${uvc_LIBRARIES} )
+      target_include_directories(${COMPONENT} PRIVATE ${uvc_INCLUDE_DIRS} )
+      PangolinRegisterFactory( VideoInterface UvcVideo )
+      if(WIN32 OR WIN64)
+          find_package(pthread REQUIRED QUIET)
+          find_package(libusb1 REQUIRED QUIET)
+          target_link_libraries(${COMPONENT} PRIVATE
+              ${pthread_LIBRARIES} ${libusb1_LIBRARIES}
+          )
+      endif()
+      message(STATUS "libuvc Found and Enabled")
+  endif()
+endif()
+
+option(BUILD_PANGOLIN_UVC_MEDIAFOUNDATION "Build support for MediaFoundation UVC input" ON)
+if (BUILD_PANGOLIN_UVC_MEDIAFOUNDATION)
+  find_package(MediaFoundation QUIET)
+  if (MediaFoundation_FOUND)
+      target_sources( ${COMPONENT} PRIVATE ${DRIVER_DIR}/uvc_mediafoundation.cpp)
+      target_link_libraries(${COMPONENT} PRIVATE ${MediaFoundation_LIBRARIES} )
+      PangolinRegisterFactory( VideoInterface UvcMediaFoundationVideo )
+      message(STATUS "MediaFoundation Found and Enabled")
+  endif()
+endif()
+
+option(BUILD_PANGOLIN_DEPTHSENSE "Build support for DepthSense video input" ON)
+if(BUILD_PANGOLIN_DEPTHSENSE)
+  find_package(DepthSense QUIET)
+  if(DepthSense_FOUND)
+      target_sources( ${COMPONENT} PRIVATE ${DRIVER_DIR}/depthsense.cpp)
+      target_link_libraries(${COMPONENT} PRIVATE ${DepthSense_LIBRARIES} )
+      target_include_directories(${COMPONENT} PRIVATE ${DepthSense_INCLUDE_DIRS} )
+      PangolinRegisterFactory( VideoInterface DepthSenseVideo )
+      message(STATUS "DepthSense Found and Enabled")
+  endif()
+endif()
+
+option(BUILD_PANGOLIN_TELICAM "Build support for TeliCam video input" ON)
+if(BUILD_PANGOLIN_TELICAM)
+  find_package(TeliCam QUIET)
+  if(TeliCam_FOUND)
+      target_sources( ${COMPONENT} PRIVATE ${DRIVER_DIR}/teli.cpp)
+      target_link_libraries(${COMPONENT} PRIVATE ${TeliCam_LIBRARIES} )
+      target_include_directories(${COMPONENT} PRIVATE ${TeliCam_INCLUDE_DIRS} )
+      PangolinRegisterFactory( VideoInterface TeliVideo )
+      message(STATUS "TeliCam Found and Enabled" )
+  endif()
+endif()
+
+option(BUILD_PANGOLIN_PLEORA "Build support for Pleora video input" ON)
+if(BUILD_PANGOLIN_PLEORA)
+  find_package(Pleora QUIET)
+  if(Pleora_FOUND)
+      target_sources( ${COMPONENT} PRIVATE ${DRIVER_DIR}/pleora.cpp)
+      target_link_libraries(${COMPONENT} PRIVATE ${Pleora_LIBRARIES} )
+      target_include_directories(${COMPONENT} PRIVATE ${Pleora_INCLUDE_DIRS} )
+      PangolinRegisterFactory( VideoInterface PleoraVideo )
+      if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+          # Suppress warnings generated from Pleora SDK.
+          set_source_files_properties(${DRIVER_DIR}/pleora.cpp PROPERTIES COMPILE_FLAGS -Wno-unknown-pragmas)
+      endif()
+      message(STATUS "Pleora Found and Enabled" )
+  endif()
+endif()
+
+#########################################################
+
+target_link_libraries(${COMPONENT} PUBLIC pango_core pango_image pango_packetstream)
+target_include_directories(${COMPONENT} PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
+install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/include" DESTINATION ${CMAKE_INSTALL_PREFIX})
+install(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/include" DESTINATION ${CMAKE_INSTALL_PREFIX})
+
+# Create RegisterFactoriesVideoInterface() method call file to load built drivers and add as source
+create_factory_registry_file( "${CMAKE_CURRENT_BINARY_DIR}/include/pangolin/factory" VideoInterface )
+create_factory_registry_file( "${CMAKE_CURRENT_BINARY_DIR}/include/pangolin/factory" VideoOutputInterface )
+target_sources(${COMPONENT} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/include/pangolin/factory/RegisterFactoriesVideoInterface.h")
+target_sources(${COMPONENT} PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/include/pangolin/factory/RegisterFactoriesVideoOutputInterface.h")
+
+
+if(BUILD_TESTS)
+    add_executable(test_video_uris ${CMAKE_CURRENT_LIST_DIR}/tests/tests_video_uri.cpp)
+    target_link_libraries(test_video_uris PRIVATE Catch2::Catch2 ${COMPONENT})
+    catch_discover_tests(test_video_uris)
+    add_executable(test_video_loading ${CMAKE_CURRENT_LIST_DIR}/tests/tests_video_loading.cpp)
+    target_link_libraries(test_video_loading PRIVATE Catch2::Catch2 ${COMPONENT})
+    catch_discover_tests(test_video_loading)
+endif()

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/debayer.h

@@ -0,0 +1,130 @@
+/* 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/video/video_interface.h>
+
+namespace pangolin
+{
+
+struct WbGains {
+    WbGains():r(1.0f), g(1.0f), b(1.0f){}
+    WbGains(float r_in, float g_in, float b_in):r(r_in), g(g_in), b(b_in){
+        PANGO_ASSERT(r_in >= 0.0f && r_in <= 1.0f &&
+                     g_in >= 0.0f && g_in <= 1.0f &&
+                     b_in >= 0.0f && b_in <= 1.0f ,
+                     "[Debayer] White balance gains must be between 0.0 and 1.0");
+    }
+    float r;
+    float g;
+    float b;
+};
+
+// Enum to match libdc1394's dc1394_bayer_method_t
+typedef enum {
+    BAYER_METHOD_NEAREST = 0,
+    BAYER_METHOD_SIMPLE,
+    BAYER_METHOD_BILINEAR,
+    BAYER_METHOD_HQLINEAR,
+    BAYER_METHOD_DOWNSAMPLE_,
+    BAYER_METHOD_EDGESENSE,
+    BAYER_METHOD_VNG,
+    BAYER_METHOD_AHD,
+
+    // Pangolin custom defines
+    BAYER_METHOD_NONE = 512,
+    BAYER_METHOD_DOWNSAMPLE,
+    BAYER_METHOD_DOWNSAMPLE_MONO
+} bayer_method_t;
+
+// Enum to match libdc1394's dc1394_color_filter_t
+typedef enum {
+    DC1394_COLOR_FILTER_RGGB = 512,
+    DC1394_COLOR_FILTER_GBRG,
+    DC1394_COLOR_FILTER_GRBG,
+    DC1394_COLOR_FILTER_BGGR
+} color_filter_t;
+
+// Video class that debayers its video input using the given method.
+class PANGOLIN_EXPORT DebayerVideo :
+        public VideoInterface,
+        public VideoFilterInterface,
+        public BufferAwareVideoInterface
+{
+public:
+    DebayerVideo(std::unique_ptr<VideoInterface>& videoin, const std::vector<bayer_method_t> &method, color_filter_t tile, const WbGains& input_wb_gains);
+    ~DebayerVideo();
+
+    //! Implement VideoInput::Start()
+    void Start();
+
+    //! Implement VideoInput::Stop()
+    void Stop();
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const;
+
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true );
+
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true );
+
+    std::vector<VideoInterface*>& InputStreams();
+
+    static color_filter_t ColorFilterFromString(std::string str);
+
+    static bayer_method_t BayerMethodFromString(std::string str);
+
+    uint32_t AvailableFrames() const;
+
+    bool DropNFrames(uint32_t n);
+
+protected:
+    void ProcessStreams(unsigned char* out, const unsigned char* in);
+
+    std::unique_ptr<VideoInterface> src;
+    std::vector<VideoInterface*> videoin;
+    std::vector<StreamInfo> streams;
+
+    size_t size_bytes;
+    std::unique_ptr<unsigned char[]> buffer;
+
+    std::vector<bayer_method_t> methods;
+    color_filter_t tile;
+
+    WbGains wb_gains;
+
+    picojson::value device_properties;
+    picojson::value frame_properties;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/deinterlace.h

@@ -0,0 +1,62 @@
+/* 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/video/video_interface.h>
+#include <vector>
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT DeinterlaceVideo
+    : public VideoInterface
+{
+public:
+    DeinterlaceVideo(std::unique_ptr<VideoInterface>& videoin);
+    ~DeinterlaceVideo();
+    
+    size_t SizeBytes() const;
+    
+    const std::vector<StreamInfo>& Streams() const;
+    
+    void Start();
+    
+    void Stop();
+    
+    bool GrabNext( unsigned char* image, bool wait = true );
+    
+    bool GrabNewest( unsigned char* image, bool wait = true );    
+    
+protected:
+    std::unique_ptr<VideoInterface> videoin;
+    std::vector<StreamInfo> streams;
+    unsigned char* buffer;
+};
+
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/depthsense.h

@@ -0,0 +1,170 @@
+/* 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 <thread>
+#include <mutex>
+#include <condition_variable>
+
+#include <pangolin/video/video_interface.h>
+#include <pangolin/video/iostream_operators.h>
+
+// DepthSense SDK for SoftKinetic cameras from Creative
+#include <DepthSense.hxx>
+
+namespace pangolin
+{
+
+enum DepthSenseSensorType
+{
+    DepthSenseUnassigned = -1,
+    DepthSenseRgb = 0,
+    DepthSenseDepth
+};
+
+// Video class that outputs test video signal.
+class PANGOLIN_EXPORT DepthSenseVideo :
+        public VideoInterface, public VideoPropertiesInterface
+{
+public:
+    DepthSenseVideo(DepthSense::Device device, DepthSenseSensorType s1, DepthSenseSensorType s2, ImageDim dim1, ImageDim dim2, unsigned int fps1, unsigned int fps2, const Uri& uri);
+    ~DepthSenseVideo();
+    
+    //! Implement VideoInput::Start()
+    void Start();
+    
+    //! Implement VideoInput::Stop()
+    void Stop();
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const;
+    
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true );
+    
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true );
+    
+    //! Implement VideoInput::DeviceProperties()
+    const picojson::value& DeviceProperties() const {
+        return device_properties;
+    }
+
+    //! Implement VideoInput::DeviceProperties()
+    const picojson::value& FrameProperties() const {
+        return frame_properties;
+    }
+protected:
+    void onNewColorSample(DepthSense::ColorNode node, DepthSense::ColorNode::NewSampleReceivedData data);
+    void onNewDepthSample(DepthSense::DepthNode node, DepthSense::DepthNode::NewSampleReceivedData data);
+
+    struct SensorConfig
+    {
+        DepthSenseSensorType type;
+        ImageDim dim;
+        unsigned int fps;
+    };
+
+    void UpdateParameters(const DepthSense::Node& node, const Uri& uri);
+    void ConfigureNodes(const Uri& uri);
+    void ConfigureDepthNode(const SensorConfig& sensorConfig, const Uri& uri);
+    void ConfigureColorNode(const SensorConfig& sensorConfig, const Uri& uri);
+
+    double GetDeltaTime() const;
+
+    std::vector<StreamInfo> streams;
+    picojson::value device_properties;
+    picojson::value frame_properties;
+    picojson::value* streams_properties;
+
+
+    DepthSense::Device device;
+    DepthSense::DepthNode g_dnode;
+    DepthSense::ColorNode g_cnode;
+
+    unsigned char* fill_image;
+
+    int depthmap_stream;
+    int rgb_stream;
+
+    int gotDepth;
+    int gotColor;
+    std::mutex update_mutex;
+    std::condition_variable cond_image_filled;
+    std::condition_variable cond_image_requested;
+
+    SensorConfig sensorConfig[2];
+
+    bool enableDepth;
+    bool enableColor;
+    double depthTs;
+    double colorTs;
+
+    size_t size_bytes;
+};
+
+class DepthSenseContext
+{
+    friend class DepthSenseVideo;
+
+public:
+    // Singleton Instance
+    static DepthSenseContext& I();
+
+    DepthSenseVideo* GetDepthSenseVideo(size_t device_num, DepthSenseSensorType s1, DepthSenseSensorType s2, ImageDim dim1, ImageDim dim2, unsigned int fps1, unsigned int fps2, const Uri& uri);
+
+protected:
+    // Protected Constructor 
+    DepthSenseContext();
+    ~DepthSenseContext();
+
+    DepthSense::Context& Context();
+
+    void NewDeviceRunning();
+    void DeviceClosing();
+
+    void StartNodes();
+    void StopNodes();
+
+    void EventLoop();
+
+    void onDeviceConnected(DepthSense::Context context, DepthSense::Context::DeviceAddedData data);
+    void onDeviceDisconnected(DepthSense::Context context, DepthSense::Context::DeviceRemovedData data);
+
+    DepthSense::Context g_context;
+
+    std::thread event_thread;
+    bool is_running;
+
+    int running_devices;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/ffmpeg.h

@@ -0,0 +1,87 @@
+/* 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/video/video_interface.h>
+#include <pangolin/video/iostream_operators.h>
+#include <pangolin/video/drivers/ffmpeg_common.h>
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT FfmpegVideo : public VideoInterface, public VideoPlaybackInterface
+{
+public:
+    FfmpegVideo(const std::string filename, const std::string fmtout = "RGB24", const std::string codec_hint = "", bool dump_info = false, int user_video_stream = -1, ImageDim size = ImageDim(0,0));
+    ~FfmpegVideo();
+    
+    //! Implement VideoInput::Start()
+    void Start() override;
+    
+    //! Implement VideoInput::Stop()
+    void Stop() override;
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const override;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const override;
+    
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true ) override;
+    
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true ) override;
+    
+    //! VideoPlaybackInterface methods
+    size_t GetCurrentFrameId() const override;
+    size_t GetTotalFrames() const override;
+    size_t Seek(size_t frameid) override;
+
+protected:
+    void InitUrl(const std::string filename, const std::string fmtout = "RGB24", const std::string codec_hint = "", bool dump_info = false , int user_video_stream = -1, ImageDim size= ImageDim(0,0));
+    
+    std::vector<StreamInfo> streams;
+    
+    SwsContext      *img_convert_ctx;
+    AVFormatContext *pFormatCtx;
+    int             videoStream;
+    int64_t         numFrames;
+    int64_t         ptsPerFrame;
+    const AVCodec         *pVidCodec;
+    const AVCodec         *pAudCodec;
+    AVCodecContext *pCodecContext;
+    AVFrame         *pFrame;
+    AVFrame         *pFrameOut;
+    AVPacket        *packet;
+    int             numBytesOut;
+    AVPixelFormat     fmtout;
+    int64_t next_frame;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/ffmpeg_common.h

@@ -0,0 +1,127 @@
+#pragma once
+
+#include <pangolin/video/video_exception.h>
+#include <pangolin/utils/file_utils.h>
+
+extern "C"
+{
+
+// HACK for some versions of FFMPEG
+#ifndef INT64_C
+#define INT64_C(c) (c ## LL)
+#define UINT64_C(c) (c ## ULL)
+#endif
+
+#include <libavformat/avformat.h>
+#include <libswscale/swscale.h>
+#include <libavutil/pixdesc.h>
+#include <libavcodec/avcodec.h>
+#include <libavutil/imgutils.h>
+
+// Some versions of FFMPEG define this horrid macro in global scope.
+#undef PixelFormat
+}
+
+namespace pangolin
+{
+
+inline AVPixelFormat FfmpegFmtFromString(const std::string fmt)
+{
+    const std::string lfmt = ToLowerCopy(fmt);
+    if(!lfmt.compare("gray8") || !lfmt.compare("grey8") || !lfmt.compare("grey")) {
+        return AV_PIX_FMT_GRAY8;
+    }
+    return av_get_pix_fmt(lfmt.c_str());
+}
+
+
+#define TEST_PIX_FMT_RETURN(fmt) case AV_PIX_FMT_##fmt: return #fmt;
+inline std::string FfmpegFmtToString(const AVPixelFormat fmt)
+{
+    switch( fmt )
+    {
+    TEST_PIX_FMT_RETURN(YUV420P);
+    TEST_PIX_FMT_RETURN(YUYV422);
+    TEST_PIX_FMT_RETURN(RGB24);
+    TEST_PIX_FMT_RETURN(BGR24);
+    TEST_PIX_FMT_RETURN(YUV422P);
+    TEST_PIX_FMT_RETURN(YUV444P);
+    TEST_PIX_FMT_RETURN(YUV410P);
+    TEST_PIX_FMT_RETURN(YUV411P);
+    TEST_PIX_FMT_RETURN(GRAY8);
+    TEST_PIX_FMT_RETURN(MONOWHITE);
+    TEST_PIX_FMT_RETURN(MONOBLACK);
+    TEST_PIX_FMT_RETURN(PAL8);
+    TEST_PIX_FMT_RETURN(YUVJ420P);
+    TEST_PIX_FMT_RETURN(YUVJ422P);
+    TEST_PIX_FMT_RETURN(YUVJ444P);
+#ifdef FF_API_XVMC
+    TEST_PIX_FMT_RETURN(XVMC_MPEG2_MC);
+    TEST_PIX_FMT_RETURN(XVMC_MPEG2_IDCT);
+#endif
+    TEST_PIX_FMT_RETURN(UYVY422);
+    TEST_PIX_FMT_RETURN(UYYVYY411);
+    TEST_PIX_FMT_RETURN(BGR8);
+    TEST_PIX_FMT_RETURN(BGR4);
+    TEST_PIX_FMT_RETURN(BGR4_BYTE);
+    TEST_PIX_FMT_RETURN(RGB8);
+    TEST_PIX_FMT_RETURN(RGB4);
+    TEST_PIX_FMT_RETURN(RGB4_BYTE);
+    TEST_PIX_FMT_RETURN(NV12);
+    TEST_PIX_FMT_RETURN(NV21);
+    TEST_PIX_FMT_RETURN(ARGB);
+    TEST_PIX_FMT_RETURN(RGBA);
+    TEST_PIX_FMT_RETURN(ABGR);
+    TEST_PIX_FMT_RETURN(BGRA);
+    TEST_PIX_FMT_RETURN(GRAY16BE);
+    TEST_PIX_FMT_RETURN(GRAY16LE);
+    TEST_PIX_FMT_RETURN(YUV440P);
+    TEST_PIX_FMT_RETURN(YUVJ440P);
+    TEST_PIX_FMT_RETURN(YUVA420P);
+#ifdef FF_API_VDPAU
+    TEST_PIX_FMT_RETURN(VDPAU_H264);
+    TEST_PIX_FMT_RETURN(VDPAU_MPEG1);
+    TEST_PIX_FMT_RETURN(VDPAU_MPEG2);
+    TEST_PIX_FMT_RETURN(VDPAU_WMV3);
+    TEST_PIX_FMT_RETURN(VDPAU_VC1);
+#endif
+    TEST_PIX_FMT_RETURN(RGB48BE );
+    TEST_PIX_FMT_RETURN(RGB48LE );
+    TEST_PIX_FMT_RETURN(RGB565BE);
+    TEST_PIX_FMT_RETURN(RGB565LE);
+    TEST_PIX_FMT_RETURN(RGB555BE);
+    TEST_PIX_FMT_RETURN(RGB555LE);
+    TEST_PIX_FMT_RETURN(BGR565BE);
+    TEST_PIX_FMT_RETURN(BGR565LE);
+    TEST_PIX_FMT_RETURN(BGR555BE);
+    TEST_PIX_FMT_RETURN(BGR555LE);
+#if LIBAVFORMAT_VERSION_MAJOR >= 59
+    TEST_PIX_FMT_RETURN(VAAPI);
+#else
+    TEST_PIX_FMT_RETURN(VAAPI_MOCO);
+    TEST_PIX_FMT_RETURN(VAAPI_IDCT);
+    TEST_PIX_FMT_RETURN(VAAPI_VLD);
+#endif
+    TEST_PIX_FMT_RETURN(YUV420P16LE);
+    TEST_PIX_FMT_RETURN(YUV420P16BE);
+    TEST_PIX_FMT_RETURN(YUV422P16LE);
+    TEST_PIX_FMT_RETURN(YUV422P16BE);
+    TEST_PIX_FMT_RETURN(YUV444P16LE);
+    TEST_PIX_FMT_RETURN(YUV444P16BE);
+#ifdef FF_API_VDPAU
+    TEST_PIX_FMT_RETURN(VDPAU_MPEG4);
+#endif
+    TEST_PIX_FMT_RETURN(DXVA2_VLD);
+    TEST_PIX_FMT_RETURN(RGB444BE);
+    TEST_PIX_FMT_RETURN(RGB444LE);
+    TEST_PIX_FMT_RETURN(BGR444BE);
+    TEST_PIX_FMT_RETURN(BGR444LE);
+    TEST_PIX_FMT_RETURN(Y400A   );
+    TEST_PIX_FMT_RETURN(NB      );
+    default: return "";
+    }
+}
+
+#undef TEST_PIX_FMT_RETURN
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/ffmpeg_convert.h

@@ -0,0 +1,100 @@
+/* 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/video/video_interface.h>
+#include <pangolin/video/drivers/ffmpeg_common.h>
+
+namespace pangolin {
+
+enum FfmpegMethod
+{
+    FFMPEG_FAST_BILINEAR =    1,
+    FFMPEG_BILINEAR      =    2,
+    FFMPEG_BICUBIC       =    4,
+    FFMPEG_X             =    8,
+    FFMPEG_POINT         = 0x10,
+    FFMPEG_AREA          = 0x20,
+    FFMPEG_BICUBLIN      = 0x40,
+    FFMPEG_GAUSS         = 0x80,
+    FFMPEG_SINC          =0x100,
+    FFMPEG_LANCZOS       =0x200,
+    FFMPEG_SPLINE        =0x400
+};
+
+class PANGOLIN_EXPORT FfmpegConverter : public VideoInterface
+{
+public:
+    FfmpegConverter(std::unique_ptr<VideoInterface>& videoin, const std::string pixelfmtout = "RGB24", FfmpegMethod method = FFMPEG_POINT);
+    ~FfmpegConverter();
+
+    //! Implement VideoInput::Start()
+    void Start();
+
+    //! Implement VideoInput::Stop()
+    void Stop();
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const;
+
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true );
+
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true );
+
+protected:
+    std::vector<StreamInfo> streams;
+
+    struct ConvertContext
+    {
+        SwsContext*     img_convert_ctx;
+        AVPixelFormat   fmtsrc;
+        AVPixelFormat   fmtdst;
+        AVFrame*        avsrc;
+        AVFrame*        avdst;
+        size_t          w,h;
+        size_t          src_buffer_offset;
+        size_t          dst_buffer_offset;
+
+        void convert(const unsigned char * src, unsigned char* dst);
+
+    };
+
+    std::unique_ptr<VideoInterface> videoin;
+    std::unique_ptr<unsigned char[]> input_buffer;
+
+    std::vector<ConvertContext> converters;
+    //size_t src_buffer_size;
+    size_t dst_buffer_size;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/ffmpeg_output.h

@@ -0,0 +1,111 @@
+/* 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/video/video_output_interface.h>
+#include <pangolin/video/drivers/ffmpeg_common.h>
+
+namespace pangolin
+{
+
+#if (LIBAVFORMAT_VERSION_MAJOR > 55) || ((LIBAVFORMAT_VERSION_MAJOR == 55) && (LIBAVFORMAT_VERSION_MINOR >= 7))
+typedef AVCodecID CodecID;
+#endif
+
+// Forward declaration
+class FfmpegVideoOutputStream;
+
+class PANGOLIN_EXPORT FfmpegVideoOutput
+    : public VideoOutputInterface
+{
+    friend class FfmpegVideoOutputStream;
+public:
+    FfmpegVideoOutput( const std::string& filename, int base_frame_rate, int bit_rate, bool flip = false);
+    ~FfmpegVideoOutput();
+
+    const std::vector<StreamInfo>& Streams() const override;
+
+    void SetStreams(const std::vector<StreamInfo>& streams, const std::string& uri, const picojson::value& properties) override;
+
+    int WriteStreams(const unsigned char* data, const picojson::value& frame_properties) override;
+
+    bool IsPipe() const override;
+
+protected:
+    void Initialise(std::string filename);
+    void StartStream();
+    void Close();
+
+    std::string filename;
+    bool started;
+    AVFormatContext *oc;
+    std::vector<FfmpegVideoOutputStream*> streams;
+    std::vector<StreamInfo> strs;
+
+    int frame_count;
+
+    int base_frame_rate;
+    int bit_rate;
+    bool is_pipe;
+    bool flip;
+};
+
+class FfmpegVideoOutputStream
+{
+public:
+    FfmpegVideoOutputStream(FfmpegVideoOutput& recorder, CodecID codec_id, uint64_t frame_rate, int bit_rate, const StreamInfo& input_info, bool flip );
+    ~FfmpegVideoOutputStream();
+
+    const StreamInfo& GetStreamInfo() const;
+
+    void WriteImage(const uint8_t* img, int w, int h);
+    void Flush();
+
+protected:
+    void WriteAvPacket(AVPacket* pkt);
+    void WriteFrame(AVFrame* frame);
+    double BaseFrameTime();
+
+    FfmpegVideoOutput& recorder;
+
+    StreamInfo input_info;
+    AVPixelFormat input_format;
+    AVPixelFormat output_format;
+    int64_t last_pts;
+
+    // These pointers are owned by class
+    AVStream* stream;
+    SwsContext *sws_ctx;
+    AVFrame* src_frame;
+    AVFrame* frame;
+    AVCodecContext* codec_context;
+
+    bool flip;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/firewire.h

@@ -0,0 +1,253 @@
+/* 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/video/video_interface.h>
+
+#include <dc1394/dc1394.h>
+
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+
+
+
+namespace pangolin
+{
+
+PANGOLIN_EXPORT
+std::string Dc1394ColorCodingToString(dc1394color_coding_t coding);
+
+PANGOLIN_EXPORT
+dc1394color_coding_t Dc1394ColorCodingFromString(std::string coding);
+
+PANGOLIN_EXPORT
+void Dc1394ModeDetails(dc1394video_mode_t mode, unsigned& w, unsigned& h, std::string& format );
+
+class PANGOLIN_EXPORT FirewireFrame
+{
+    friend class FirewireVideo;
+public:
+    bool isValid() { return frame; }
+    unsigned char* Image() { return frame ? frame->image : 0; }
+    unsigned Width() const { return frame ? frame->size[0] : 0; }
+    unsigned Height() const { return frame ? frame->size[1] : 0; }
+    unsigned ImageBytes() const { return frame ? frame->image_bytes : 0; }
+    int FramesBehind() const { return frame ? frame->frames_behind : -1; }
+    unsigned Timestamp() const { return frame ? frame->timestamp : 0; }
+    int Id() const { return frame ? frame->id : -1; }
+protected:
+    FirewireFrame(dc1394video_frame_t* frame) : frame(frame) {}
+    dc1394video_frame_t *frame;
+};
+
+struct PANGOLIN_EXPORT Guid
+{
+    Guid(uint64_t guid):guid(guid){}
+    uint64_t guid;
+};
+
+class PANGOLIN_EXPORT FirewireVideo : public VideoInterface
+{
+public:
+    const static int MAX_FR = -1;
+    const static int EXT_TRIG = -1;
+    const static uint32_t GPIO_CTRL_PIN0 = 0x1110;
+    const static uint32_t GPIO_CTRL_PIN1 = 0x1120;
+    const static uint32_t GPIO_CTRL_PIN2 = 0x1130;
+    const static uint32_t GPIO_CTRL_PIN3 = 0x1140;
+    
+    FirewireVideo(
+            unsigned deviceid = 0,
+            dc1394video_mode_t video_mode = DC1394_VIDEO_MODE_640x480_RGB8,
+            dc1394framerate_t framerate = DC1394_FRAMERATE_30,
+            dc1394speed_t iso_speed = DC1394_ISO_SPEED_400,
+            int dma_buffers = 10
+            );
+    
+    FirewireVideo(
+            Guid guid,
+            dc1394video_mode_t video_mode = DC1394_VIDEO_MODE_640x480_RGB8,
+            dc1394framerate_t framerate = DC1394_FRAMERATE_30,
+            dc1394speed_t iso_speed = DC1394_ISO_SPEED_400,
+            int dma_buffers = 10
+            );
+    
+    FirewireVideo(
+            Guid guid,
+            dc1394video_mode_t video_mode,
+            float framerate,
+            uint32_t width, uint32_t height,
+            uint32_t left, uint32_t top,
+            dc1394speed_t iso_speed,
+            int dma_buffers, bool reset_at_boot=false
+            );
+    
+    FirewireVideo(
+            unsigned deviceid,
+            dc1394video_mode_t video_mode,
+            float framerate,
+            uint32_t width, uint32_t height,
+            uint32_t left, uint32_t top,
+            dc1394speed_t iso_speed,
+            int dma_buffers, bool reset_at_boot=false
+            );
+    
+    ~FirewireVideo();
+    
+    //! Implement VideoInput::Start()
+    void Start();
+    
+    //! Implement VideoInput::Stop()
+    void Stop();
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const;
+    
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true );
+    
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true );
+
+    //! (deprecated: use Streams[i].Width())
+    //! Return image width
+    unsigned Width() const { return width; }
+    
+    //! (deprecated: use Streams[i].Height())
+    //! Return image height
+    unsigned Height() const { return height; }
+    
+    //! Return object containing reference to image data within
+    //! DMA buffer. The FirewireFrame must be returned to
+    //! signal that it can be reused with a corresponding PutFrame()
+    FirewireFrame GetNext(bool wait = true);
+    
+    //! Return object containing reference to newest image data within
+    //! DMA buffer discarding old images. The FirewireFrame must be
+    //! returned to signal that it can be reused with a corresponding PutFrame()
+    FirewireFrame GetNewest(bool wait = true);
+    
+    //! Return FirewireFrame object. Data held by FirewireFrame is
+    //! invalidated on return.
+    void PutFrame(FirewireFrame& frame);
+    
+    //! return absolute shutter value
+    float GetShutterTime() const;
+    
+    //! set absolute shutter value
+    void SetShutterTime(float val);
+    
+    //! set auto shutter value
+    void SetAutoShutterTime();
+    
+    //! return absolute gain value
+    float GetGain() const;
+    
+    //! set absolute gain value
+    void SetGain(float val);
+    
+    //! set auto gain value
+    void SetAutoGain();
+    
+    //! return absolute brightness value
+    float GetBrightness() const;
+    
+    //! set absolute brightness value
+    void SetBrightness(float val);
+    
+    //! set auto brightness
+    void SetAutoBrightness();
+    
+    //! return absolute gamma value
+    float GetGamma() const;
+    
+    //! return quantised shutter value
+    void SetShutterTimeQuant(int shutter);
+    
+    //! set the trigger to internal, i.e. determined by video mode
+    void SetInternalTrigger();
+    
+    //! set the trigger to external
+    void SetExternalTrigger(
+            dc1394trigger_mode_t mode=DC1394_TRIGGER_MODE_0,
+            dc1394trigger_polarity_t polarity=DC1394_TRIGGER_ACTIVE_HIGH,
+            dc1394trigger_source_t source=DC1394_TRIGGER_SOURCE_0
+            );
+    
+    //! set a camera register
+    void SetRegister(uint64_t offset, uint32_t value);
+    
+    //! read camera register
+    uint32_t GetRegister(uint64_t offset);
+    
+    //! set a camera control register
+    void SetControlRegister(uint64_t offset, uint32_t value);
+    
+    //! read camera control register
+    uint32_t GetControlRegister(uint64_t offset);
+    
+protected:
+    void init_stream_info();
+    
+    void init_camera(
+            uint64_t guid, int dma_frames,
+            dc1394speed_t iso_speed,
+            dc1394video_mode_t video_mode,
+            dc1394framerate_t framerate
+            );
+    
+    void init_format7_camera(
+            uint64_t guid, int dma_frames,
+            dc1394speed_t iso_speed,
+            dc1394video_mode_t video_mode,
+            float framerate,
+            uint32_t width, uint32_t height,
+            uint32_t left, uint32_t top, bool reset_at_boot
+            );
+    
+    static int nearest_value(int value, int step, int min, int max);
+    static double bus_period_from_iso_speed(dc1394speed_t iso_speed);
+    
+    size_t frame_size_bytes;
+    std::vector<StreamInfo> streams;
+    
+    bool running;
+    dc1394camera_t *camera;
+    unsigned width, height, top, left;
+    //dc1394featureset_t features;
+    dc1394_t * d;
+    dc1394camera_list_t * list;
+    mutable dc1394error_t err;
+    
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/gamma.h

@@ -0,0 +1,85 @@
+/* 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/pangolin.h>
+#include <pangolin/video/video.h>
+#include <set>
+
+namespace pangolin
+{
+
+// Video class that applies gamma to its video input
+class PANGOLIN_EXPORT GammaVideo :
+    public VideoInterface,
+    public VideoFilterInterface,
+    public BufferAwareVideoInterface
+{
+public:
+    GammaVideo(std::unique_ptr<VideoInterface>& videoin, const std::map<size_t, float> &stream_gammas);
+    ~GammaVideo();
+
+    //! Implement VideoInput::Start()
+    void Start();
+
+    //! Implement VideoInput::Stop()
+    void Stop();
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const;
+
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( uint8_t* image, bool wait = true );
+
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( uint8_t* image, bool wait = true );
+
+    //! Implement VideoFilterInterface method
+    std::vector<VideoInterface*>& InputStreams();
+
+    uint32_t AvailableFrames() const;
+
+    bool DropNFrames(uint32_t n);
+
+protected:
+    void Process(uint8_t* image, const uint8_t* buffer);
+
+    std::unique_ptr<VideoInterface> src;
+    std::vector<VideoInterface*> videoin;
+
+    std::vector<StreamInfo> streams;
+    size_t size_bytes;
+    std::unique_ptr<uint8_t[]> buffer;
+    const std::map<size_t, float> stream_gammas;
+    std::set<std::string> formats_supported;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/images.h

@@ -0,0 +1,121 @@
+/* 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/video/video_interface.h>
+#include <pangolin/image/image_io.h>
+
+#include <deque>
+#include <vector>
+
+namespace pangolin
+{
+
+// Video class that outputs test video signal.
+class PANGOLIN_EXPORT ImagesVideo : public VideoInterface, public VideoPlaybackInterface, public VideoPropertiesInterface
+{
+public:
+    ImagesVideo(const std::string& wildcard_path);
+    ImagesVideo(const std::string& wildcard_path, const PixelFormat& raw_fmt, size_t raw_width, size_t raw_height, size_t raw_pitch);
+
+    // Explicitly delete copy ctor and assignment operator.
+    // See http://stackoverflow.com/questions/29565299/how-to-use-a-vector-of-unique-pointers-in-a-dll-exported-class-with-visual-studi
+    // >> It appears adding __declspec(dllexport) forces the compiler to define the implicitly-declared copy constructor and copy assignment operator
+    ImagesVideo(const ImagesVideo&) = delete;
+    ImagesVideo& operator=(const ImagesVideo&) = delete;
+
+    ~ImagesVideo();
+
+    ///////////////////////////////////
+    // Implement VideoInterface
+    
+    void Start() override;
+    
+    void Stop() override;
+
+    size_t SizeBytes() const override;
+
+    const std::vector<StreamInfo>& Streams() const override;
+    
+    bool GrabNext( unsigned char* image, bool wait = true ) override;
+    
+    bool GrabNewest( unsigned char* image, bool wait = true ) override;
+
+    ///////////////////////////////////
+    // Implement VideoPlaybackInterface
+
+    size_t GetCurrentFrameId() const override;
+
+    size_t GetTotalFrames() const override;
+
+    size_t Seek(size_t frameid) override;
+
+    ///////////////////////////////////
+    // Implement VideoPropertiesInterface
+
+    const picojson::value& DeviceProperties() const override;
+
+    const picojson::value& FrameProperties() const override;
+    
+protected:
+    typedef std::vector<TypedImage> Frame;
+    
+    const std::string& Filename(size_t frameNum, size_t channelNum) {
+        return filenames[channelNum][frameNum];
+    }
+    
+    void PopulateFilenames(const std::string& wildcard_path);
+
+    void PopulateFilenamesFromJson(const std::string& filename);
+
+    bool LoadFrame(size_t i);
+
+    void ConfigureStreamSizes();
+    
+    std::vector<StreamInfo> streams;
+    size_t size_bytes;
+    
+    size_t num_files;
+    size_t num_channels;
+    size_t next_frame_id;
+    std::vector<std::vector<std::string> > filenames;
+    std::vector<Frame> loaded;
+
+    bool unknowns_are_raw;
+    PixelFormat raw_fmt;
+    size_t raw_width;
+    size_t raw_height;
+    size_t raw_pitch;
+
+    // Load any json properties if they are defined
+    picojson::value device_properties;
+    picojson::value json_frames;
+    picojson::value null_props;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/images_out.h

@@ -0,0 +1,60 @@
+/* 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 <fstream>
+#include <pangolin/video/video_output_interface.h>
+#include <pangolin/log/packetstream_writer.h>
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT ImagesVideoOutput : public VideoOutputInterface
+{
+public:
+    ImagesVideoOutput(const std::string& image_folder, const std::string& json_file_out, const std::string &image_file_extension);
+    ~ImagesVideoOutput();
+
+    const std::vector<StreamInfo>& Streams() const override;
+    void SetStreams(const std::vector<StreamInfo>& streams, const std::string& uri, const picojson::value& device_properties) override;
+    int WriteStreams(const unsigned char* data, const picojson::value& frame_properties) override;
+    bool IsPipe() const override;
+
+protected:
+    std::vector<StreamInfo> streams;
+    std::string input_uri;
+    picojson::value device_properties;
+    picojson::value json_frames;
+
+    size_t image_index;
+    std::string image_folder;
+    std::string image_file_extension;
+    std::ofstream file;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/join.h

@@ -0,0 +1,80 @@
+/* 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/video/video_interface.h>
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT JoinVideo
+    : public VideoInterface, public VideoFilterInterface
+{
+public:
+    JoinVideo(std::vector<std::unique_ptr<VideoInterface>> &src, const bool verbose);
+
+    ~JoinVideo();
+
+    // Explicitly delete copy ctor and assignment operator.
+    // See http://stackoverflow.com/questions/29565299/how-to-use-a-vector-of-unique-pointers-in-a-dll-exported-class-with-visual-studi
+    // >> It appears adding __declspec(dllexport) forces the compiler to define the implicitly-declared copy constructor and copy assignment operator
+    JoinVideo(const JoinVideo&) = delete;
+    JoinVideo& operator=(const JoinVideo&) = delete;
+
+    size_t SizeBytes() const;
+
+    const std::vector<StreamInfo>& Streams() const;
+
+    void Start();
+
+    void Stop();
+
+    bool Sync(int64_t tolerance_us, double transfer_bandwidth_gbps = 0);
+
+    bool GrabNext( unsigned char* image, bool wait = true );
+
+    bool GrabNewest( unsigned char* image, bool wait = true );
+
+    std::vector<VideoInterface*>& InputStreams();
+
+protected:
+    int64_t GetAdjustedCaptureTime(size_t src_index);
+
+    std::vector<std::unique_ptr<VideoInterface>> storage;
+    std::vector<VideoInterface*> src;
+    std::vector<bool> frame_seen;
+    std::vector<StreamInfo> streams;
+    size_t size_bytes;
+
+    int64_t sync_tolerance_us;
+    int64_t transfer_bandwidth_bytes_per_us;
+    bool verbose;
+};
+
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/merge.h

@@ -0,0 +1,69 @@
+/* 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/video/video_interface.h>
+#include <pangolin/video/iostream_operators.h>
+
+namespace pangolin
+{
+
+// Take N streams, and place them into one big buffer.
+class PANGOLIN_EXPORT MergeVideo : public VideoInterface, public VideoFilterInterface
+{
+public:
+    MergeVideo(std::unique_ptr<VideoInterface>& src, const std::vector<Point>& stream_pos, size_t w, size_t h);
+    ~MergeVideo();
+    
+    void Start() override;
+    
+    void Stop() override;
+
+    size_t SizeBytes() const override;
+
+    const std::vector<StreamInfo>& Streams() const override;
+    
+    bool GrabNext( unsigned char* image, bool wait = true ) override;
+    
+    bool GrabNewest( unsigned char* image, bool wait = true ) override;
+
+    std::vector<VideoInterface*>& InputStreams() override;
+    
+protected:
+    void CopyBuffer(unsigned char* dst_bytes, unsigned char* src_bytes);
+
+    std::unique_ptr<VideoInterface> src;
+    std::vector<VideoInterface*> videoin;
+    std::unique_ptr<uint8_t[]> buffer;
+    std::vector<Point> stream_pos;
+
+    std::vector<StreamInfo> streams;
+    size_t size_bytes;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/mjpeg.h

@@ -0,0 +1,77 @@
+/* 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/video/video_interface.h>
+#include <pangolin/image/typed_image.h>
+#include <fstream>
+
+namespace pangolin
+{
+
+// Video class that outputs test video signal.
+class PANGOLIN_EXPORT MjpegVideo : public VideoInterface, public VideoPlaybackInterface
+{
+public:
+    MjpegVideo(const std::string& filename);
+    ~MjpegVideo();
+
+    //! Implement VideoInput::Start()
+    void Start() override;
+
+    //! Implement VideoInput::Stop()
+    void Stop() override;
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const override;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const override;
+
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true ) override;
+
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true ) override;
+
+    size_t GetCurrentFrameId() const override;
+    size_t GetTotalFrames() const override;
+    size_t Seek(size_t frameid) override;
+
+protected:
+    bool LoadNext();
+
+    std::vector<StreamInfo> streams;
+    size_t size_bytes;
+    std::ifstream bFile;
+    TypedImage next_image;
+    std::vector<std::streampos> offsets;
+    size_t next_frame_id;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/openni.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <pangolin/video/video_interface.h>
+#include <pangolin/video/drivers/openni_common.h>
+
+// Workaround poor OpenNI Platform test on Linux before including XnCppWrapper.h
+// See https://github.com/dennishamester/OpenNI/commit/ca99f6181234c682bba42a6ba
+#ifdef _LINUX_
+#define linux 1
+#endif // _LINUX_
+
+// OpenNI generates SO MANY warnings, we'll just disable all for this header(!)
+// GCC and clang will listen to this pramga.
+#ifdef __GNUC__
+#pragma GCC system_header
+#endif
+#include <XnCppWrapper.h>
+
+namespace pangolin
+{
+
+//! Interface to video capture sources
+struct PANGOLIN_EXPORT OpenNiVideo : public VideoInterface
+{
+public:
+    OpenNiVideo(OpenNiSensorType s1, OpenNiSensorType s2, ImageDim dim = ImageDim(640,480), int fps = 30);
+    ~OpenNiVideo();
+
+    //! Implement VideoInput::Start()
+    void Start();
+    
+    //! Implement VideoInput::Stop()
+    void Stop();
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const;
+    
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true );
+    
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true );
+
+    void SetAutoExposure(bool enabled)
+    {
+#if XN_MINOR_VERSION > 5 || (XN_MINOR_VERSION == 5 && XN_BUILD_VERSION >= 7)
+        if(imageNode.IsValid()) {
+            imageNode.GetAutoExposureCap().Set(enabled ? 1 : 0);
+        }
+#else
+        throw pangolin::VideoException("SetAutoExposure Not supported for this version of OpenNI.");
+#endif
+    }
+    
+protected:
+    std::vector<StreamInfo> streams;
+    OpenNiSensorType sensor_type[2];
+    
+    xn::Context context;
+    xn::DepthGenerator depthNode;
+    xn::ImageGenerator imageNode;
+    xn::IRGenerator irNode;
+    
+    size_t sizeBytes;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/openni2.h

@@ -0,0 +1,145 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Richard Newcombe
+ *               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/video/video_interface.h>
+#include <pangolin/video/drivers/openni_common.h>
+
+#include <OpenNI.h>
+
+namespace pangolin
+{
+const int MAX_OPENNI2_STREAMS = 2 * ONI_MAX_SENSORS;
+
+//! Interface to video capture sources
+struct OpenNi2Video : public VideoInterface, public VideoPropertiesInterface, public VideoPlaybackInterface
+{
+public:
+
+    // Open all RGB and Depth streams from all devices
+    OpenNi2Video(ImageDim dim=ImageDim(640,480), ImageRoi roi=ImageRoi(0,0,0,0), int fps=30);
+
+    // Open streams specified
+    OpenNi2Video(std::vector<OpenNiStreamMode>& stream_modes);
+
+    // Open openni file
+    OpenNi2Video(const std::string& filename);
+
+    // Open openni file with certain params
+    OpenNi2Video(const std::string& filename, std::vector<OpenNiStreamMode>& stream_modes);
+    
+    void UpdateProperties();
+
+    void SetMirroring(bool enable);
+    void SetAutoExposure(bool enable);
+    void SetAutoWhiteBalance(bool enable);
+    void SetDepthCloseRange(bool enable);
+    void SetDepthHoleFilter(bool enable);
+    void SetDepthColorSyncEnabled(bool enable);
+    void SetFastCrop(bool enable);
+    void SetRegisterDepthToImage(bool enable);
+    void SetPlaybackSpeed(float speed);
+    void SetPlaybackRepeat(bool enabled);
+
+    ~OpenNi2Video();
+
+    //! Implement VideoInput::Start()
+    void Start() override;
+
+    //! Implement VideoInput::Stop()
+    void Stop() override;
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const override;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const override;
+
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true ) override;
+
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true ) override;
+
+    //! Implement VideoPropertiesInterface::Properties()
+    const picojson::value& DeviceProperties() const  override{
+        return device_properties;
+    }
+
+    //! Implement VideoPropertiesInterface::Properties()
+    const picojson::value& FrameProperties() const  override{
+        return frame_properties;
+    }
+
+    //! Implement VideoPlaybackInterface::GetCurrentFrameId
+    size_t GetCurrentFrameId() const override;
+
+    //! Implement VideoPlaybackInterface::GetTotalFrames
+    size_t GetTotalFrames() const override;
+
+    //! Implement VideoPlaybackInterface::Seek
+    size_t Seek(size_t frameid) override;
+
+    openni::VideoStream* GetVideoStream(int stream);
+
+protected:
+    void InitialiseOpenNI();
+    int AddDevice(const std::string& device_uri);
+    void AddStream(const OpenNiStreamMode& mode);
+    void SetupStreamModes();
+    void PrintOpenNI2Modes(openni::SensorType sensorType);
+    openni::VideoMode FindOpenNI2Mode(openni::Device &device, openni::SensorType sensorType, int width, int height, int fps, openni::PixelFormat fmt );
+
+    size_t numDevices;
+    size_t numStreams;
+
+    openni::Device devices[ONI_MAX_SENSORS];
+    OpenNiStreamMode sensor_type[ONI_MAX_SENSORS];
+
+    openni::VideoStream video_stream[ONI_MAX_SENSORS];
+    openni::VideoFrameRef video_frame[ONI_MAX_SENSORS];
+
+    std::vector<StreamInfo> streams;
+    size_t sizeBytes;
+
+    picojson::value device_properties;
+    picojson::value frame_properties;
+    picojson::value* streams_properties;
+
+    bool use_depth;
+    bool use_ir;
+    bool use_rgb;
+    bool depth_to_color;
+    bool use_ir_and_rgb;
+
+    size_t current_frame_index;
+    size_t total_frames;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/openni_common.h

@@ -0,0 +1,154 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *               2015 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/video/iostream_operators.h>
+#include <pangolin/utils/type_convert.h>
+
+namespace pangolin
+{
+
+enum OpenNiSensorType
+{
+    OpenNiUnassigned = -1,
+    OpenNiRgb = 0,
+    OpenNiIr,
+    OpenNiDepth_1mm,
+    OpenNiDepth_1mm_Registered,
+    OpenNiDepth_100um,
+    OpenNiIr8bit,
+    OpenNiIr24bit,
+    OpenNiIrProj,
+    OpenNiIr8bitProj,
+    OpenNiGrey
+};
+
+struct PANGOLIN_EXPORT OpenNiStreamMode
+{
+    OpenNiStreamMode(
+        OpenNiSensorType sensor_type=OpenNiUnassigned,
+        ImageDim dim=ImageDim(640,480), ImageRoi roi=ImageRoi(0,0,0,0), int fps=30, int device=0
+    )
+        : sensor_type(sensor_type), dim(dim), roi(roi), fps(fps), device(device)
+    {
+
+    }
+
+    OpenNiSensorType sensor_type;
+    ImageDim dim;
+    ImageRoi roi;
+    int fps;
+    int device;
+};
+
+inline OpenNiSensorType openni_sensor(const std::string& str)
+{
+    if( !str.compare("grey") || !str.compare("gray") ) {
+        return OpenNiGrey;
+    }else if( !str.compare("rgb") ) {
+        return OpenNiRgb;
+    }else if( !str.compare("ir") ) {
+        return OpenNiIr;
+    }else if( !str.compare("depth1mm") || !str.compare("depth") ) {
+        return OpenNiDepth_1mm;
+    }else if( !str.compare("depth100um") ) {
+        return OpenNiDepth_100um;
+    }else if( !str.compare("depth_reg") || !str.compare("reg_depth")) {
+        return OpenNiDepth_1mm_Registered;
+    }else if( !str.compare("ir8") ) {
+        return OpenNiIr8bit;
+    }else if( !str.compare("ir24") ) {
+        return OpenNiIr24bit;
+    }else if( !str.compare("ir+") ) {
+        return OpenNiIrProj;
+    }else if( !str.compare("ir8+") ) {
+        return OpenNiIr8bitProj;
+    }else if( str.empty() ) {
+        return OpenNiUnassigned;
+    }else{
+        throw pangolin::VideoException("Unknown OpenNi sensor", str );
+    }
+}
+
+// Find prefix character key
+// Given arguments "depth!5:320x240@15", "!:@", would return map
+// \0->"depth", !->"5", :->"320x240", @->"15"
+inline std::map<char,std::string> GetTokenSplits(const std::string& str, const std::string& tokens)
+{
+    std::map<char,std::string> splits;
+
+    char last_token = 0;
+    size_t  last_start = 0;
+    for(unsigned int i=0; i<str.size(); ++i) {
+        size_t token_pos = tokens.find(str[i]);
+        if(token_pos != std::string::npos) {
+            splits[last_token] = str.substr(last_start, i-last_start);
+            last_token = tokens[token_pos];
+            last_start = i+1;
+        }
+    }
+
+    if(last_start < str.size()) {
+        splits[last_token] = str.substr(last_start);
+    }
+
+    return splits;
+}
+
+inline std::istream& operator>> (std::istream &is, OpenNiStreamMode& fmt)
+{
+    std::string str;
+    is >> str;
+
+    std::map<char,std::string> splits = GetTokenSplits(str, "!:@#");
+
+    if(splits.count(0)) {
+        fmt.sensor_type = openni_sensor(splits[0]);
+    }
+
+    if(splits.count('@')) {
+        fmt.fps = pangolin::Convert<int,std::string>::Do(splits['@']);
+    }
+
+    if(splits.count(':')) {
+        fmt.dim = pangolin::Convert<ImageDim,std::string>::Do(splits[':']);
+    }
+
+    if(splits.count('!')) {
+        fmt.device = pangolin::Convert<int,std::string>::Do(splits['!']);
+    }
+
+    if(splits.count('#')) {
+        fmt.roi = pangolin::Convert<ImageRoi,std::string>::Do(splits['#']);
+    }
+
+    return is;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/pack.h

@@ -0,0 +1,83 @@
+/* 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/video/video_interface.h>
+
+namespace pangolin
+{
+
+// Video class that packs its video input using the given method.
+class PANGOLIN_EXPORT PackVideo :
+    public VideoInterface,
+    public VideoFilterInterface,
+    public BufferAwareVideoInterface
+{
+public:
+    PackVideo(std::unique_ptr<VideoInterface>& videoin, PixelFormat new_fmt);
+    ~PackVideo();
+
+    //! Implement VideoInput::Start()
+    void Start();
+
+    //! Implement VideoInput::Stop()
+    void Stop();
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const;
+
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true );
+
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true );
+
+    //! Implement VideoFilterInterface method
+    std::vector<VideoInterface*>& InputStreams();
+
+    uint32_t AvailableFrames() const;
+
+    bool DropNFrames(uint32_t n);
+
+protected:
+    void Process(unsigned char* image, const unsigned char* buffer);
+
+    std::unique_ptr<VideoInterface> src;
+    std::vector<VideoInterface*> videoin;
+    std::vector<StreamInfo> streams;
+    size_t size_bytes;
+    unsigned char* buffer;
+
+    picojson::value device_properties;
+    picojson::value frame_properties;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/pango.h

@@ -0,0 +1,105 @@
+/* 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/video/video_interface.h>
+#include <pangolin/video/stream_encoder_factory.h>
+#include <pangolin/log/packetstream_reader.h>
+#include <pangolin/log/playback_session.h>
+#include <pangolin/utils/signal_slot.h>
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT PangoVideo
+    : public VideoInterface, public VideoPropertiesInterface, public VideoPlaybackInterface
+{
+public:
+    PangoVideo(const std::string& filename, std::shared_ptr<PlaybackSession> playback_session);
+    ~PangoVideo();
+
+    // Implement VideoInterface
+
+    size_t SizeBytes() const override;
+
+    const std::vector<StreamInfo>& Streams() const override;
+
+    void Start() override;
+
+    void Stop() override;
+
+    bool GrabNext( unsigned char* image, bool wait = true ) override;
+
+    bool GrabNewest( unsigned char* image, bool wait = true ) override;
+
+    // Implement VideoPropertiesInterface
+    const picojson::value& DeviceProperties() const override {
+        if (-1 == _src_id) throw std::runtime_error("Not initialised");
+        return _device_properties;
+    }
+
+    const picojson::value& FrameProperties() const override {
+        return _frame_properties;
+    }
+
+    // Implement VideoPlaybackInterface
+
+    size_t GetCurrentFrameId() const override;
+
+    size_t GetTotalFrames() const override;
+
+    size_t Seek(size_t frameid) override;
+
+    std::string GetSourceUri();
+
+private:
+    void HandlePipeClosed();
+
+protected:
+    int FindPacketStreamSource();
+    void SetupStreams(const PacketStreamSource& src);
+
+    const std::string _filename;
+    std::shared_ptr<PlaybackSession> _playback_session;
+    std::shared_ptr<PacketStreamReader> _reader;
+    SyncTimeEventPromise _event_promise;
+    int _src_id;
+    const PacketStreamSource* _source;
+
+    size_t _size_bytes;
+    bool _fixed_size;
+    std::vector<StreamInfo> _streams;
+    std::vector<ImageDecoderFunc> stream_decoder;
+    picojson::value _device_properties;
+    picojson::value _frame_properties;
+    std::string _source_uri;
+
+    sigslot::scoped_connection session_seek;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/pango_video_output.h

@@ -0,0 +1,69 @@
+/* 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/video/video_output_interface.h>
+#include <pangolin/log/packetstream_writer.h>
+#include <pangolin/video/stream_encoder_factory.h>
+
+#include <functional>
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT PangoVideoOutput : public VideoOutputInterface
+{
+public:
+    PangoVideoOutput(const std::string& filename, size_t buffer_size_bytes, const std::map<size_t, std::string> &stream_encoder_uris);
+    ~PangoVideoOutput();
+
+    const std::vector<StreamInfo>& Streams() const override;
+    void SetStreams(const std::vector<StreamInfo>& streams, const std::string& uri, const picojson::value& device_properties) override;
+    int WriteStreams(const unsigned char* data, const picojson::value& frame_properties) override;
+    bool IsPipe() const override;
+
+protected:
+//    void WriteHeader();
+
+    std::vector<StreamInfo> streams;
+    std::string input_uri;
+    const std::string filename;
+    picojson::value device_properties;
+
+    PacketStreamWriter packetstream;
+    size_t packetstream_buffer_size_bytes;
+    int packetstreamsrcid;
+    size_t total_frame_size;
+    bool is_pipe;
+
+    bool fixed_size;
+    std::map<size_t, std::string> stream_encoder_uris;
+    std::vector<ImageEncoderFunc> stream_encoders;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/pleora.h

@@ -0,0 +1,195 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2015 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/video/video_interface.h>
+
+#include <PvDevice.h>
+#include <PvDeviceGEV.h>
+#include <PvDeviceU3V.h>
+#include <PvStream.h>
+#include <PvStreamGEV.h>
+#include <PvStreamU3V.h>
+#include <PvBuffer.h>
+
+#include <PvSystem.h>
+
+#include <stdlib.h>
+#include <list>
+
+namespace pangolin
+{
+
+struct GrabbedBuffer {
+
+  inline GrabbedBuffer(PvBuffer* b,PvResult r,bool v)
+      : buff(b), res(r), valid(v)
+  {
+  }
+
+  PvBuffer* buff;
+  PvResult res;
+  bool valid;
+
+};
+
+typedef std::list<GrabbedBuffer> GrabbedBufferList;
+
+typedef std::list<PvBuffer *> BufferList;
+
+class PANGOLIN_EXPORT PleoraVideo : public VideoInterface, public VideoPropertiesInterface,
+        public BufferAwareVideoInterface, public GenicamVideoInterface
+{
+public:
+
+    static const size_t DEFAULT_BUFFER_COUNT = 30;
+
+    PleoraVideo(const Params& p);
+
+    ~PleoraVideo();
+
+    void Start();
+
+    void Stop();
+
+    size_t SizeBytes() const;
+
+    const std::vector<StreamInfo>& Streams() const;
+
+    bool GrabNext( unsigned char* image, bool wait = true );
+
+    bool GrabNewest( unsigned char* image, bool wait = true );
+
+    std::string GetParameter(const std::string& name);
+
+    void SetParameter(const std::string& name, const std::string& value);
+
+    void SetGain(int64_t val);
+
+    int64_t GetGain();
+
+    void SetAnalogBlackLevel(int64_t val);
+
+    int64_t GetAnalogBlackLevel();
+
+    void SetExposure(double val);
+
+    double GetExposure();
+
+    void SetGamma(double val);
+
+    double GetGamma();
+
+
+
+    void SetupTrigger(bool triggerActive, int64_t triggerSource, int64_t acquisitionMode);
+
+    const picojson::value& DeviceProperties() const {
+        return device_properties;
+    }
+
+    const picojson::value& FrameProperties() const {
+        return frame_properties;
+    }
+
+    uint32_t AvailableFrames() const;
+
+    bool DropNFrames(uint32_t n);
+
+protected:
+
+    void InitDevice(const char *model_name, const char *serial_num, size_t index);
+
+    void DeinitDevice();
+
+    void SetDeviceParams(Params& p);
+
+    void InitStream();
+
+    void DeinitStream();
+
+    void InitPangoStreams();
+
+    void InitPangoDeviceProperties();
+
+    void InitBuffers(size_t buffer_count);
+
+    void DeinitBuffers();
+
+    template<typename T>
+    T DeviceParam(const char* name);
+
+    template<typename T>
+    bool SetDeviceParam(const char* name, T val);
+
+    template<typename T>
+    T StreamParam(const char* name);
+
+    template<typename T>
+    bool SetStreamParam(const char* name, T val);
+
+    bool ParseBuffer(PvBuffer* lBuffer,  unsigned char* image);
+
+    void RetriveAllAvailableBuffers(uint32_t timeout);
+
+    std::vector<StreamInfo> streams;
+    picojson::value device_properties;
+    picojson::value frame_properties;
+
+    size_t size_bytes;
+
+    // Pleora handles
+    PvSystem* lPvSystem;
+    const PvDeviceInfo* lDeviceInfo;
+    PvDevice* lDevice;
+    PvStream* lStream;
+
+    // Genicam device parameters
+    PvGenParameterArray* lDeviceParams;
+    PvGenCommand* lStart;
+    PvGenCommand* lStop;
+
+    PvGenInteger* lAnalogGain;
+    PvGenInteger* lAnalogBlackLevel;
+    PvGenFloat*   lExposure;
+    PvGenFloat*   lGamma;
+    PvGenEnum*    lAquisitionMode;
+    PvGenEnum*    lTriggerSource;
+    PvGenEnum*    lTriggerMode;
+    PvGenFloat*   lTemperatureCelcius;
+    bool getTemp;
+
+    // Genicam stream parameters
+    PvGenParameterArray* lStreamParams;
+
+    BufferList lBufferList;
+    GrabbedBufferList lGrabbedBuffList;
+    uint32_t validGrabbedBuffers;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/realsense.h

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <pangolin/video/video_interface.h>
+#include <pangolin/video/iostream_operators.h>
+
+namespace rs {
+class context;
+class device;
+}
+
+namespace pangolin
+{
+
+//! Interface to video capture sources
+struct RealSenseVideo : public VideoInterface, public VideoPropertiesInterface, public VideoPlaybackInterface
+{
+public:
+
+    // Open all RGB and Depth streams from all devices
+    RealSenseVideo(ImageDim dim=ImageDim(640,480), int fps=30);
+
+    ~RealSenseVideo();
+
+    //! Implement VideoInput::Start()
+    void Start() override;
+
+    //! Implement VideoInput::Stop()
+    void Stop() override;
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const override;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const override;
+
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true ) override;
+
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true ) override;
+
+    //! Implement VideoPropertiesInterface::Properties()
+    const picojson::value& DeviceProperties() const override {
+        return device_properties;
+    }
+
+    //! Implement VideoPropertiesInterface::Properties()
+    const picojson::value& FrameProperties() const override {
+        return frame_properties;
+    }
+
+    //! Implement VideoPlaybackInterface::GetCurrentFrameId
+    size_t GetCurrentFrameId() const override;
+
+    //! Implement VideoPlaybackInterface::GetTotalFrames
+    size_t GetTotalFrames() const override;
+
+    //! Implement VideoPlaybackInterface::Seek
+    size_t Seek(size_t frameid) override;
+
+protected:
+    size_t sizeBytes;
+
+    std::vector<StreamInfo> streams;
+
+    picojson::value device_properties;
+    picojson::value frame_properties;
+    picojson::value* streams_properties;
+
+    size_t current_frame_index;
+    size_t total_frames;
+
+    rs::context* ctx_;
+    std::vector<rs::device*> devs_;
+
+    ImageDim  dim_;
+    size_t fps_;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_video/include/pangolin/video/drivers/realsense2.h

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <pangolin/video/video_interface.h>
+#include <pangolin/video/iostream_operators.h>
+
+namespace rs2 {
+class pipeline;
+class config;
+}
+
+namespace pangolin
+{
+
+//! Interface to video capture sources
+struct RealSense2Video : public VideoInterface, public VideoPropertiesInterface, public VideoPlaybackInterface
+{
+public:
+
+    // Open all RGB and Depth streams from all devices
+    RealSense2Video(ImageDim dim=ImageDim(640,480), int fps=30);
+
+    ~RealSense2Video();
+
+    //! Implement VideoInput::Start()
+    void Start() override;
+
+    //! Implement VideoInput::Stop()
+    void Stop() override;
+
+    //! Implement VideoInput::SizeBytes()
+    size_t SizeBytes() const override;
+
+    //! Implement VideoInput::Streams()
+    const std::vector<StreamInfo>& Streams() const override;
+
+    //! Implement VideoInput::GrabNext()
+    bool GrabNext( unsigned char* image, bool wait = true ) override;
+
+    //! Implement VideoInput::GrabNewest()
+    bool GrabNewest( unsigned char* image, bool wait = true ) override;
+
+    //! Implement VideoPropertiesInterface::Properties()
+    const picojson::value& DeviceProperties() const override {
+        return device_properties;
+    }
+
+    //! Implement VideoPropertiesInterface::Properties()
+    const picojson::value& FrameProperties() const override {
+        return frame_properties;
+    }
+
+    //! Implement VideoPlaybackInterface::GetCurrentFrameId
+    size_t GetCurrentFrameId() const override;
+
+    //! Implement VideoPlaybackInterface::GetTotalFrames
+    size_t GetTotalFrames() const override;
+
+    //! Implement VideoPlaybackInterface::Seek
+    size_t Seek(size_t frameid) override;
+
+protected:
+    size_t sizeBytes;
+
+    std::vector<StreamInfo> streams;
+
+    picojson::value device_properties;
+    picojson::value frame_properties;
+    picojson::value* streams_properties;
+
+    size_t current_frame_index;
+    size_t total_frames;
+
+    rs2::pipeline* pipe;
+    rs2::config* cfg;
+
+    ImageDim  dim_;
+    size_t fps_;
+};
+
+}