9f6ef56b47ab9a4a46bd6dcc26aaed5c1573071e90029486e391948c5a32e647

third-party/DPVO/Pangolin/components/pango_opengl/include/pangolin/gl/gltext.h

@@ -0,0 +1,96 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/gl/gl.h>
+#include <pangolin/gl/glchar.h>
+
+#include <vector>
+#include <string>
+
+namespace pangolin {
+
+class PANGOLIN_EXPORT GlText
+{
+public:
+    GlText();
+
+    GlText(const GlText& txt);
+
+    GlText(const GlTexture& font_tex);
+    
+    void AddSpace(GLfloat s);
+
+    // Add specified charector to this string.
+    void Add(unsigned char c, const GlChar& glc);
+
+    // Clear text
+    void Clear();
+
+    // Render without transform in text-centric pixel coordinates
+    void Draw() const;
+    void DrawGlSl() const;
+
+    // Render at (x,y,z)' in object coordinates,
+    // keeping text size and orientation constant
+    void Draw(GLfloat x, GLfloat y, GLfloat z = 0.0f) const;
+
+    // Render at (x,y,z)' in window coordinates.
+    void DrawWindow(GLfloat x, GLfloat y, GLfloat z = 0.0f) const;
+    
+    // Return text that this object signifies.
+    const std::string& Text() const {
+        return str;
+    }
+    
+    // Return width in pixels of this text.
+    GLfloat Width() const {
+        return width;
+    }
+
+    // Return height in pixels of this text.
+    GLfloat Height() const {
+        return ymax;
+    }
+    
+    // Return height in pixels of this text, including under baseline
+    GLfloat FullHeight() const {
+        return ymax - ymin;
+    }
+
+//protected:
+    const GlTexture* tex;
+    std::string str;
+    GLfloat width;
+    GLfloat ymin;
+    GLfloat ymax;
+    
+    std::vector<XYUV> vs;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_opengl/include/pangolin/gl/gltexturecache.h

@@ -0,0 +1,116 @@
+/* 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/gl/gl.h>
+#include <pangolin/gl/glformattraits.h>
+#include <pangolin/gl/glpixformat.h>
+#include <pangolin/image/image.h>
+
+#include <memory>
+#include <map>
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT TextureCache
+{
+public:
+    static TextureCache& I();
+
+    GlTexture& GlTex(GLsizei w, GLsizei h, GLint internal_format, GLint glformat, GLenum gltype)
+    {
+        const long key =
+            (((long)internal_format)<<20) ^
+            (((long)glformat)<<10) ^ gltype;
+
+        // Lookup texture
+        std::shared_ptr<GlTexture>& ptex = texture_map[key];
+        if(!ptex) {
+            ptex = std::shared_ptr<GlTexture>(new GlTexture());
+        }
+        GlTexture& tex = *ptex;
+
+        // Initialise if it didn't already exist or the size was too small
+        if(!tex.tid || tex.width < w || tex.height < h) {
+            tex.Reinitialise(
+                std::max(tex.width,w), std::max(tex.height,h),
+                internal_format, default_sampling_linear, 0,
+                glformat, gltype
+            );
+        }
+
+        return tex;
+    }
+
+    template<typename T>
+    GlTexture& GlTex(GLsizei w, GLsizei h)
+    {
+        return GlTex( w, h,
+            GlFormatTraits<T>::glinternalformat,
+            GlFormatTraits<T>::glformat,
+            GlFormatTraits<T>::gltype
+        );
+    }
+
+protected:
+    bool default_sampling_linear;
+    std::map<long, std::shared_ptr<GlTexture> > texture_map;
+
+    // Protected constructor
+    TextureCache()
+        : default_sampling_linear(true)
+    {
+    }
+};
+
+template<typename T>
+void RenderToViewport(Image<T>& image, bool flipx=false, bool flipy=false)
+{
+    // Retrieve texture that is at least as large as image and of appropriate type.
+    GlTexture& tex = TextureCache::I().GlTex<T>(image.w, image.h);
+    tex.Upload(image.ptr,0,0, image.w, image.h, GlFormatTraits<T>::glformat, GlFormatTraits<T>::gltype);
+    tex.RenderToViewport(Viewport(0,0,image.w, image.h), flipx, flipy);
+}
+
+// This method may dissapear in the future
+inline void RenderToViewport(
+    Image<unsigned char>& image,
+    const pangolin::GlPixFormat& fmt,
+    bool flipx=false, bool flipy=false,
+    bool linear_sampling = true
+) {
+    pangolin::GlTexture& tex = pangolin::TextureCache::I().GlTex((GLsizei)image.w, (GLsizei)image.h, fmt.scalable_internal_format, fmt.glformat, fmt.gltype);
+    tex.Bind();
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, linear_sampling ? GL_LINEAR : GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, linear_sampling ? GL_LINEAR : GL_NEAREST);
+    tex.Upload(image.ptr,0,0, (GLsizei)image.w, (GLsizei)image.h, fmt.glformat, fmt.gltype);
+    tex.RenderToViewport(pangolin::Viewport(0,0,(GLint)image.w, (GLint)image.h), flipx, flipy);
+}
+
+}

third-party/DPVO/Pangolin/components/pango_opengl/include/pangolin/gl/glvbo.h

@@ -0,0 +1,239 @@
+/* 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/gl.h>
+
+namespace pangolin
+{
+
+////////////////////////////////////////////////
+// Interface
+////////////////////////////////////////////////
+
+void MakeTriangleStripIboForVbo(GlBuffer& ibo, int w, int h);
+
+GlBuffer MakeTriangleStripIboForVbo(int w, int h);
+
+void RenderVbo(GlBuffer& vbo, GLenum mode = GL_POINTS);
+
+void RenderVbo(GlBuffer& vbo, const GLuint count, GLenum mode);
+
+void RenderVboCbo(GlBuffer& vbo, GlBuffer& cbo, bool draw_color = true, GLenum mode = GL_POINTS);
+
+void RenderVboIbo(GlBuffer& vbo, GlBuffer& ibo, bool draw_mesh = true);
+
+void RenderVboIboCbo(GlBuffer& vbo, GlBuffer& ibo, GlBuffer& cbo, bool draw_mesh = true, bool draw_color = true);
+
+void RenderVboIboNbo(GlBuffer& vbo, GlBuffer& ibo, GlBuffer& nbo, bool draw_mesh = true, bool draw_normals = true);
+
+void RenderVboIboCboNbo(GlBuffer& vbo, GlBuffer& ibo, GlBuffer& cbo, GlBuffer& nbo, bool draw_mesh = true, bool draw_color = true, bool draw_normals = true);
+
+////////////////////////////////////////////////
+// Implementation
+////////////////////////////////////////////////
+
+inline void MakeTriangleStripIboForVbo(GlBuffer& ibo, int w, int h)
+{
+    const int num_elements = w*(h-1)*2;
+    unsigned int* buffer = new unsigned int[num_elements];
+    unsigned int* ptr = buffer;
+    
+    for(int y=0; y < (h-1);)
+    {
+        for(int x=0; x<w; ++x) {
+            (*ptr++) = y*w+x;
+            (*ptr++) = (y+1)*w+x;
+        }
+        ++y;
+        
+        if(y>=(h-1)) break;        
+        for(int x=w-1; x>=0; --x) {
+            (*ptr++) = y*w+x;
+            (*ptr++) = (y+1)*w+x;
+        }
+        ++y;
+    }
+    
+    ibo.Reinitialise(GlElementArrayBuffer, num_elements, GL_UNSIGNED_INT, 1, GL_STATIC_DRAW );
+    ibo.Upload(buffer, sizeof(unsigned int)*num_elements );
+    
+    delete[] buffer;
+}
+
+inline GlBuffer MakeTriangleStripIboForVbo(int w, int h)
+{
+    GlBuffer ibo;
+    MakeTriangleStripIboForVbo(ibo,w,h);
+    return ibo;
+}
+
+inline void RenderVbo(GlBuffer& vbo, GLenum mode)
+{
+    vbo.Bind();
+    glVertexPointer(vbo.count_per_element, vbo.datatype, 0, 0);
+    glEnableClientState(GL_VERTEX_ARRAY);
+    
+    glDrawArrays(mode, 0, vbo.num_elements);
+    
+    glDisableClientState(GL_VERTEX_ARRAY);
+    vbo.Unbind();
+}
+
+inline void RenderVbo(GlBuffer& vbo, const GLuint count, GLenum mode)
+{
+    vbo.Bind();
+    glVertexPointer(vbo.count_per_element, vbo.datatype, 0, 0);
+    glEnableClientState(GL_VERTEX_ARRAY);
+
+    glDrawArrays(mode, 0, std::min(count, vbo.num_elements));
+
+    glDisableClientState(GL_VERTEX_ARRAY);
+    vbo.Unbind();
+}
+
+inline void RenderVboCbo(GlBuffer& vbo, GlBuffer& cbo, bool draw_color, GLenum mode )
+{
+    if(draw_color) {
+        cbo.Bind();
+        glColorPointer(cbo.count_per_element, cbo.datatype, 0, 0);
+        glEnableClientState(GL_COLOR_ARRAY);
+    }
+    
+    RenderVbo(vbo,mode);
+    
+    if(draw_color) {
+        glDisableClientState(GL_COLOR_ARRAY);
+        cbo.Unbind();
+    }
+}
+
+inline void RenderVboIbo(GlBuffer& vbo, GlBuffer& ibo, bool draw_mesh)
+{
+    vbo.Bind();
+    glVertexPointer(vbo.count_per_element, vbo.datatype, 0, 0);
+    glEnableClientState(GL_VERTEX_ARRAY);
+    
+    if(draw_mesh) {
+        ibo.Bind();
+        glDrawElements(GL_TRIANGLE_STRIP,ibo.num_elements, ibo.datatype, 0);
+        ibo.Unbind();
+    }else{
+        glDrawArrays(GL_POINTS, 0, vbo.num_elements);
+    }
+    
+    glDisableClientState(GL_VERTEX_ARRAY);
+    vbo.Unbind();
+}
+
+inline void RenderVboIboCbo(GlBuffer& vbo, GlBuffer& ibo, GlBuffer& cbo, bool draw_mesh, bool draw_color )
+{
+    if(draw_color) {
+        cbo.Bind();
+        glColorPointer(cbo.count_per_element, cbo.datatype, 0, 0);
+        glEnableClientState(GL_COLOR_ARRAY);
+    }
+    
+    RenderVboIbo(vbo,ibo,draw_mesh);
+    
+    if(draw_color) {
+        glDisableClientState(GL_COLOR_ARRAY);
+        cbo.Unbind();
+    }
+}
+
+inline void RenderVboIboCboNbo(GlBuffer& vbo, GlBuffer& ibo, GlBuffer& cbo, GlBuffer& nbo, bool draw_mesh, bool draw_color, bool draw_normals)
+{
+    if(draw_color) {
+        cbo.Bind();
+        glColorPointer(cbo.count_per_element, cbo.datatype, 0, 0);
+        glEnableClientState(GL_COLOR_ARRAY);
+    }
+    
+    if(draw_normals) {
+        nbo.Bind();
+        glNormalPointer(nbo.datatype, (GLsizei)(nbo.count_per_element * GlDataTypeBytes(nbo.datatype)),0);
+        glEnableClientState(GL_NORMAL_ARRAY);
+    }
+
+    vbo.Bind();
+    glVertexPointer(vbo.count_per_element, vbo.datatype, 0, 0);
+    glEnableClientState(GL_VERTEX_ARRAY);
+    
+    if(draw_mesh) {
+        ibo.Bind();
+        glDrawElements(GL_TRIANGLE_STRIP,ibo.num_elements, ibo.datatype, 0);
+        ibo.Unbind();
+    }else{
+        glDrawArrays(GL_POINTS, 0, vbo.num_elements);
+    }
+    
+    if(draw_color) {
+        glDisableClientState(GL_COLOR_ARRAY);
+        cbo.Unbind();
+    }
+    
+    if(draw_normals) {
+        glDisableClientState(GL_NORMAL_ARRAY);
+        nbo.Unbind();
+    }
+
+    glDisableClientState(GL_VERTEX_ARRAY);
+    vbo.Unbind();
+}
+
+inline void RenderVboIboNbo(GlBuffer& vbo, GlBuffer& ibo, GlBuffer& nbo, bool draw_mesh, bool draw_normals)
+{
+    vbo.Bind();
+    glVertexPointer(vbo.count_per_element, vbo.datatype, 0, 0);
+    glEnableClientState(GL_VERTEX_ARRAY);
+
+    if(draw_normals) {
+        nbo.Bind();
+        glNormalPointer(nbo.datatype, (GLsizei)(nbo.count_per_element * GlDataTypeBytes(nbo.datatype)), 0);
+        glEnableClientState(GL_NORMAL_ARRAY);
+    }
+
+    if(draw_mesh) {
+        ibo.Bind();
+        glDrawElements(GL_TRIANGLE_STRIP,ibo.num_elements, ibo.datatype, 0);
+        ibo.Unbind();
+    }else{
+        glDrawArrays(GL_POINTS, 0, vbo.num_elements);
+    }
+
+    if(draw_normals) {
+        glDisableClientState(GL_NORMAL_ARRAY);
+        nbo.Unbind();
+    }
+
+    glDisableClientState(GL_VERTEX_ARRAY);
+    vbo.Unbind();
+}
+
+}

third-party/DPVO/Pangolin/components/pango_opengl/include/pangolin/gl/opengl_render_state.h

@@ -0,0 +1,446 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/platform.h>
+#include <pangolin/utils/simple_math.h>
+
+#include <vector>
+
+#if defined(HAVE_EIGEN) && !defined(__CUDACC__) //prevent including Eigen in cuda files
+#define USE_EIGEN
+#endif
+
+#ifdef USE_EIGEN
+#include <Eigen/Core>
+#include <Eigen/Geometry>
+#endif
+
+#ifdef HAVE_TOON
+#include <cstring>
+#include <TooN/TooN.h>
+#include <TooN/se3.h>
+#endif
+
+#ifdef HAVE_OCULUS
+#include <pangolin/compat/ovr.h>
+#endif
+
+namespace pangolin {
+
+#ifdef HAVE_GLES
+    typedef float GLprecision;
+#else
+    typedef double GLprecision;
+#endif
+
+/// Capture OpenGL matrix types in enum to typing.
+enum OpenGlStack {
+    GlModelViewStack =  0x1700, // GL_MODELVIEW
+    GlProjectionStack = 0x1701, // GL_PROJECTION
+    GlTextureStack =    0x1702  // GL_TEXTURE
+};
+
+enum AxisDirection
+{
+    AxisNone,
+    AxisNegX, AxisX,
+    AxisNegY, AxisY,
+    AxisNegZ, AxisZ
+};
+
+struct CameraSpec {
+    GLprecision forward[3];
+    GLprecision up[3];
+    GLprecision right[3];
+    GLprecision img_up[2];
+    GLprecision img_right[2];
+};
+
+const static CameraSpec CameraSpecOpenGl = {{0,0,-1},{0,1,0},{1,0,0},{0,1},{1,0}};
+
+const static CameraSpec CameraSpecYDownZForward = {{0,0,1},{0,-1,0},{1,0,0},{0,-1},{1,0}};
+
+/// Direction vector for each AxisDirection enum
+const static GLprecision AxisDirectionVector[7][3] = {
+    {0,0,0},
+    {-1,0,0}, {1,0,0},
+    {0,-1,0}, {0,1,0},
+    {0,0,-1}, {0,0,1}
+};
+
+/// Object representing OpenGl Matrix.
+struct PANGOLIN_EXPORT OpenGlMatrix {
+    static OpenGlMatrix Translate(GLprecision x, GLprecision y, GLprecision z);
+    static OpenGlMatrix Scale(GLprecision x, GLprecision y, GLprecision z);
+    static OpenGlMatrix RotateX(GLprecision theta_rad);
+    static OpenGlMatrix RotateY(GLprecision theta_rad);
+    static OpenGlMatrix RotateZ(GLprecision theta_rad);
+
+
+    template<typename P>
+    static OpenGlMatrix ColMajor4x4(const P* col_major_4x4);
+    
+    OpenGlMatrix();
+    
+#ifdef USE_EIGEN
+    template<typename P>
+    OpenGlMatrix(const Eigen::Matrix<P,4,4>& mat);
+
+    template<typename P>
+    OpenGlMatrix(const Eigen::Transform<P,3,Eigen::Affine>& mat) : OpenGlMatrix(mat.matrix()) { }
+    
+    template<typename P>
+    operator Eigen::Matrix<P,4,4>() const;
+
+    template<typename P>
+    operator Eigen::Transform<P,3,Eigen::Affine>() const;
+#endif // USE_EIGEN
+
+#ifdef HAVE_TOON
+    OpenGlMatrix(const TooN::SE3<>& T);
+    OpenGlMatrix(const TooN::Matrix<4,4>& M);
+    operator const TooN::SE3<>() const;
+    operator const TooN::Matrix<4,4>() const;
+#endif // HAVE_TOON    
+
+#ifdef HAVE_OCULUS
+    OpenGlMatrix(const OVR::Matrix4f& M);
+    operator const OVR::Matrix4f() const;
+#endif // HAVE_OCULUS
+    
+    // Load matrix on to OpenGl stack
+    void Load() const;
+    
+    void Multiply() const;
+    
+    void SetIdentity();
+    
+    OpenGlMatrix Transpose() const;
+    
+    OpenGlMatrix Inverse() const;
+
+    GLprecision& operator()(int r, int c) {
+        return m[4*c +r];
+    }
+
+    GLprecision operator()(int r, int c) const {
+        return m[4 * c + r];
+    }
+    
+    // Column major Internal buffer
+    GLprecision m[16];
+};
+
+PANGOLIN_EXPORT
+OpenGlMatrix operator*(const OpenGlMatrix& lhs, const OpenGlMatrix& rhs);
+
+PANGOLIN_EXPORT
+std::ostream& operator<<(std::ostream& os, const OpenGlMatrix& mat);
+
+/// Deprecated.
+struct PANGOLIN_EXPORT OpenGlMatrixSpec : public OpenGlMatrix {
+    // Specify which stack this refers to
+    OpenGlStack type;
+};
+
+/// Object representing attached OpenGl Matrices / transforms.
+class PANGOLIN_EXPORT OpenGlRenderState
+{
+public:
+    OpenGlRenderState();
+    OpenGlRenderState(const OpenGlMatrix& projection_matrix);
+    OpenGlRenderState(const OpenGlMatrix& projection_matrix, const OpenGlMatrix& modelview_matrix);
+    
+    static void ApplyIdentity();
+    
+    void Apply() const;
+    OpenGlRenderState& SetProjectionMatrix(OpenGlMatrix m);
+    OpenGlRenderState& SetModelViewMatrix(OpenGlMatrix m);
+
+    OpenGlMatrix& GetProjectionMatrix();
+    OpenGlMatrix GetProjectionMatrix() const;
+    
+    OpenGlMatrix& GetModelViewMatrix();
+    OpenGlMatrix GetModelViewMatrix() const;
+    
+    OpenGlMatrix GetProjectionModelViewMatrix() const;
+    OpenGlMatrix GetProjectiveTextureMatrix() const;
+    
+    void EnableProjectiveTexturing() const;
+    void DisableProjectiveTexturing() const;
+    
+    //! Seemlessly move OpenGl camera relative to changes in T_wc,
+    //! whilst still enabling interaction
+    void Follow(const OpenGlMatrix& T_wc, bool follow = true);
+    void Unfollow();
+
+    // Experimental - subject to change
+    OpenGlMatrix& GetProjectionMatrix(unsigned int view);
+    OpenGlMatrix GetProjectionMatrix(unsigned int view) const;
+    OpenGlMatrix& GetViewOffset(unsigned int view);
+    OpenGlMatrix GetViewOffset(unsigned int view) const;
+    OpenGlMatrix GetModelViewMatrix(int i) const;
+    void ApplyNView(int view) const;
+    
+    PANGOLIN_DEPRECATED("Use SetProjectionMatrix() or SetModelViewMatrix() instead.")
+    OpenGlRenderState& Set(OpenGlMatrixSpec spec);
+    
+protected:
+    OpenGlMatrix modelview;
+    std::vector<OpenGlMatrix> projection;
+    std::vector<OpenGlMatrix> modelview_premult;
+    OpenGlMatrix T_cw;
+    bool follow;
+};
+
+PANGOLIN_EXPORT
+OpenGlMatrixSpec ProjectionMatrixRUB_BottomLeft(int w, int h, GLprecision fu, GLprecision fv, GLprecision u0, GLprecision v0, GLprecision zNear, GLprecision zFar );
+
+PANGOLIN_EXPORT
+OpenGlMatrixSpec ProjectionMatrixRUB_TopLeft(int w, int h, GLprecision fu, GLprecision fv, GLprecision u0, GLprecision v0, GLprecision zNear, GLprecision zFar );
+
+PANGOLIN_EXPORT
+OpenGlMatrixSpec ProjectionMatrixRDF_TopLeft(int w, int h, GLprecision fu, GLprecision fv, GLprecision u0, GLprecision v0, GLprecision zNear, GLprecision zFar );
+
+PANGOLIN_EXPORT
+OpenGlMatrixSpec ProjectionMatrixRDF_TopRight(int w, int h, GLprecision fu, GLprecision fv, GLprecision u0, GLprecision v0, GLprecision zNear, GLprecision zFar );
+
+PANGOLIN_EXPORT
+OpenGlMatrixSpec ProjectionMatrixRDF_BottomLeft(int w, int h, GLprecision fu, GLprecision fv, GLprecision u0, GLprecision v0, GLprecision zNear, GLprecision zFar );
+
+PANGOLIN_EXPORT
+OpenGlMatrixSpec ProjectionMatrixRDF_BottomRight(int w, int h, GLprecision fu, GLprecision fv, GLprecision u0, GLprecision v0, GLprecision zNear, GLprecision zFar );
+
+//! Use OpenGl's default frame RUB_BottomLeft
+PANGOLIN_EXPORT
+OpenGlMatrixSpec ProjectionMatrix(int w, int h, GLprecision fu, GLprecision fv, GLprecision u0, GLprecision v0, GLprecision zNear, GLprecision zFar );
+
+PANGOLIN_EXPORT
+OpenGlMatrixSpec ProjectionMatrixOrthographic(GLprecision l, GLprecision r, GLprecision b, GLprecision t, GLprecision n, GLprecision f );
+
+
+//! Generate glulookat style model view matrix, looking at (lx,ly,lz)
+//! X-Right, Y-Up, Z-Back
+PANGOLIN_EXPORT
+OpenGlMatrix ModelViewLookAtRUB(GLprecision ex, GLprecision ey, GLprecision ez, GLprecision lx, GLprecision ly, GLprecision lz, GLprecision ux, GLprecision uy, GLprecision uz);
+
+//! Generate glulookat style model view matrix, looking at (lx,ly,lz)
+//! X-Right, Y-Down, Z-Forward
+PANGOLIN_EXPORT
+OpenGlMatrix ModelViewLookAtRDF(GLprecision ex, GLprecision ey, GLprecision ez, GLprecision lx, GLprecision ly, GLprecision lz, GLprecision ux, GLprecision uy, GLprecision uz);
+
+//! Generate glulookat style model view matrix, OpenGL Default camera convention (XYZ=RUB), looking at (lx,ly,lz)
+PANGOLIN_EXPORT
+OpenGlMatrix ModelViewLookAt(GLprecision x, GLprecision y, GLprecision z, GLprecision lx, GLprecision ly, GLprecision lz, AxisDirection up);
+
+PANGOLIN_EXPORT
+OpenGlMatrix ModelViewLookAt(GLprecision ex, GLprecision ey, GLprecision ez, GLprecision lx, GLprecision ly, GLprecision lz, GLprecision ux, GLprecision uy, GLprecision uz);
+
+
+PANGOLIN_EXPORT
+OpenGlMatrix IdentityMatrix();
+
+PANGOLIN_EXPORT
+OpenGlMatrixSpec IdentityMatrix(OpenGlStack type);
+
+PANGOLIN_EXPORT
+OpenGlMatrixSpec negIdentityMatrix(OpenGlStack type);
+
+#ifdef HAVE_TOON
+OpenGlMatrixSpec FromTooN(const TooN::SE3<>& T_cw);
+OpenGlMatrixSpec FromTooN(OpenGlStack type, const TooN::Matrix<4,4>& M);
+TooN::Matrix<4,4> ToTooN(const OpenGlMatrixSpec& ms);
+TooN::SE3<> ToTooN_SE3(const OpenGlMatrixSpec& ms);
+#endif
+
+#ifdef USE_EIGEN
+template<typename P>
+Eigen::Matrix<P,4,4> ToEigen(const OpenGlMatrix& ms);
+#endif
+
+}
+
+// Inline definitions
+namespace pangolin
+{
+
+template<typename P>
+inline OpenGlMatrix OpenGlMatrix::ColMajor4x4(const P* col_major_4x4)
+{
+    OpenGlMatrix mat;
+    std::copy(col_major_4x4, col_major_4x4 + 16, mat.m);
+    return mat;
+}
+
+inline OpenGlMatrix::OpenGlMatrix() {
+}
+
+#ifdef USE_EIGEN
+template<typename P> inline
+OpenGlMatrix::OpenGlMatrix(const Eigen::Matrix<P,4,4>& mat)
+{
+    for(int r=0; r<4; ++r ) {
+        for(int c=0; c<4; ++c ) {
+            m[c*4+r] = mat(r,c);
+        }
+    }
+}
+
+template<typename P>
+OpenGlMatrix::operator Eigen::Matrix<P,4,4>() const
+{
+    return ToEigen<P>(*this);
+}
+
+template<typename P>
+OpenGlMatrix::operator Eigen::Transform<P,3,Eigen::Affine>() const
+{
+    return Eigen::Transform<P,3,Eigen::Affine>(ToEigen<P>(*this));
+}
+
+template<typename P> inline
+Eigen::Matrix<P,4,4> ToEigen(const OpenGlMatrix& ms)
+{
+    Eigen::Matrix<P,4,4> mat;
+    for(int r=0; r<4; ++r ) {
+        for(int c=0; c<4; ++c ) {
+            mat(r,c) = (P)ms.m[c*4+r];
+        }
+    }
+    return mat;
+}
+
+#endif // USE_EIGEN
+
+#ifdef HAVE_TOON
+inline OpenGlMatrix::OpenGlMatrix(const TooN::SE3<>& T)
+{
+    TooN::Matrix<4,4,GLprecision,TooN::ColMajor> M;
+    M.slice<0,0,3,3>() = T.get_rotation().get_matrix();
+    M.T()[3].slice<0,3>() = T.get_translation();
+    M[3] = TooN::makeVector(0,0,0,1);
+    std::memcpy(m, &(M[0][0]),16*sizeof(GLprecision));
+}
+
+inline OpenGlMatrix::OpenGlMatrix(const TooN::Matrix<4,4>& M)
+{
+    // Read in remembering col-major convension for our matrices
+    int el = 0;
+    for(int c=0; c<4; ++c)
+        for(int r=0; r<4; ++r)
+            m[el++] = M[r][c];    
+}
+
+inline OpenGlMatrix::operator const TooN::SE3<>() const
+{
+    const TooN::Matrix<4,4> m = *this;
+    const TooN::SO3<> R(m.slice<0,0,3,3>());
+    const TooN::Vector<3> t = m.T()[3].slice<0,3>();
+    return TooN::SE3<>(R,t);    
+}
+
+inline OpenGlMatrix::operator const TooN::Matrix<4,4>() const
+{
+    TooN::Matrix<4,4> M;
+    int el = 0;
+    for( int c=0; c<4; ++c )
+        for( int r=0; r<4; ++r )
+            M(r,c) = m[el++];
+    return M;
+}
+
+PANGOLIN_DEPRECATED
+inline OpenGlMatrixSpec FromTooN(const TooN::SE3<>& T_cw)
+{
+    TooN::Matrix<4,4,GLprecision,TooN::ColMajor> M;
+    M.slice<0,0,3,3>() = T_cw.get_rotation().get_matrix();
+    M.T()[3].slice<0,3>() = T_cw.get_translation();
+    M[3] = TooN::makeVector(0,0,0,1);
+    
+    OpenGlMatrixSpec P;
+    P.type = GlModelViewStack;
+    std::memcpy(P.m, &(M[0][0]),16*sizeof(GLprecision));
+    return P;
+}
+
+PANGOLIN_DEPRECATED
+inline OpenGlMatrixSpec FromTooN(OpenGlStack type, const TooN::Matrix<4,4>& M)
+{
+    // Read in remembering col-major convension for our matrices
+    OpenGlMatrixSpec P;
+    P.type = type;
+    int el = 0;
+    for(int c=0; c<4; ++c)
+        for(int r=0; r<4; ++r)
+            P.m[el++] = M[r][c];
+    return P;
+}
+
+PANGOLIN_DEPRECATED
+inline TooN::Matrix<4,4> ToTooN(const OpenGlMatrix& ms)
+{
+    TooN::Matrix<4,4> m;
+    int el = 0;
+    for( int c=0; c<4; ++c )
+        for( int r=0; r<4; ++r )
+            m(r,c) = ms.m[el++];
+    return m;
+}
+
+PANGOLIN_DEPRECATED
+inline TooN::SE3<> ToTooN_SE3(const OpenGlMatrix& ms)
+{
+    TooN::Matrix<4,4> m = ms;
+    const TooN::SO3<> R(m.slice<0,0,3,3>());
+    const TooN::Vector<3> t = m.T()[3].slice<0,3>();
+    return TooN::SE3<>(R,t);
+}
+
+#endif // HAVE_TOON
+
+#ifdef HAVE_OCULUS
+inline OpenGlMatrix::OpenGlMatrix(const OVR::Matrix4f& mat)
+{
+    for(int r=0; r<4; ++r )
+        for(int c=0; c<4; ++c )
+            m[c*4+r] = mat.M[r][c];
+}
+
+inline OpenGlMatrix::operator const OVR::Matrix4f() const
+{
+    OVR::Matrix4f mat;
+    for(int r=0; r<4; ++r )
+        for(int c=0; c<4; ++c )
+            mat.M[r][c] = m[c*4+r];
+    return mat;
+}
+#endif // HAVE_OCULUS
+
+
+}

third-party/DPVO/Pangolin/components/pango_opengl/include/pangolin/gl/viewport.h

@@ -0,0 +1,63 @@
+/* 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/glinclude.h>
+
+namespace pangolin
+{
+
+/// Encapsulates OpenGl Viewport.
+struct PANGOLIN_EXPORT Viewport
+{
+    Viewport() : l(0),b(0),w(0),h(0) {}
+    Viewport(GLint l,GLint b,GLint w,GLint h) : l(l),b(b),w(w),h(h) {}
+    
+    void Activate() const;
+    void ActivateIdentity() const;
+    void ActivatePixelOrthographic() const;
+
+    void Scissor() const;
+    void ActivateAndScissor() const;
+
+    bool Contains(int x, int y) const;
+    
+    Viewport Inset(int i) const;
+    Viewport Inset(int horiz, int vert) const;
+    Viewport Intersect(const Viewport& vp) const;
+
+    static void DisableScissor();
+    
+    GLint r() const { return l+w;}
+    GLint t() const { return b+h;}
+    GLfloat aspect() const { return (GLfloat)w / (GLfloat)h; }
+    GLint area() const { return w * h; }
+    GLint l,b,w,h;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_opengl/src/compat/gl2engine.cpp

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

third-party/DPVO/Pangolin/components/pango_opengl/src/fonts/AnonymousPro.txt

@@ -0,0 +1,94 @@
+Copyright (c) 2009, Mark Simonson (http://www.ms-studio.com, [email protected]),
+with Reserved Font Name Anonymous Pro.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

third-party/DPVO/Pangolin/components/pango_opengl/src/glchar.cpp

@@ -0,0 +1,70 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/gl/glchar.h>
+
+namespace pangolin
+{
+
+GlChar::GlChar()
+    : x_step(0.0f)
+{
+    // Uninitialised
+}
+
+GlChar::GlChar(int tw, int th, int x, int y, int w, int h, GLfloat advance, GLfloat ox, GLfloat oy)
+    : x_step(advance)
+{
+    const GLfloat u = (GLfloat)x / (GLfloat)tw;
+    const GLfloat v = (GLfloat)y / (GLfloat)th;
+    const GLfloat u2 = (GLfloat)(x + w) / (GLfloat)tw;
+    const GLfloat v2 = (GLfloat)(y + h) / (GLfloat)th;
+
+    // Setup u,v tex coords
+    vs[0] = XYUV(ox, oy,     u,v );
+    vs[1] = XYUV(ox, oy-h,   u,v2 );
+    vs[2] = XYUV(w+ox, oy-h, u2,v2 );
+    vs[3] = XYUV(w+ox, oy,   u2,v );
+
+    y_min = oy-h;
+    y_max = oy;
+}
+
+void GlChar::Draw() const
+{
+    glVertexPointer(2, GL_FLOAT, sizeof(XYUV), &vs[0].x);
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glTexCoordPointer(2, GL_FLOAT, sizeof(XYUV), &vs[0].tu);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+    glEnable(GL_TEXTURE_2D);
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+    glDisable(GL_TEXTURE_2D);
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+}
+
+}

third-party/DPVO/Pangolin/components/pango_opengl/src/gldraw.cpp

@@ -0,0 +1,55 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove, Richard Newcombe
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+#include <pangolin/gl/gldraw.h>
+#include <pangolin/utils/timer.h>
+
+namespace pangolin
+{
+
+void glRecordGraphic(float x, float y, float radius)
+{
+    const int ticks = static_cast<int>(TimeNow_s());
+    if( ticks % 2 )
+    {
+        // now, render a little red "recording" dot
+#ifndef HAVE_GLES
+        glPushAttrib(GL_ENABLE_BIT);
+#endif
+        glDisable(GL_LIGHTING);
+        glDisable(GL_DEPTH_TEST);
+        glColor3f( 1.0f, 0.0f, 0.0f );
+        glDrawCircle( x, y, radius );
+#ifndef HAVE_GLES
+        glPopAttrib();
+#endif
+    }
+
+}
+
+}

third-party/DPVO/Pangolin/components/pango_opengl/src/glfont.cpp

@@ -0,0 +1,207 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/gl/glfont.h>
+#include <pangolin/gl/glstate.h>
+#include <pangolin/image/image_io.h>
+#include <pangolin/utils/type_convert.h>
+#include <pangolin/utils/file_utils.h>
+
+#if !defined(HAVE_GLES) || defined(HAVE_GLES_2)
+#include <pangolin/gl/glsl.h>
+#endif
+
+#define STB_TRUETYPE_IMPLEMENTATION
+#define STBTT_STATIC
+
+#if defined(__GNUC__)
+#  pragma GCC diagnostic push
+#  pragma GCC diagnostic ignored "-Wunused-function"
+#  include "stb_truetype.h"
+#  pragma GCC diagnostic pop
+#else
+#  include "stb_truetype.h"
+#endif
+
+#define MAX_TEXT_LENGTH 500
+
+// Embedded fonts:
+PANGOLIN_EXPORT extern const unsigned char AnonymousPro_ttf[];
+
+namespace pangolin
+{
+
+GlFont::GlFont(float pixel_height, int tex_w, int tex_h)
+{
+    InitialiseFont(AnonymousPro_ttf, pixel_height, tex_w, tex_h);
+}
+
+GlFont::GlFont(const unsigned char* ttf_buffer, float pixel_height, int tex_w, int tex_h)
+{
+    InitialiseFont(ttf_buffer, pixel_height, tex_w, tex_h);
+}
+
+GlFont::GlFont(const std::string& filename, float pixel_height, int tex_w, int tex_h)
+{
+    const std::string file_contents = GetFileContents(filename);
+    InitialiseFont(reinterpret_cast<const unsigned char*>(file_contents.data()), pixel_height, tex_w, tex_h);
+}
+
+GlFont::~GlFont()
+{
+    delete[] font_bitmap;
+}
+
+void GlFont::InitialiseFont(const unsigned char* ttf_buffer, float pixel_height, int tex_w, int tex_h)
+{
+    font_height_px = pixel_height;
+    font_max_width_px = 0;
+
+    this->tex_w = tex_w;
+    this->tex_h = tex_h;
+    font_bitmap = new unsigned char[tex_w*tex_h];
+    const int offset = 0;
+
+    stbtt_fontinfo f;
+    if (!stbtt_InitFont(&f, ttf_buffer, offset)) {
+       throw std::runtime_error("Unable to initialise font: stbtt_InitFont failed.");
+    }
+
+    float scale = stbtt_ScaleForPixelHeight(&f, pixel_height);
+
+    STBTT_memset(font_bitmap, 0, tex_w*tex_h);
+    int x = 1;
+    int y = 1;
+    int bottom_y = 1;
+
+    // Generate bitmap and char indices
+    for (int i=0; i < NUM_CHARS; ++i) {
+       int advance, lsb, x0,y0,x1,y1,gw,gh;
+       int g = stbtt_FindGlyphIndex(&f, FIRST_CHAR + i);
+       stbtt_GetGlyphHMetrics(&f, g, &advance, &lsb);
+       stbtt_GetGlyphBitmapBox(&f, g, scale,scale, &x0,&y0,&x1,&y1);
+       gw = x1-x0;
+       gh = y1-y0;
+       font_max_width_px = std::max(font_max_width_px, (float)gw);
+
+       if (x + gw + 1 >= tex_w)
+          y = bottom_y, x = 1; // advance to next row
+       if (y + gh + 1 >= tex_h) // check if it fits vertically AFTER potentially moving to next row
+          throw std::runtime_error("Unable to initialise font: run out of texture pixel space.");
+       STBTT_assert(x+gw < tex_w);
+       STBTT_assert(y+gh < tex_h);
+       stbtt_MakeGlyphBitmap(&f, font_bitmap+x+y*tex_w, gw,gh,tex_w, scale,scale, g);
+
+       // Adjust offset for edges of pixels
+       chardata[i] = GlChar(tex_w,tex_h, x, y, gw, gh, scale*advance, x0 -0.5f, -y0 -0.5f);
+
+       x = x + gw + 1;
+       if (y+gh+1 > bottom_y)
+          bottom_y = y+gh+1;
+    }
+
+    // Generate kern table
+    for (int i=0; i < NUM_CHARS; ++i) {
+        for (int j=0; j < NUM_CHARS; ++j) {
+            kern_table[i*NUM_CHARS+j] = scale * stbtt_GetCodepointKernAdvance(&f,i,j);
+        }
+    }
+}
+
+void GlFont::InitialiseGlTexture()
+{
+    if(font_bitmap) {
+        mTex.Reinitialise(tex_w,tex_h, GL_ALPHA, true, 0, GL_ALPHA,GL_UNSIGNED_BYTE, font_bitmap);
+//        mTex.SetNearestNeighbour();
+        delete[] font_bitmap;
+        font_bitmap = 0;
+    }
+}
+
+GlText GlFont::Text( const char* fmt, ... )
+{
+    if(!mTex.IsValid()) InitialiseGlTexture();
+
+    GlText ret(mTex);
+
+    char text[MAX_TEXT_LENGTH];
+    va_list ap;
+
+    if( fmt != NULL ) {
+        va_start( ap, fmt );
+        vsnprintf( text, MAX_TEXT_LENGTH, fmt, ap );
+        va_end( ap );
+
+        const size_t len = strlen(text);
+        char lc = ' ' - FIRST_CHAR;
+        for(size_t i=0; i < len; ++i) {
+            char c = text[i];
+            if( !(FIRST_CHAR <= c /*&& c <FIRST_CHAR+NUM_CHARS*/) ) {
+                c = ' ';
+            }
+            const GlChar& ch = chardata[c-32];
+
+            // Kerning
+            if(i) {
+                const GLfloat kern = kern_table[ (lc-32)*NUM_CHARS + (c-32) ];
+                ret.AddSpace(kern);
+            }
+
+            ret.Add(c,ch);
+            lc = c;
+        }
+    }
+    return ret;
+}
+
+GlText GlFont::Text( const std::string& str )
+{
+    if(!mTex.IsValid()) InitialiseGlTexture();
+
+    GlText ret(mTex);
+
+    char lc = ' ' - FIRST_CHAR;
+    for(size_t i=0; i < str.length(); ++i) {
+        char c = str[i];
+        if( !(FIRST_CHAR <= c /*&& c <FIRST_CHAR+NUM_CHARS*/) ) {
+            c = ' ';
+        }
+        const GlChar& ch = chardata[c-32];
+
+        // Kerning
+        if(i) {
+            const GLfloat kern = kern_table[ (lc-32)*NUM_CHARS + (c-32) ];
+            ret.AddSpace(kern);
+        }
+
+        ret.Add(c,ch);
+        lc = c;
+    }
+    return ret;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_opengl/src/glpangoglu.cpp

@@ -0,0 +1,272 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/gl/glpangoglu.h>
+#include <pangolin/utils/simple_math.h>
+#include <unordered_map>
+
+namespace pangolin {
+
+const GLubyte* glErrorString(GLenum err)
+{
+    switch (err)
+    {
+    case GL_NO_ERROR:                      return (GLubyte*)"GL_NO_ERROR: No error has been recorded.";
+    case GL_INVALID_ENUM:                  return (GLubyte*)"GL_INVALID_ENUM: An unacceptable value is specified for an enumerated argument.";
+    case GL_INVALID_VALUE:                 return (GLubyte*)"GL_INVALID_VALUE: A numeric argument is out of range.";
+    case GL_INVALID_OPERATION:             return (GLubyte*)"GL_INVALID_OPERATION: The specified operation is not allowed in the current state.";
+    case GL_STACK_OVERFLOW:                return (GLubyte*)"GL_STACK_OVERFLOW: An attempt has been made to perform an operation that would cause an internal stack to underflow.";
+    case GL_STACK_UNDERFLOW:               return (GLubyte*)"GL_STACK_UNDERFLOW: An attempt has been made to perform an operation that would cause an internal stack to overflow.";
+    case GL_OUT_OF_MEMORY:                 return (GLubyte*)"GL_OUT_OF_MEMORY: There is not enough memory left to execute the command.";
+    case 0x8031: /* not core */            return (GLubyte*)"GL_TABLE_TOO_LARGE_EXT";
+    case 0x8065: /* not core */            return (GLubyte*)"GL_TEXTURE_TOO_LARGE_EXT";
+    case GL_INVALID_FRAMEBUFFER_OPERATION: return (GLubyte*)"GL_INVALID_FRAMEBUFFER_OPERATION: The framebuffer object is not complete.";
+    default:
+        return (GLubyte*)"[Unknown error code]";
+    }
+}
+
+// Based on glu implementation.
+template<typename P>
+int InvertMatrix(const P m[16], P invOut[16])
+{
+    P inv[16], det;
+    int i;
+
+    inv[0] =   m[5]*m[10]*m[15] - m[5]*m[11]*m[14] - m[9]*m[6]*m[15]
+             + m[9]*m[7]*m[14] + m[13]*m[6]*m[11] - m[13]*m[7]*m[10];
+    inv[4] =  -m[4]*m[10]*m[15] + m[4]*m[11]*m[14] + m[8]*m[6]*m[15]
+             - m[8]*m[7]*m[14] - m[12]*m[6]*m[11] + m[12]*m[7]*m[10];
+    inv[8] =   m[4]*m[9]*m[15] - m[4]*m[11]*m[13] - m[8]*m[5]*m[15]
+             + m[8]*m[7]*m[13] + m[12]*m[5]*m[11] - m[12]*m[7]*m[9];
+    inv[12] = -m[4]*m[9]*m[14] + m[4]*m[10]*m[13] + m[8]*m[5]*m[14]
+             - m[8]*m[6]*m[13] - m[12]*m[5]*m[10] + m[12]*m[6]*m[9];
+    inv[1] =  -m[1]*m[10]*m[15] + m[1]*m[11]*m[14] + m[9]*m[2]*m[15]
+             - m[9]*m[3]*m[14] - m[13]*m[2]*m[11] + m[13]*m[3]*m[10];
+    inv[5] =   m[0]*m[10]*m[15] - m[0]*m[11]*m[14] - m[8]*m[2]*m[15]
+             + m[8]*m[3]*m[14] + m[12]*m[2]*m[11] - m[12]*m[3]*m[10];
+    inv[9] =  -m[0]*m[9]*m[15] + m[0]*m[11]*m[13] + m[8]*m[1]*m[15]
+             - m[8]*m[3]*m[13] - m[12]*m[1]*m[11] + m[12]*m[3]*m[9];
+    inv[13] =  m[0]*m[9]*m[14] - m[0]*m[10]*m[13] - m[8]*m[1]*m[14]
+             + m[8]*m[2]*m[13] + m[12]*m[1]*m[10] - m[12]*m[2]*m[9];
+    inv[2] =   m[1]*m[6]*m[15] - m[1]*m[7]*m[14] - m[5]*m[2]*m[15]
+             + m[5]*m[3]*m[14] + m[13]*m[2]*m[7] - m[13]*m[3]*m[6];
+    inv[6] =  -m[0]*m[6]*m[15] + m[0]*m[7]*m[14] + m[4]*m[2]*m[15]
+             - m[4]*m[3]*m[14] - m[12]*m[2]*m[7] + m[12]*m[3]*m[6];
+    inv[10] =  m[0]*m[5]*m[15] - m[0]*m[7]*m[13] - m[4]*m[1]*m[15]
+             + m[4]*m[3]*m[13] + m[12]*m[1]*m[7] - m[12]*m[3]*m[5];
+    inv[14] = -m[0]*m[5]*m[14] + m[0]*m[6]*m[13] + m[4]*m[1]*m[14]
+             - m[4]*m[2]*m[13] - m[12]*m[1]*m[6] + m[12]*m[2]*m[5];
+    inv[3] =  -m[1]*m[6]*m[11] + m[1]*m[7]*m[10] + m[5]*m[2]*m[11]
+             - m[5]*m[3]*m[10] - m[9]*m[2]*m[7] + m[9]*m[3]*m[6];
+    inv[7] =   m[0]*m[6]*m[11] - m[0]*m[7]*m[10] - m[4]*m[2]*m[11]
+             + m[4]*m[3]*m[10] + m[8]*m[2]*m[7] - m[8]*m[3]*m[6];
+    inv[11] = -m[0]*m[5]*m[11] + m[0]*m[7]*m[9] + m[4]*m[1]*m[11]
+             - m[4]*m[3]*m[9] - m[8]*m[1]*m[7] + m[8]*m[3]*m[5];
+    inv[15] =  m[0]*m[5]*m[10] - m[0]*m[6]*m[9] - m[4]*m[1]*m[10]
+             + m[4]*m[2]*m[9] + m[8]*m[1]*m[6] - m[8]*m[2]*m[5];
+
+    det = m[0]*inv[0] + m[1]*inv[4] + m[2]*inv[8] + m[3]*inv[12];
+    if (det == 0)
+        return GL_FALSE;
+
+    det=1.0f/det;
+
+    for (i = 0; i < 16; i++)
+        invOut[i] = inv[i] * det;
+
+    return GL_TRUE;
+}
+
+// Based on glu implementation
+GLint glProject(float objx, float objy, float objz,
+    const float * const modelMatrix,
+    const float * const projMatrix,
+    const GLint * const viewport,
+    float* winx, float* winy, float* winz)
+{
+    float t1[4] = {objx, objy, objz, 1.0f};
+    float t2[4];
+
+    MatMul<4,4,1,float>(t2, modelMatrix, t1);
+    MatMul<4,4,1,float>(t1, projMatrix, t2);
+
+    if (t1[3] == 0.0) {
+        return(GL_FALSE);
+    }
+
+    // Normalise
+    t1[0]/=t1[3];
+    t1[1]/=t1[3];
+    t1[2]/=t1[3];
+
+    // Map x, y and z to range 0-1
+    t1[0]=t1[0]*0.5f+0.5f;
+    t1[1]=t1[1]*0.5f+0.5f;
+    t1[2]=t1[2]*0.5f+0.5f;
+
+    // Map x,y to viewport
+    t1[0]=t1[0] * viewport[2] + viewport[0];
+    t1[1]=t1[1] * viewport[3] + viewport[1];
+
+    *winx=t1[0];
+    *winy=t1[1];
+    *winz=t1[2];
+
+    return GL_TRUE;
+}
+
+// Based on glu implementation
+GLint glUnProject(float winx, float winy, float winz,
+    const float * const mv,
+    const float * const proj,
+    const GLint * const viewport,
+    float* objx, float* objy, float* objz)
+{
+    float t1[16];
+
+    MatMul<4,4,4,float>(t1, proj, mv);
+
+    if (!InvertMatrix<float>(t1, t1)) {
+        return(GL_FALSE);
+    }
+
+    // Map x and y from window coordinates
+    float in[4] = {winx, winy, winz, 1.0f};
+    in[0] = (in[0] - viewport[0]) / viewport[2];
+    in[1] = (in[1] - viewport[1]) / viewport[3];
+
+    // Map to range -1 to 1
+    in[0] = in[0] * 2 - 1;
+    in[1] = in[1] * 2 - 1;
+    in[2] = in[2] * 2 - 1;
+
+    float out[4];
+    MatMul<4,4,1,float>(out, t1, in);
+
+    if (out[3] == 0.0) {
+        return(GL_FALSE);
+    }
+
+    // Normalise
+    out[0] /= out[3];
+    out[1] /= out[3];
+    out[2] /= out[3];
+
+    // Copy out
+    *objx = out[0];
+    *objy = out[1];
+    *objz = out[2];
+
+    return GL_TRUE;
+}
+
+// Based on glu implementation
+GLint glProject(double objx, double objy, double objz,
+    const double * const modelMatrix,
+    const double * const projMatrix,
+    const GLint * const viewport,
+    double* winx, double* winy, double* winz)
+{
+    double t1[4] = {objx, objy, objz, 1.0f};
+    double t2[4];
+
+    MatMul<4,4,1,double>(t2, modelMatrix, t1);
+    MatMul<4,4,1,double>(t1, projMatrix, t2);
+
+    if (t1[3] == 0.0) {
+        return(GL_FALSE);
+    }
+
+    // Normalise
+    t1[0]/=t1[3];
+    t1[1]/=t1[3];
+    t1[2]/=t1[3];
+
+    // Map x, y and z to range 0-1
+    t1[0]=t1[0]*0.5f+0.5f;
+    t1[1]=t1[1]*0.5f+0.5f;
+    t1[2]=t1[2]*0.5f+0.5f;
+
+    // Map x,y to viewport
+    t1[0]=t1[0] * viewport[2] + viewport[0];
+    t1[1]=t1[1] * viewport[3] + viewport[1];
+
+    *winx=t1[0];
+    *winy=t1[1];
+    *winz=t1[2];
+
+    return GL_TRUE;
+}
+
+// Based on glu implementation
+GLint glUnProject(double winx, double winy, double winz,
+    const double * const mv,
+    const double * const proj,
+    const GLint * const viewport,
+    double* objx, double* objy, double* objz)
+{
+    double t1[16];
+
+    MatMul<4,4,4,double>(t1, proj, mv);
+
+    if (!InvertMatrix<double>(t1, t1)) {
+        return(GL_FALSE);
+    }
+
+    // Map x and y from window coordinates
+    double in[4] = {winx, winy, winz, 1.0f};
+    in[0] = (in[0] - viewport[0]) / viewport[2];
+    in[1] = (in[1] - viewport[1]) / viewport[3];
+
+    // Map to range -1 to 1
+    in[0] = in[0] * 2 - 1;
+    in[1] = in[1] * 2 - 1;
+    in[2] = in[2] * 2 - 1;
+
+    double out[4];
+    MatMul<4,4,1,double>(out, t1, in);
+
+    if (out[3] == 0.0) {
+        return(GL_FALSE);
+    }
+
+    // Normalise
+    out[0] /= out[3];
+    out[1] /= out[3];
+    out[2] /= out[3];
+
+    // Copy out
+    *objx = out[0];
+    *objy = out[1];
+    *objz = out[2];
+
+    return GL_TRUE;
+}
+
+
+}

third-party/DPVO/Pangolin/components/pango_opengl/src/gltext.cpp

@@ -0,0 +1,198 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/gl/gltext.h>
+#include <pangolin/gl/glsl.h>
+
+namespace pangolin
+{
+
+GlText::GlText()
+    : tex(NULL), width(0),
+      ymin(std::numeric_limits<GLfloat>::max()),
+      ymax(-std::numeric_limits<GLfloat>::max())
+{
+
+}
+
+GlText::GlText(const GlText& txt)
+    : tex(txt.tex), str(txt.str), width(txt.width),
+      ymin(txt.ymin), ymax(txt.ymax), vs(txt.vs)
+{
+}
+
+GlText::GlText(const GlTexture& font_tex)
+    : tex(&font_tex), width(0),
+      ymin(std::numeric_limits<GLfloat>::max()),
+      ymax(-std::numeric_limits<GLfloat>::max())
+{
+}
+
+void GlText::AddSpace(GLfloat s)
+{
+    width += s;
+}
+
+void GlText::Add(unsigned char c, const GlChar& glc)
+{
+    GLfloat x = width;
+
+    vs.push_back(glc.GetVert(0) + x);
+    vs.push_back(glc.GetVert(1) + x);
+    vs.push_back(glc.GetVert(2) + x);
+    vs.push_back(glc.GetVert(0) + x);
+    vs.push_back(glc.GetVert(2) + x);
+    vs.push_back(glc.GetVert(3) + x);
+
+    ymin = std::min(ymin, glc.YMin());
+    ymax = std::max(ymax, glc.YMax());
+    width = x + glc.StepX();
+
+    str.append(1,c);
+}
+
+void GlText::Clear()
+{
+    str.clear();
+    vs.clear();
+    width = 0;
+    ymin = +std::numeric_limits<GLfloat>::max();
+    ymax = -std::numeric_limits<GLfloat>::max();
+}
+
+void GlText::DrawGlSl() const
+{
+#if !defined(HAVE_GLES) || defined(HAVE_GLES_2)
+    if(vs.size() && tex) {
+        glEnableVertexAttribArray(pangolin::DEFAULT_LOCATION_POSITION);
+        glEnableVertexAttribArray(pangolin::DEFAULT_LOCATION_TEXCOORD);
+
+        glVertexAttribPointer(pangolin::DEFAULT_LOCATION_POSITION, 2, GL_FLOAT, GL_FALSE, sizeof(XYUV), &vs[0].x);
+        glVertexAttribPointer(pangolin::DEFAULT_LOCATION_TEXCOORD, 2, GL_FLOAT, GL_FALSE, sizeof(XYUV), &vs[0].tu);
+
+        tex->Bind();
+        glEnable(GL_TEXTURE_2D);
+        glDrawArrays(GL_TRIANGLES, 0, (GLsizei)vs.size() );
+        glDisable(GL_TEXTURE_2D);
+
+        glDisableVertexAttribArray(pangolin::DEFAULT_LOCATION_POSITION);
+        glDisableVertexAttribArray(pangolin::DEFAULT_LOCATION_TEXCOORD);
+    }
+#endif
+}
+
+void SetWindowOrthographic()
+{
+    // We'll set an arbitrary viewport with known dimensions
+    // >= window dimensions so we can draw in pixel units.
+    GLint dims[2];
+    glGetIntegerv(GL_MAX_VIEWPORT_DIMS,dims);
+    glViewport(0,0,dims[0], dims[1]);
+
+    glMatrixMode(GL_PROJECTION);
+    ProjectionMatrixOrthographic(-0.5, dims[0]-0.5, -0.5, dims[1]-0.5, -1.0, 1.0).Load();
+    glMatrixMode(GL_MODELVIEW);
+}
+
+void GlText::Draw() const
+{
+    if(vs.size() && tex) {
+        glVertexPointer(2, GL_FLOAT, sizeof(XYUV), &vs[0].x);
+        glEnableClientState(GL_VERTEX_ARRAY);
+        glTexCoordPointer(2, GL_FLOAT, sizeof(XYUV), &vs[0].tu);
+        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+        tex->Bind();
+        glEnable(GL_TEXTURE_2D);
+        glDrawArrays(GL_TRIANGLES, 0, (GLsizei)vs.size() );
+        glDisable(GL_TEXTURE_2D);
+        glDisableClientState(GL_VERTEX_ARRAY);
+        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+    }
+}
+
+void GlText::Draw(GLfloat x, GLfloat y, GLfloat z) const
+{
+    // find object point (x,y,z)' in pixel coords
+    GLdouble projection[16];
+    GLdouble modelview[16];
+    GLint    view[4];
+    GLdouble scrn[3];
+
+#ifdef HAVE_GLES_2
+    std::copy(glEngine().projection.top().m, glEngine().projection.top().m+16, projection);
+    std::copy(glEngine().modelview.top().m, glEngine().modelview.top().m+16, modelview);
+#else
+    glGetDoublev(GL_PROJECTION_MATRIX, projection );
+    glGetDoublev(GL_MODELVIEW_MATRIX, modelview );
+#endif
+    glGetIntegerv(GL_VIEWPORT, view );
+
+    pangolin::glProject(x, y, z, modelview, projection, view,
+        scrn, scrn + 1, scrn + 2);
+
+    // Save current state
+    glMatrixMode(GL_PROJECTION);
+    glPushMatrix();
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+
+    SetWindowOrthographic();
+    glTranslatef(std::floor((GLfloat)scrn[0]), std::floor((GLfloat)scrn[1]), (GLfloat)scrn[2]);
+    Draw();
+
+    // Restore viewport & matrices
+    glViewport(view[0],view[1],view[2],view[3]);
+    glMatrixMode(GL_PROJECTION);
+    glPopMatrix();
+    glMatrixMode(GL_MODELVIEW);
+    glPopMatrix();
+}
+
+// Render at (x,y) in window coordinates.
+void GlText::DrawWindow(GLfloat x, GLfloat y, GLfloat z) const
+{
+    // Backup viewport & matrices
+    GLint    view[4];
+    glGetIntegerv(GL_VIEWPORT, view );
+    glMatrixMode(GL_PROJECTION);
+    glPushMatrix();
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+
+    SetWindowOrthographic();
+    glTranslatef( std::floor(x), std::floor(y), z);
+    Draw();
+
+    // Restore viewport & matrices
+    glViewport(view[0],view[1],view[2],view[3]);
+    glMatrixMode(GL_PROJECTION);
+    glPopMatrix();
+    glMatrixMode(GL_MODELVIEW);
+    glPopMatrix();
+}
+
+}

third-party/DPVO/Pangolin/components/pango_opengl/src/gltexturecache.cpp

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

third-party/DPVO/Pangolin/components/pango_opengl/src/opengl_render_state.cpp

@@ -0,0 +1,707 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove, Richard Newcombe
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/gl/opengl_render_state.h>
+#include <pangolin/gl/glinclude.h>
+
+#include <stdexcept>
+
+namespace pangolin
+{
+
+inline void glLoadMatrix(const float* m) { glLoadMatrixf(m); }
+inline void glMultMatrix(const float* m) { glMultMatrixf(m); }
+
+#ifndef HAVE_GLES
+inline void glLoadMatrix(const double* m) { glLoadMatrixd(m); }
+inline void glMultMatrix(const double* m) { glMultMatrixd(m); }
+#endif
+
+OpenGlMatrix OpenGlMatrix::Translate(GLprecision x, GLprecision y, GLprecision z)
+{
+    OpenGlMatrix mat;
+    mat.SetIdentity();
+    mat(0, 3) = x;
+    mat(1, 3) = y;
+    mat(2, 3) = z;
+    return mat;
+}
+
+OpenGlMatrix OpenGlMatrix::Scale(GLprecision x, GLprecision y, GLprecision z)
+{
+    OpenGlMatrix mat;
+    mat.SetIdentity();
+    mat(0, 0) = x;
+    mat(1, 1) = y;
+    mat(2, 2) = z;
+    return mat;
+}
+
+OpenGlMatrix OpenGlMatrix::RotateX(GLprecision theta_rad)
+{
+    OpenGlMatrix mat;
+    mat.SetIdentity();
+    const GLprecision costh = cos(theta_rad);
+    const GLprecision sinth = sin(theta_rad);
+    mat(1, 1) = costh;
+    mat(1, 2) = -sinth;
+    mat(2, 1) = sinth;
+    mat(2, 2) = costh;
+    return mat;
+}
+
+OpenGlMatrix OpenGlMatrix::RotateY(GLprecision theta_rad)
+{
+    OpenGlMatrix mat;
+    mat.SetIdentity();
+    const GLprecision costh = cos(theta_rad);
+    const GLprecision sinth = sin(theta_rad);
+    mat(0, 0) = costh;
+    mat(0, 2) = sinth;
+    mat(2, 0) = -sinth;
+    mat(2, 2) = costh;
+    return mat;
+}
+
+OpenGlMatrix OpenGlMatrix::RotateZ(GLprecision theta_rad)
+{
+    OpenGlMatrix mat;
+    mat.SetIdentity();
+    const GLprecision costh = cos(theta_rad);
+    const GLprecision sinth = sin(theta_rad);
+    mat(0, 0) = costh;
+    mat(0, 1) = -sinth;
+    mat(1, 0) = sinth;
+    mat(1, 1) = costh;
+    return mat;
+}
+
+void OpenGlMatrix::Load() const
+{
+    glLoadMatrix(m);
+}
+
+void OpenGlMatrix::Multiply() const
+{
+    glMultMatrix(m);
+}
+
+void OpenGlMatrix::SetIdentity()
+{
+    m[0] = 1.0f;  m[1] = 0.0f;  m[2] = 0.0f;  m[3] = 0.0f;
+    m[4] = 0.0f;  m[5] = 1.0f;  m[6] = 0.0f;  m[7] = 0.0f;
+    m[8] = 0.0f;  m[9] = 0.0f; m[10] = 1.0f; m[11] = 0.0f;
+    m[12] = 0.0f; m[13] = 0.0f; m[14] = 0.0f; m[15] = 1.0f;
+}
+
+OpenGlMatrix OpenGlMatrix::Transpose() const
+{
+    OpenGlMatrix trans;
+    trans.m[0] = m[0];  trans.m[4] = m[1];  trans.m[8]  = m[2];  trans.m[12] = m[3];
+    trans.m[1] = m[4];  trans.m[5] = m[5];  trans.m[9]  = m[6];  trans.m[13] = m[7];
+    trans.m[2] = m[8];  trans.m[6] = m[9];  trans.m[10] = m[10]; trans.m[14] = m[11];
+    trans.m[3] = m[12]; trans.m[7] = m[13]; trans.m[11] = m[14]; trans.m[15] = m[15];
+    return trans;
+}
+
+OpenGlMatrix OpenGlMatrix::Inverse() const
+{
+    OpenGlMatrix inv;
+    inv.m[0] = m[0]; inv.m[4] = m[1]; inv.m[8]  = m[2];  inv.m[12] = -(m[0]*m[12] + m[1]*m[13] + m[2]*m[14]);
+    inv.m[1] = m[4]; inv.m[5] = m[5]; inv.m[9]  = m[6];  inv.m[13] = -(m[4]*m[12] + m[5]*m[13] + m[6]*m[14]);
+    inv.m[2] = m[8]; inv.m[6] = m[9]; inv.m[10] = m[10]; inv.m[14] = -(m[8]*m[12] + m[9]*m[13] + m[10]*m[14]);
+    inv.m[3] =    0; inv.m[7] =    0; inv.m[11] =    0;  inv.m[15] = 1;
+    return inv;
+}
+
+std::ostream& operator<<(std::ostream& os, const OpenGlMatrix& mat)
+{
+    for(int r=0; r< 4; ++r) {
+        for(int c=0; c<4; ++c) {
+            std::cout << mat.m[4*c+r] << '\t';
+        }
+        std::cout << std::endl;
+    }
+    return os;
+}
+
+void OpenGlRenderState::Apply() const
+{
+    glMatrixMode(GL_PROJECTION);
+    projection[0].Load();
+    
+    // Leave in MODEVIEW mode
+    glMatrixMode(GL_MODELVIEW);
+    modelview.Load();
+
+    if(follow) {
+        T_cw.Multiply();
+    }
+}
+
+OpenGlMatrix& OpenGlRenderState::GetProjectionMatrix(unsigned int view)
+{
+    if( projection.size() <= view ) {
+        projection.resize(view+1);
+    }
+    return projection[view];
+}
+
+OpenGlMatrix OpenGlRenderState::GetProjectionMatrix(unsigned int view) const
+{
+    if( projection.size() <= view ) {
+        return IdentityMatrix();
+    }
+    return projection[view];
+}
+
+OpenGlMatrix& OpenGlRenderState::GetViewOffset(unsigned int view)
+{
+    if( modelview_premult.size() <= view ) {
+        modelview_premult.resize(view+1);
+    }
+    return modelview_premult[view];
+}
+
+OpenGlMatrix OpenGlRenderState::GetViewOffset(unsigned int view) const
+{
+    if( modelview_premult.size() <= view ) {
+        return IdentityMatrix();
+    }
+    return modelview_premult[view];
+}
+
+void OpenGlRenderState::ApplyNView(int view) const
+{
+    glMatrixMode(GL_PROJECTION);
+    projection[view].Load();
+
+    // Leave in MODEVIEW mode
+    glMatrixMode(GL_MODELVIEW);
+    OpenGlMatrix m = GetModelViewMatrix(view);
+    m.Load();
+
+    if(follow) {
+        T_cw.Multiply();
+    }
+}
+
+OpenGlRenderState::OpenGlRenderState()
+    : modelview(IdentityMatrix()), follow(false)
+{
+    projection.push_back( IdentityMatrix() );
+}
+
+OpenGlRenderState::OpenGlRenderState(const OpenGlMatrix& projection_matrix)
+    : modelview(IdentityMatrix()), follow(false)
+{
+    projection.push_back( projection_matrix );
+}
+
+OpenGlRenderState::OpenGlRenderState(const OpenGlMatrix& projection_matrix, const OpenGlMatrix& modelview_matrx)
+    : modelview(modelview_matrx), follow(false)
+{
+    projection.push_back( projection_matrix );
+}
+
+void OpenGlRenderState::ApplyIdentity()
+{
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+}
+
+OpenGlRenderState& OpenGlRenderState::SetProjectionMatrix(OpenGlMatrix m)
+{
+    projection[0] = m;
+    return *this;
+}
+
+OpenGlRenderState& OpenGlRenderState::SetModelViewMatrix(OpenGlMatrix m)
+{
+    modelview = m;
+    return *this;
+}
+
+OpenGlRenderState& OpenGlRenderState::Set(OpenGlMatrixSpec m)
+{
+    switch (m.type) {
+    case GlProjectionStack:
+        projection[0] = m;
+        break;
+    case GlModelViewStack:
+        modelview = m;
+        break;
+    default:
+        throw std::runtime_error("Unexpected matrix type");
+        break;
+    }
+    return *this;
+}
+
+OpenGlMatrix operator*(const OpenGlMatrix& lhs, const OpenGlMatrix& rhs)
+{
+    OpenGlMatrix ret;
+    pangolin::MatMul<4,4,4>(ret.m, lhs.m, rhs.m);
+    return ret;
+}
+
+OpenGlMatrix& OpenGlRenderState::GetProjectionMatrix()
+{
+    // guarenteed to have at least one projection matrix element
+    return projection[0];
+}
+
+OpenGlMatrix OpenGlRenderState::GetProjectionMatrix() const
+{
+    // guarenteed to have at least one projection matrix element
+    return projection[0];
+}
+
+OpenGlMatrix& OpenGlRenderState::GetModelViewMatrix()
+{
+    return modelview;
+}
+
+OpenGlMatrix OpenGlRenderState::GetModelViewMatrix() const
+{
+    return modelview;
+}
+
+OpenGlMatrix OpenGlRenderState::GetModelViewMatrix(int i) const
+{
+    return modelview_premult[i] * modelview;
+}
+
+OpenGlMatrix OpenGlRenderState::GetProjectionModelViewMatrix() const
+{
+    return GetProjectionMatrix() * GetModelViewMatrix();
+}
+
+OpenGlMatrix OpenGlRenderState::GetProjectiveTextureMatrix() const
+{
+    return OpenGlMatrix::Translate(0.5,0.5,0.5) * OpenGlMatrix::Scale(0.5,0.5,0.5) * GetProjectionModelViewMatrix();
+}
+
+void OpenGlRenderState::EnableProjectiveTexturing() const
+{
+#ifndef HAVE_GLES
+    const pangolin::OpenGlMatrix projmattrans = GetProjectiveTextureMatrix().Transpose();
+    glEnable(GL_TEXTURE_GEN_S);
+    glEnable(GL_TEXTURE_GEN_T);
+    glEnable(GL_TEXTURE_GEN_R);
+    glEnable(GL_TEXTURE_GEN_Q);
+    glTexGendv(GL_S, GL_EYE_PLANE, projmattrans.m);
+    glTexGendv(GL_T, GL_EYE_PLANE, projmattrans.m+4);
+    glTexGendv(GL_R, GL_EYE_PLANE, projmattrans.m+8);
+    glTexGendv(GL_Q, GL_EYE_PLANE, projmattrans.m+12);
+    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
+    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
+    glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
+    glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
+#endif
+}
+
+void OpenGlRenderState::DisableProjectiveTexturing() const
+{
+#ifndef HAVE_GLES
+    glDisable(GL_TEXTURE_GEN_S);
+    glDisable(GL_TEXTURE_GEN_T);
+    glDisable(GL_TEXTURE_GEN_R);
+    glDisable(GL_TEXTURE_GEN_Q);
+#endif
+}
+
+void OpenGlRenderState::Follow(const OpenGlMatrix& T_wc, bool follow)
+{
+    this->T_cw = T_wc.Inverse();
+    
+    if(follow != this->follow) {
+        if(follow) {
+            const OpenGlMatrix T_vc = GetModelViewMatrix() * T_wc;
+            SetModelViewMatrix(T_vc);
+            this->follow = true;
+        }else{
+            Unfollow();
+        }
+    }
+}
+
+void OpenGlRenderState::Unfollow()
+{
+    const OpenGlMatrix T_vw = GetModelViewMatrix() * T_cw;
+    SetModelViewMatrix(T_vw);
+    this->follow = false;
+}
+
+// Use OpenGl's default frame of reference
+OpenGlMatrixSpec ProjectionMatrix(int w, int h, GLprecision fu, GLprecision fv, GLprecision u0, GLprecision v0, GLprecision zNear, GLprecision zFar )
+{
+    return ProjectionMatrixRUB_BottomLeft(w,h,fu,fv,u0,v0,zNear,zFar);
+}
+
+OpenGlMatrixSpec ProjectionMatrixOrthographic(GLprecision l, GLprecision r, GLprecision b, GLprecision t, GLprecision n, GLprecision f )
+{
+    OpenGlMatrixSpec P;
+    P.type = GlProjectionStack;
+    
+    P.m[0] = 2/(r-l);
+    P.m[1] = 0;
+    P.m[2] = 0;
+    P.m[3] = 0;
+    
+    P.m[4] = 0;
+    P.m[5] = 2/(t-b);
+    P.m[6] = 0;
+    P.m[7] = 0;
+    
+    P.m[8] = 0;
+    P.m[9] = 0;
+    P.m[10] = -2/(f-n);
+    P.m[11] = 0;
+    
+    P.m[12] = -(r+l)/(r-l);
+    P.m[13] = -(t+b)/(t-b);
+    P.m[14] = -(f+n)/(f-n);
+    P.m[15] = 1;
+    
+    return P;
+}
+
+
+// Camera Axis:
+//   X - Right, Y - Up, Z - Back
+// Image Origin:
+//   Bottom Left
+// Caution: Principal point defined with respect to image origin (0,0) at
+//          bottom left of bottom-left pixel (not center, and in different frame
+//          of reference to projection function image)
+OpenGlMatrixSpec ProjectionMatrixRUB_BottomLeft(int w, int h, GLprecision fu, GLprecision fv, GLprecision u0, GLprecision v0, GLprecision zNear, GLprecision zFar )
+{
+    // http://www.songho.ca/opengl/gl_projectionmatrix.html
+    const GLprecision L = +(u0) * zNear / -fu;
+    const GLprecision T = +(v0) * zNear / fv;
+    const GLprecision R = -(w-u0) * zNear / -fu;
+    const GLprecision B = -(h-v0) * zNear / fv;
+    
+    OpenGlMatrixSpec P;
+    P.type = GlProjectionStack;
+    std::fill_n(P.m,4*4,0);
+    
+    P.m[0*4+0] = 2 * zNear / (R-L);
+    P.m[1*4+1] = 2 * zNear / (T-B);
+    P.m[2*4+2] = -(zFar +zNear) / (zFar - zNear);
+    P.m[2*4+0] = (R+L)/(R-L);
+    P.m[2*4+1] = (T+B)/(T-B);
+    P.m[2*4+3] = -1.0;
+    P.m[3*4+2] =  -(2*zFar*zNear)/(zFar-zNear);
+    
+    return P;
+}
+
+// Camera Axis:
+//   X - Right, Y - Up, Z - Back
+// Image Origin:
+//   Top Left
+// Caution: Principal point defined with respect to image origin (0,0) at
+//          top left of top-left pixel (not center, and in different frame
+//          of reference to projection function image)
+OpenGlMatrixSpec ProjectionMatrixRUB_TopLeft(int w, int h, GLprecision fu, GLprecision fv, GLprecision u0, GLprecision v0, GLprecision zNear, GLprecision zFar )
+{
+    // http://www.songho.ca/opengl/gl_projectionmatrix.html
+    const GLprecision L = +(u0) * zNear / -fu;
+    const GLprecision R = -(w-u0) * zNear / -fu;
+    const GLprecision T = -(h-v0) * zNear / fv;
+    const GLprecision B = +(v0) * zNear / fv;
+
+    OpenGlMatrixSpec P;
+    P.type = GlProjectionStack;
+    std::fill_n(P.m,4*4,0);
+
+    P.m[0*4+0] = 2 * zNear / (R-L);
+    P.m[1*4+1] = 2 * zNear / (T-B);
+    P.m[2*4+2] = -(zFar +zNear) / (zFar - zNear);
+    P.m[2*4+0] = (R+L)/(R-L);
+    P.m[2*4+1] = (T+B)/(T-B);
+    P.m[2*4+3] = -1.0;
+    P.m[3*4+2] =  -(2*zFar*zNear)/(zFar-zNear);
+
+    return P;
+}
+
+// Camera Axis:
+//   X - Right, Y - Down, Z - Forward
+// Image Origin:
+//   Top Left
+// Pricipal point specified with image origin (0,0) at top left of top-left pixel (not center)
+OpenGlMatrixSpec ProjectionMatrixRDF_TopLeft(int w, int h, GLprecision fu, GLprecision fv, GLprecision u0, GLprecision v0, GLprecision zNear, GLprecision zFar )
+{
+    // http://www.songho.ca/opengl/gl_projectionmatrix.html
+    const GLprecision L = -(u0) * zNear / fu;
+    const GLprecision R = +(w-u0) * zNear / fu;
+    const GLprecision T = -(v0) * zNear / fv;
+    const GLprecision B = +(h-v0) * zNear / fv;
+    
+    OpenGlMatrixSpec P;
+    P.type = GlProjectionStack;
+    std::fill_n(P.m,4*4,0);
+    
+    P.m[0*4+0] = 2 * zNear / (R-L);
+    P.m[1*4+1] = 2 * zNear / (T-B);
+    
+    P.m[2*4+0] = (R+L)/(L-R);
+    P.m[2*4+1] = (T+B)/(B-T);
+    P.m[2*4+2] = (zFar +zNear) / (zFar - zNear);
+    P.m[2*4+3] = 1.0;
+    
+    P.m[3*4+2] =  (2*zFar*zNear)/(zNear - zFar);
+    return P;
+}
+
+// Camera Axis:
+//   X - Right, Y - Down, Z - Forward
+// Image Origin:
+//   Top Right
+// Pricipal point specified with image origin (0,0) at top right of top-right pixel (not center)
+OpenGlMatrixSpec ProjectionMatrixRDF_TopRight(int w, int h, GLprecision fu, GLprecision fv, GLprecision u0, GLprecision v0, GLprecision zNear, GLprecision zFar )
+{
+    // http://www.songho.ca/opengl/gl_projectionmatrix.html
+    const GLprecision L = +(w-u0) * zNear / fu;
+    const GLprecision R = -(u0) * zNear / fu;
+    const GLprecision T = -(v0) * zNear / fv;
+    const GLprecision B = +(h-v0) * zNear / fv;
+
+    OpenGlMatrixSpec P;
+    P.type = GlProjectionStack;
+    std::fill_n(P.m,4*4,0);
+
+    P.m[0*4+0] = 2 * zNear / (R-L);
+    P.m[1*4+1] = 2 * zNear / (T-B);
+
+    P.m[2*4+0] = (R+L)/(L-R);
+    P.m[2*4+1] = (T+B)/(B-T);
+    P.m[2*4+2] = (zFar +zNear) / (zFar - zNear);
+    P.m[2*4+3] = 1.0;
+
+    P.m[3*4+2] =  (2*zFar*zNear)/(zNear - zFar);
+    return P;
+}
+
+// Camera Axis:
+//   X - Right, Y - Down, Z - Forward
+// Image Origin:
+//   Bottom Left
+// Pricipal point specified with image origin (0,0) at bottom left of bottom-left pixel (not center)
+OpenGlMatrixSpec ProjectionMatrixRDF_BottomLeft(int w, int h, GLprecision fu, GLprecision fv, GLprecision u0, GLprecision v0, GLprecision zNear, GLprecision zFar )
+{
+    // http://www.songho.ca/opengl/gl_projectionmatrix.html
+    const GLprecision L = -(u0) * zNear / fu;
+    const GLprecision R = +(w-u0) * zNear / fu;
+    const GLprecision B = -(v0) * zNear / fv;
+    const GLprecision T = +(h-v0) * zNear / fv;
+    
+    OpenGlMatrixSpec P;
+    P.type = GlProjectionStack;
+    std::fill_n(P.m,4*4,0);
+    
+    P.m[0*4+0] = 2 * zNear / (R-L);
+    P.m[1*4+1] = 2 * zNear / (T-B);
+    
+    P.m[2*4+0] = (R+L)/(L-R);
+    P.m[2*4+1] = (T+B)/(B-T);
+    P.m[2*4+2] = (zFar +zNear) / (zFar - zNear);
+    P.m[2*4+3] = 1.0;
+    
+    P.m[3*4+2] =  (2*zFar*zNear)/(zNear - zFar);
+    return P;
+}
+
+// Camera Axis:
+//   X - Right, Y - Down, Z - Forward
+// Image Origin:
+//   Bottom Right
+// Pricipal point specified with image origin (0,0) at bottom right of bottom-right pixel (not center)
+OpenGlMatrixSpec ProjectionMatrixRDF_BottomRight(int w, int h, GLprecision fu, GLprecision fv, GLprecision u0, GLprecision v0, GLprecision zNear, GLprecision zFar )
+{
+    // http://www.songho.ca/opengl/gl_projectionmatrix.html
+    const GLprecision R = -(u0) * zNear / fu;
+    const GLprecision L = +(w-u0) * zNear / fu;
+    const GLprecision B = -(v0) * zNear / fv;
+    const GLprecision T = +(h-v0) * zNear / fv;
+
+    OpenGlMatrixSpec P;
+    P.type = GlProjectionStack;
+    std::fill_n(P.m,4*4,0);
+
+    P.m[0*4+0] = 2 * zNear / (R-L);
+    P.m[1*4+1] = 2 * zNear / (T-B);
+
+    P.m[2*4+0] = (R+L)/(L-R);
+    P.m[2*4+1] = (T+B)/(B-T);
+    P.m[2*4+2] = (zFar +zNear) / (zFar - zNear);
+    P.m[2*4+3] = 1.0;
+
+    P.m[3*4+2] =  (2*zFar*zNear)/(zNear - zFar);
+    return P;
+}
+
+OpenGlMatrix ModelViewLookAtRUB(GLprecision ex, GLprecision ey, GLprecision ez, GLprecision lx, GLprecision ly, GLprecision lz, GLprecision ux, GLprecision uy, GLprecision uz)
+{
+    OpenGlMatrix mat;
+    GLprecision* m = mat.m;
+    
+    const GLprecision u_o[3] = {ux,uy,uz};
+    
+    GLprecision x[3], y[3];
+    GLprecision z[] = {ex - lx, ey - ly, ez - lz};
+    Normalise<3>(z);
+    
+    CrossProduct(x,u_o,z);
+    CrossProduct(y,z,x);
+    
+    // Normalize x, y
+    const GLprecision lenx = Length<3>(x);
+    const GLprecision leny = Length<3>(y);
+    
+    if( lenx > 0 && leny > 0) {
+        for(size_t r = 0; r < 3; ++r ) {
+            x[r] /= lenx;
+            y[r] /= leny;
+        }
+    #define M(row,col)  m[col*4+row]
+        M(0,0) = x[0];
+        M(0,1) = x[1];
+        M(0,2) = x[2];
+        M(1,0) = y[0];
+        M(1,1) = y[1];
+        M(1,2) = y[2];
+        M(2,0) = z[0];
+        M(2,1) = z[1];
+        M(2,2) = z[2];
+        M(3,0) = 0.0;
+        M(3,1) = 0.0;
+        M(3,2) = 0.0;
+        M(0,3) = -(M(0,0)*ex + M(0,1)*ey + M(0,2)*ez);
+        M(1,3) = -(M(1,0)*ex + M(1,1)*ey + M(1,2)*ez);
+        M(2,3) = -(M(2,0)*ex + M(2,1)*ey + M(2,2)*ez);
+        M(3,3) = 1.0;
+    #undef M        
+        return mat;
+    }else{
+        throw std::invalid_argument("'Look' and 'up' vectors cannot be parallel when calling ModelViewLookAt.");
+    }
+    
+}
+
+OpenGlMatrix ModelViewLookAtRDF(GLprecision ex, GLprecision ey, GLprecision ez, GLprecision lx, GLprecision ly, GLprecision lz, GLprecision ux, GLprecision uy, GLprecision uz)
+{
+    OpenGlMatrix mat;
+    GLprecision* m = mat.m;
+    
+    const GLprecision u_o[3] = {ux,uy,uz};
+    
+    GLprecision x[3], y[3];
+    GLprecision z[] = {lx - ex, ly - ey, lz - ez};
+    Normalise<3>(z);
+    
+    CrossProduct(x,z,u_o);
+    CrossProduct(y,z,x);
+    
+    // Normalize x, y
+    const GLprecision lenx = Length<3>(x);
+    const GLprecision leny = Length<3>(y);
+    
+    if( lenx > 0 && leny > 0) {
+        for(size_t r = 0; r < 3; ++r ) {
+            x[r] /= lenx;
+            y[r] /= leny;
+        }        
+    #define M(row,col)  m[col*4+row]
+        M(0,0) = x[0];
+        M(0,1) = x[1];
+        M(0,2) = x[2];
+        M(1,0) = y[0];
+        M(1,1) = y[1];
+        M(1,2) = y[2];
+        M(2,0) = z[0];
+        M(2,1) = z[1];
+        M(2,2) = z[2];
+        M(3,0) = 0.0;
+        M(3,1) = 0.0;
+        M(3,2) = 0.0;
+        M(0,3) = -(M(0,0)*ex + M(0,1)*ey + M(0,2)*ez);
+        M(1,3) = -(M(1,0)*ex + M(1,1)*ey + M(1,2)*ez);
+        M(2,3) = -(M(2,0)*ex + M(2,1)*ey + M(2,2)*ez);
+        M(3,3) = 1.0;
+    #undef M
+        return mat;
+    }else{
+        throw std::invalid_argument("'Look' and 'up' vectors cannot be parallel when calling ModelViewLookAt.");
+    }
+}
+
+OpenGlMatrix ModelViewLookAt(GLprecision ex, GLprecision ey, GLprecision ez, GLprecision lx, GLprecision ly, GLprecision lz, GLprecision ux, GLprecision uy, GLprecision uz)
+{
+    return ModelViewLookAtRUB(ex,ey,ez,lx,ly,lz,ux,uy,uz);
+}
+
+OpenGlMatrix ModelViewLookAt(GLprecision ex, GLprecision ey, GLprecision ez, GLprecision lx, GLprecision ly, GLprecision lz, AxisDirection up)
+{
+    const GLprecision* u = AxisDirectionVector[up];
+    return ModelViewLookAtRUB(ex,ey,ez,lx,ly,lz,u[0],u[1],u[2]);
+}
+
+OpenGlMatrix IdentityMatrix()
+{
+    OpenGlMatrix P;
+    std::fill_n(P.m,4*4,0);
+    for( int i=0; i<4; ++i ) P.m[i*4+i] = 1;
+    return P;
+}
+
+OpenGlMatrixSpec IdentityMatrix(OpenGlStack type)
+{
+    OpenGlMatrixSpec P;
+    P.type = type;
+    std::fill_n(P.m,4*4,0);
+    for( int i=0; i<4; ++i ) P.m[i*4+i] = 1;
+    return P;
+}
+
+OpenGlMatrixSpec  negIdentityMatrix(OpenGlStack type)
+{
+    OpenGlMatrixSpec P;
+    P.type = type;
+    std::fill_n(P.m,4*4,0);
+    for( int i=0; i<4; ++i ) P.m[i*4+i] = -1;
+    
+    P.m[3*4+3] =1;
+    return P;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_opengl/src/viewport.cpp

@@ -0,0 +1,102 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <algorithm>
+#include <pangolin/gl/viewport.h>
+#include <pangolin/gl/opengl_render_state.h>
+#include <pangolin/utils/simple_math.h>
+
+namespace pangolin {
+
+void Viewport::Activate() const
+{
+    glViewport(l,b,w,h);
+}
+
+void Viewport::Scissor() const
+{
+    glEnable(GL_SCISSOR_TEST);
+    glScissor(l,b,w,h);
+}
+
+void Viewport::ActivateAndScissor() const
+{
+    glViewport(l,b,w,h);
+    glEnable(GL_SCISSOR_TEST);
+    glScissor(l,b,w,h);
+}
+
+
+void Viewport::DisableScissor()
+{
+    glDisable(GL_SCISSOR_TEST);
+}
+
+bool Viewport::Contains(int x, int y) const
+{
+    return l <= x && x < (l+w) && b <= y && y < (b+h);
+}
+
+void Viewport::ActivatePixelOrthographic() const
+{
+    Activate();
+    glMatrixMode(GL_PROJECTION);
+    ProjectionMatrixOrthographic(-0.5, w-0.5, -0.5, h-0.5, -1.0, 1.0).Load();
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+}
+
+void Viewport::ActivateIdentity() const
+{
+    Activate();
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+}
+
+
+Viewport Viewport::Inset(int i) const
+{
+    return Viewport(l+i, b+i, w-2*i, h-2*i);
+}
+
+Viewport Viewport::Inset(int horiz, int vert) const
+{
+    return Viewport(l+horiz, b+vert, w-horiz, h-vert);
+}
+
+Viewport Viewport::Intersect(const Viewport& vp) const
+{
+    GLint nl = std::max(l,vp.l);
+    GLint nr = std::min(r(),vp.r());
+    GLint nb = std::max(b,vp.b);
+    GLint nt = std::min(t(),vp.t());
+    return Viewport(nl,nb, nr-nl, nt-nb);
+}
+
+}

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

@@ -0,0 +1,20 @@
+get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME)
+
+target_sources( ${COMPONENT}
+PRIVATE
+    ${CMAKE_CURRENT_LIST_DIR}/src/packet.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/packetstream.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/packetstream_reader.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/packetstream_writer.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/playback_session.cpp
+)
+
+target_compile_definitions(${COMPONENT} PRIVATE "PANGOLIN_VERSION_STRING=\"${PANGOLIN_VERSION}\"")
+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}
+)

third-party/DPVO/Pangolin/components/pango_packetstream/include/pangolin/log/packet.h

@@ -0,0 +1,70 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * 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 <mutex>
+
+#include <pangolin/log/packetstream.h>
+#include <pangolin/log/packetstream_source.h>
+
+namespace pangolin {
+
+// Encapsulate serialized reading of Packet from stream.
+struct PANGOLIN_EXPORT Packet
+{
+    Packet(PacketStream& s, std::unique_lock<std::recursive_mutex>&& mutex, std::vector<PacketStreamSource>& srcs);
+    Packet(const Packet&) = delete;
+    Packet(Packet&& o);
+    ~Packet();
+
+    size_t BytesRead() const;
+    int BytesRemaining() const;
+
+    PacketStream& Stream()
+    {
+        return _stream;
+    }
+
+    PacketStreamSourceId src;
+    int64_t time;
+    size_t size;
+    size_t sequence_num;
+    picojson::value meta;
+    std::streampos frame_streampos;
+
+private:
+    void ParsePacketHeader(PacketStream& s, std::vector<PacketStreamSource>& srcs);
+    void ReadRemaining();
+
+    PacketStream& _stream;
+
+    std::unique_lock<std::recursive_mutex> lock;
+
+    std::streampos data_streampos;
+    size_t _data_len;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_packetstream/include/pangolin/log/packetstream.h

@@ -0,0 +1,111 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * 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/platform.h>
+
+#include <pangolin/log/packetstream_tags.h>
+#include <pangolin/utils/file_utils.h>
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT PacketStream: public std::ifstream
+{
+public:
+    PacketStream()
+        : _is_pipe(false)
+    {
+        cclear();
+    }
+
+    PacketStream(const std::string& filename)
+        : Base(filename.c_str(), std::ios::in | std::ios::binary),
+          _is_pipe(IsPipe(filename))
+    {
+        cclear();
+    }
+
+    bool seekable() const
+    {
+        return is_open() && !_is_pipe;
+    }
+
+    void open(const std::string& filename)
+    {
+        close();
+        _is_pipe = IsPipe(filename);
+        Base::open(filename.c_str(), std::ios::in | std::ios::binary);
+    }
+
+    void close()
+    {
+        cclear();
+        if (Base::is_open()) Base::close();
+    }
+
+    void seekg(std::streampos target);
+
+    void seekg(std::streamoff off, std::ios_base::seekdir way);
+
+    std::streampos tellg();
+
+    size_t read(char* target, size_t len);
+
+    char get();
+
+    size_t skip(size_t len);
+
+    size_t readUINT();
+
+    int64_t readTimestamp();
+
+    PangoTagType peekTag();
+
+    PangoTagType readTag();
+
+    PangoTagType readTag(PangoTagType);
+
+    PangoTagType syncToTag();
+
+private:
+    using Base = std::ifstream;
+
+    bool _is_pipe;
+    PangoTagType _tag;
+
+    // Amount of frame data left to read. Tracks our position within a data block.
+
+
+    void cclear() {
+        _tag = 0;
+    }
+};
+
+
+}

third-party/DPVO/Pangolin/components/pango_packetstream/include/pangolin/log/packetstream_reader.h

@@ -0,0 +1,120 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * 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 <mutex>
+#include <thread>
+
+#include <pangolin/log/packet.h>
+
+#include <pangolin/log/sync_time.h>
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/utils/timer.h>
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT PacketStreamReader
+{
+public:
+    PacketStreamReader();
+
+    PacketStreamReader(const std::string& filename);
+
+    ~PacketStreamReader();
+
+    void Open(const std::string& filename);
+
+    void Close();
+
+    const std::vector<PacketStreamSource>&
+    Sources() const
+    {
+        return _sources;
+    }
+
+    // Grab Next available frame packetstream
+    Packet NextFrame();
+
+    // Grab Next available frame in packetstream from src, discarding other frames.
+    Packet NextFrame(PacketStreamSourceId src);
+
+    bool Good() const
+    {
+        return _stream.good();
+    }
+
+    // Jumps to a particular packet.
+    size_t Seek(PacketStreamSourceId src, size_t framenum);
+
+    // Jumps to the first packet with time >= time
+    size_t Seek(PacketStreamSourceId src, SyncTime::TimePoint time);
+
+    void FixFileIndex();
+
+private:
+    bool GoodToRead();
+
+    bool SetupIndex();
+
+    void ParseHeader();
+
+    void ParseNewSource();
+
+    bool ParseIndex();
+
+    void RebuildIndex();
+
+    void AppendIndex();
+
+    std::streampos ParseFooter();
+
+    void SkipSync();
+
+    void ReSync() {
+        _stream.syncToTag();
+    }
+
+    std::string _filename;
+    std::vector<PacketStreamSource> _sources;
+    SyncTime::TimePoint packet_stream_start;
+
+    PacketStream _stream;
+    std::recursive_mutex _mutex;
+
+    bool _is_pipe;
+    int _pipe_fd;
+};
+
+
+
+
+
+
+
+
+}

third-party/DPVO/Pangolin/components/pango_packetstream/include/pangolin/log/packetstream_source.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <iostream>
+#include <pangolin/platform.h>
+#include <pangolin/utils/picojson.h>
+
+namespace pangolin {
+
+using PacketStreamSourceId = size_t;
+
+struct PANGOLIN_EXPORT PacketStreamSource
+{
+    struct PacketInfo
+    {
+        std::streampos pos;
+        int64_t capture_time;
+    };
+
+    PacketStreamSource()
+        : id(static_cast<PacketStreamSourceId>(-1)),
+          version(0),
+          data_alignment_bytes(1),
+          data_size_bytes(0),
+          next_packet_id(0)
+    {
+    }
+
+    std::streampos FindSeekLocation(size_t packet_id)
+    {
+        if(packet_id < index.size()) {
+            return index[packet_id].pos;
+        }else{
+            return std::streampos(-1);
+        }
+
+    }
+
+    int64_t NextPacketTime() const
+    {
+        if(next_packet_id < index.size()) {
+            return index[next_packet_id].capture_time;
+        }else{
+            return 0;
+        }
+    }
+
+    std::string     driver;
+    size_t          id;
+    std::string     uri;
+    picojson::value info;
+    int64_t         version;
+    int64_t         data_alignment_bytes;
+    std::string     data_definitions;
+    int64_t         data_size_bytes;
+
+    // Index keyed by packet_id
+    std::vector<PacketInfo> index;
+
+    // Based on current position in stream
+    size_t          next_packet_id;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_packetstream/include/pangolin/log/packetstream_tags.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <string>
+
+namespace pangolin {
+
+using PangoTagType = uint32_t;
+
+const static std::string PANGO_MAGIC = "PANGO";
+
+const static std::string pss_src_driver = "driver";
+const static std::string pss_src_id = "id";
+const static std::string pss_src_info = "info";
+const static std::string pss_src_uri = "uri";
+const static std::string pss_src_packet = "packet";
+const static std::string pss_src_version = "version";
+const static std::string pss_pkt_alignment_bytes = "alignment_bytes";
+const static std::string pss_pkt_definitions = "definitions";
+const static std::string pss_pkt_size_bytes = "size_bytes";
+const static std::string pss_pkt_format_written = "format_written";
+
+const unsigned int TAG_LENGTH = 3;
+
+#define PANGO_TAG(a,b,c) ( (c<<16) | (b<<8) | a)
+const PangoTagType TAG_PANGO_HDR    = PANGO_TAG('L', 'I', 'N');
+const PangoTagType TAG_PANGO_MAGIC  = PANGO_TAG('P', 'A', 'N');
+const PangoTagType TAG_PANGO_SYNC   = PANGO_TAG('S', 'Y', 'N');
+const PangoTagType TAG_PANGO_STATS  = PANGO_TAG('S', 'T', 'A');
+const PangoTagType TAG_PANGO_FOOTER = PANGO_TAG('F', 'T', 'R');
+const PangoTagType TAG_ADD_SOURCE   = PANGO_TAG('S', 'R', 'C');
+const PangoTagType TAG_SRC_JSON     = PANGO_TAG('J', 'S', 'N');
+const PangoTagType TAG_SRC_PACKET   = PANGO_TAG('P', 'K', 'T');
+const PangoTagType TAG_END          = PANGO_TAG('E', 'N', 'D');
+#undef PANGO_TAG
+
+inline std::string tagName(int v)
+{
+    char b[4];
+    b[0] = v&0xff;
+    b[1] = (v>>8)&0xff;
+    b[2] = (v>>16)&0xff;
+    b[3] = 0x00;
+    return std::string(b);
+}
+
+}

third-party/DPVO/Pangolin/components/pango_packetstream/include/pangolin/log/packetstream_writer.h

@@ -0,0 +1,173 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <ostream>
+
+#include <pangolin/log/packetstream.h>
+#include <pangolin/log/packetstream_source.h>
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/utils/threadedfilebuf.h>
+
+namespace pangolin
+{
+
+class PANGOLIN_EXPORT PacketStreamWriter
+{
+public:
+    PacketStreamWriter()
+        : _stream(&_buffer), _indexable(false), _open(false), _bytes_written(0)
+    {
+        _stream.exceptions(std::ostream::badbit);
+    }
+
+    PacketStreamWriter(const std::string& filename, size_t buffer_size  = 100*1024*1024)
+        : _buffer(pangolin::PathExpand(filename), buffer_size), _stream(&_buffer),
+          _indexable(!IsPipe(filename)), _open(_stream.good()), _bytes_written(0)
+    {
+        _stream.exceptions(std::ostream::badbit);
+        WriteHeader();
+    }
+
+    ~PacketStreamWriter() {
+        Close();
+    }
+
+    void Open(const std::string& filename, size_t buffer_size = 100 * 1024 * 1024)
+    {
+        Close();
+        _buffer.open(filename, buffer_size);
+        _open = _stream.good();
+        _bytes_written = 0;
+        _indexable = !IsPipe(filename);
+        WriteHeader();
+    }
+
+    void Close()
+    {
+        if (_open)
+        {
+            if (_indexable) {
+                WriteEnd();
+            }
+            _buffer.close();
+            _open = false;
+        }
+    }
+
+    // Does not write footer or index.
+    void ForceClose()
+    {
+        if (_open)
+        {
+        _buffer.force_close();
+        Close();
+        }
+    }
+
+
+    // Writes to the stream immediately upon add. Return source id # and writes
+    // source id # to argument struct
+    PacketStreamSourceId AddSource(PacketStreamSource& source);
+
+    // If constructor is called inline
+    PacketStreamSourceId AddSource(const PacketStreamSource& source);
+
+    void WriteSourcePacket(
+        PacketStreamSourceId src, const char* source,const int64_t receive_time_us,
+        size_t sourcelen, const picojson::value& meta = picojson::value()
+    );
+
+    // For stream read/write synchronization. Note that this is NOT the same as
+    // time synchronization on playback of iPacketStreams.
+    void WriteSync();
+
+    // Writes the end of the stream data, including the index. Does NOT close
+    // the underlying ostream.
+    void WriteEnd();
+
+    const std::vector<PacketStreamSource>& Sources() const {
+        return _sources;
+    }
+
+    bool IsOpen() const {
+        return _open;
+    }
+
+private:
+    void WriteHeader();
+    void Write(const PacketStreamSource&);
+    void WriteMeta(PacketStreamSourceId src, const picojson::value& data);
+
+    threadedfilebuf _buffer;
+    std::ostream _stream;
+    bool _indexable, _open;
+
+    std::vector<PacketStreamSource> _sources;
+    size_t _bytes_written;
+    std::recursive_mutex _lock;
+};
+
+inline void writeCompressedUnsignedInt(std::ostream& writer, size_t n)
+{
+    while (n >= 0x80)
+    {
+    writer.put(0x80 | (n & 0x7F));
+    n >>= 7;
+    }
+    writer.put(static_cast<unsigned char>(n));
+}
+
+inline void writeTimestamp(std::ostream& writer, int64_t time_us)
+{
+    writer.write(reinterpret_cast<const char*>(&time_us), sizeof(decltype(time_us)));
+}
+
+inline void writeTag(std::ostream& writer, const PangoTagType tag)
+{
+    writer.write(reinterpret_cast<const char*>(&tag), TAG_LENGTH);
+}
+
+inline picojson::value SourceStats(const std::vector<PacketStreamSource>& srcs)
+{
+    picojson::value stat;
+    stat["num_sources"] = srcs.size();
+    stat["src_packet_index"] = picojson::array();
+    stat["src_packet_times"] = picojson::array();
+
+    for(auto& src : srcs) {
+        picojson::array pkt_index, pkt_times;
+        for (const PacketStreamSource::PacketInfo& frame : src.index) {
+            pkt_index.emplace_back(frame.pos);
+            pkt_times.emplace_back(frame.capture_time);
+        }
+        stat["src_packet_index"].push_back(std::move(pkt_index));
+        stat["src_packet_times"].push_back(std::move(pkt_times));
+    }
+    return stat;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_packetstream/include/pangolin/log/playback_session.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include <pangolin/log/packetstream_reader.h>
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/utils/param_set.h>
+
+namespace pangolin {
+
+class Params;
+
+class PlaybackSession
+{
+public:
+    // Singleton Instance
+    static std::shared_ptr<PlaybackSession> Default();
+
+    // Return thread-safe, shared instance of PacketStreamReader, providing
+    // serialised read for PacketStreamReader
+    std::shared_ptr<PacketStreamReader> Open(const std::string& filename)
+    {
+        const std::string path = SanitizePath(PathExpand(filename));
+
+        auto i = readers.find(path);
+        if(i == readers.end()) {
+            auto psr = std::make_shared<PacketStreamReader>(path);
+            readers[path] = psr;
+            return psr;
+        }else{
+            return i->second;
+        }
+    }
+
+    // Should only be called if there's no playbacks
+    // in flight
+    void Clear() {
+      readers.clear();
+      time.Reset();
+    }
+
+    SyncTime& Time()
+    {
+        return time;
+    }
+    static std::shared_ptr<PlaybackSession> ChooseFromParams(const ParamReader& reader);
+    static std::shared_ptr<PlaybackSession> ChooseFromParams(const Params& params);
+private:
+    static std::shared_ptr<PlaybackSession> Choose(bool ordered_playback);
+    std::map<std::string,std::shared_ptr<PacketStreamReader>> readers;
+    SyncTime time;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_packetstream/include/pangolin/log/sync_time.h

@@ -0,0 +1,237 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/platform.h>
+#include <pangolin/utils/signal_slot.h>
+#include <pangolin/utils/timer.h>
+
+#include <atomic>
+#include <condition_variable>
+#include <mutex>
+#include <queue>
+
+namespace pangolin
+{
+
+// Lightweight timestamp class to allow synchronized playback from the same (or a different) stream.
+// All playback functions called with the same SyncTime will be time-synchronized, and will remain synchronized on seek() if the SyncTime is passed in when seeking.
+// Playback with multiple SyncTimes (on the same or different streams) should also be synced, even in different processes or systems (underlying clock sync is not required).
+// However, playback with multiple SyncTimes will break on seek().
+class PANGOLIN_EXPORT SyncTime
+{
+public:
+    using Clock = baseclock;
+    using Duration = Clock::duration;
+    using TimePoint = Clock::time_point;
+
+    struct SeekInterruption: std::runtime_error
+    {
+        SeekInterruption() : std::runtime_error("Time queue invalidated by seek"){}
+    };
+
+    SyncTime(Duration virtual_clock_offset = std::chrono::milliseconds(0))
+        : seeking(false)
+    {
+        SetOffset(virtual_clock_offset);
+    }
+
+    // Should only be called if no other callers are currently calling it
+    void Reset() {
+      seeking = false;
+      time_queue_us.clear();
+      SetOffset(std::chrono::milliseconds(0));
+    }
+
+    // No copy constructor
+    SyncTime(const SyncTime&) = delete;
+
+    void SetOffset(Duration virtual_clock_offset)
+    {
+        virtual_offset = virtual_clock_offset;
+    }
+
+    void SetClock(TimePoint virtual_now)
+    {
+        virtual_offset = virtual_now - Clock::now();
+    }
+
+    TimePoint TimeNow() const
+    {
+        return Clock::now() + virtual_offset;
+    }
+
+    TimePoint ToVirtual(TimePoint real) const
+    {
+        return real + virtual_offset;
+    }
+
+    TimePoint ToReal(TimePoint virt) const
+    {
+        return virt - virtual_offset;
+    }
+
+    void WaitUntil(TimePoint virtual_time) const
+    {
+        std::this_thread::sleep_until( ToReal(virtual_time) );
+    }
+
+    int64_t QueueEvent(int64_t new_event_time_us)
+    {
+        return WaitDequeueAndQueueEvent(0, new_event_time_us);
+    }
+
+    void DequeueEvent(int64_t event_time_us)
+    {
+        std::unique_lock<std::mutex> l(time_mutex);
+        auto i = std::find(time_queue_us.begin(), time_queue_us.end(), event_time_us);
+        PANGO_ENSURE(i != time_queue_us.end());
+        time_queue_us.erase(i);
+        queue_changed.notify_all();
+    }
+
+    int64_t WaitDequeueAndQueueEvent(int64_t event_time_us, int64_t new_event_time_us =0 )
+    {
+        std::unique_lock<std::mutex> l(time_mutex);
+
+        if(event_time_us) {
+            PANGO_ENSURE(time_queue_us.size());
+
+            // Wait until we're top the priority-queue
+            queue_changed.wait(l, [&](){
+                if(seeking) {
+                    // Time queue will be invalidated on seek.
+                    // Unblock without action
+                    throw SeekInterruption();
+                }
+                return time_queue_us.back() == event_time_us;
+            });
+
+            // Dequeue
+            time_queue_us.pop_back();
+        }
+
+        if(new_event_time_us) {
+            // Add the new event whilst we still hold the lock, so that our
+            // event can't be missed
+            insert_sorted(time_queue_us, new_event_time_us, std::greater<int64_t>());
+
+            if(time_queue_us.back() == new_event_time_us) {
+                // Return to avoid yielding when we're next.
+                return new_event_time_us;
+            }
+        }
+
+        // Only yield if another device is next
+        queue_changed.notify_all();
+        return new_event_time_us;
+    }
+
+    void NotifyAll()
+    {
+        queue_changed.notify_all();
+    }
+
+    std::mutex& TimeMutex()
+    {
+        return time_mutex;
+    }
+
+    void Stop()
+    {
+        seeking = true;
+        OnTimeStop();
+        queue_changed.notify_all();
+    }
+
+    void Start()
+    {
+        OnTimeStart();
+        seeking=false;
+    }
+
+    void Seek(TimePoint t)
+    {
+        Stop();
+        OnSeek(t);
+        Start();
+    }
+
+    sigslot::signal<> OnTimeStart;
+
+    sigslot::signal<> OnTimeStop;
+
+    sigslot::signal<TimePoint> OnSeek;
+
+private:
+    template< typename T, typename Pred >
+    static typename std::vector<T>::iterator
+    insert_sorted( std::vector<T> & vec, T const& item, Pred pred )
+    {
+        return vec.insert (
+           std::upper_bound( vec.begin(), vec.end(), item, pred ), item
+        );
+    }
+
+    std::vector<int64_t> time_queue_us;
+    Duration virtual_offset;
+    std::mutex time_mutex;
+    std::condition_variable queue_changed;
+    bool seeking;
+};
+
+struct SyncTimeEventPromise
+{
+    SyncTimeEventPromise(SyncTime& sync, int64_t time_us = 0)
+        : sync(sync), time_us(time_us)
+    {
+        sync.QueueEvent(time_us);
+    }
+
+    ~SyncTimeEventPromise()
+    {
+        Cancel();
+    }
+
+    void Cancel()
+    {
+        if(time_us) {
+            sync.DequeueEvent(time_us);
+            time_us = 0;
+        }
+    }
+
+    void WaitAndRenew(int64_t new_time_us)
+    {
+        time_us = sync.WaitDequeueAndQueueEvent(time_us, new_time_us);
+    }
+
+private:
+    SyncTime& sync;
+    int64_t time_us;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_packetstream/src/packet.cpp

@@ -0,0 +1,79 @@
+#include <pangolin/log/packet.h>
+
+namespace pangolin {
+
+
+Packet::Packet(PacketStream& s, std::unique_lock<std::recursive_mutex>&& lock, std::vector<PacketStreamSource>& srcs)
+    : _stream(s), lock(std::move(lock))
+{
+    ParsePacketHeader(s, srcs);
+}
+
+Packet::Packet(Packet&& o)
+    : src(o.src), time(o.time), size(o.size), sequence_num(o.sequence_num),
+      meta(std::move(o.meta)), frame_streampos(o.frame_streampos), _stream(o._stream),
+      lock(std::move(o.lock)), data_streampos(o.data_streampos), _data_len(o._data_len)
+{
+    o._data_len = 0;
+}
+
+Packet::~Packet()
+{
+    ReadRemaining();
+}
+
+size_t Packet::BytesRead() const
+{
+    return _stream.tellg() - data_streampos;
+}
+
+int Packet::BytesRemaining() const
+{
+    if(_data_len) {
+        return (int)_data_len - (int)BytesRead();
+    }else{
+        return 0;
+    }
+}
+
+void Packet::ParsePacketHeader(PacketStream& s, std::vector<PacketStreamSource>& srcs)
+{
+    size_t json_src = -1;
+
+    frame_streampos = s.tellg();
+    if (s.peekTag() == TAG_SRC_JSON)
+    {
+        s.readTag(TAG_SRC_JSON);
+        json_src = s.readUINT();
+        picojson::parse(meta, s);
+    }
+
+    s.readTag(TAG_SRC_PACKET);
+    time = s.readTimestamp();
+
+    src = s.readUINT();
+    PANGO_ENSURE(json_src == size_t(-1) || json_src == src, "Frame preceded by metadata for a mismatched source. Stream may be corrupt.");
+
+    PacketStreamSource& src_packet = srcs[src];
+
+    size = src_packet.data_size_bytes;
+    if (!size) {
+        size = s.readUINT();
+    }
+    sequence_num = src_packet.next_packet_id++;
+
+    _data_len = size;
+    data_streampos = s.tellg();
+}
+
+void Packet::ReadRemaining()
+{
+    int bytes_left = BytesRemaining();
+
+    while(bytes_left > 0 && Stream().good()) {
+        Stream().skip(bytes_left);
+        bytes_left = BytesRemaining();
+    }
+}
+
+}

third-party/DPVO/Pangolin/components/pango_packetstream/src/packetstream.cpp

@@ -0,0 +1,146 @@
+#include <pangolin/log/packetstream.h>
+#include <stdexcept>
+
+namespace pangolin {
+
+size_t PacketStream::readUINT()
+{
+    size_t n = 0;
+    size_t v = get();
+    uint32_t shift = 0;
+    while (good() && (v & 0x80))
+    {
+        n |= (v & 0x7F) << shift;
+        shift += 7;
+        v = get();
+    }
+    if (!good())
+        return static_cast<size_t>(-1);
+    return n | (v & 0x7F) << shift;
+}
+
+int64_t PacketStream::readTimestamp()
+{
+    int64_t time_us;
+    read(reinterpret_cast<char*>(&time_us), sizeof(int64_t));
+    return time_us;
+}
+
+PangoTagType PacketStream::readTag()
+{
+    auto r = peekTag();
+    _tag = 0;
+    return r;
+}
+
+PangoTagType PacketStream::readTag(PangoTagType x)
+{
+    auto r = readTag();
+    if (r != x)
+        throw std::runtime_error(("Tag mismatch error: expected tag '" + tagName(r) + "' does not match found tag '" + tagName(x) + "'").c_str());
+    return r;
+}
+
+PangoTagType PacketStream::peekTag()
+{
+    if (!_tag)
+    {
+        _tag = 0;
+        Base::read(reinterpret_cast<char*>(&_tag), TAG_LENGTH);
+        if (!good())
+            _tag = TAG_END;
+    }
+    return _tag;
+}
+
+char PacketStream::get()
+{
+    _tag = 0;
+    return Base::get();
+}
+
+size_t PacketStream::read(char* target, size_t len)
+{
+    _tag = 0;
+    Base::read(target, len);
+    return gcount();
+}
+
+size_t PacketStream::skip(size_t len)
+{
+    if (seekable()) {
+        Base::seekg(len, std::ios_base::cur);
+    } else {
+        Base::ignore(len);
+    }
+    cclear();
+    return len;
+}
+
+std::streampos PacketStream::tellg()
+{
+    if (_tag) {
+        return Base::tellg() - std::streamoff(TAG_LENGTH);
+    }else{
+        return Base::tellg();
+    }
+}
+
+void PacketStream::seekg(std::streampos target)
+{
+    if (seekable()) {
+        cclear();
+        Base::seekg(target);
+    }
+}
+
+void PacketStream::seekg(std::streamoff off, std::ios_base::seekdir way)
+{
+    if (seekable()) {
+        cclear();
+        Base::seekg(off, way);
+    }
+}
+
+static bool valid(PangoTagType t)
+{
+    switch (t)
+    {
+    case TAG_PANGO_SYNC:
+        case TAG_ADD_SOURCE:
+        case TAG_SRC_JSON:
+        case TAG_SRC_PACKET:
+        case TAG_PANGO_STATS:
+        case TAG_PANGO_FOOTER:
+        case TAG_END:
+        case TAG_PANGO_HDR:
+        case TAG_PANGO_MAGIC:
+        return true;
+    default:
+        return false;
+    }
+}
+
+PangoTagType PacketStream::syncToTag() //scan through chars one by one until the last three look like a tag
+{
+    peekTag();
+    char * buffer = reinterpret_cast<char*>(&_tag);
+
+    buffer[3] = 0;
+
+    do
+    {
+        buffer[0] = buffer[1];
+        buffer[1] = buffer[2];
+        buffer[2] = get();
+    }
+    while (good() && !valid(_tag));
+
+    if (!good())
+        _tag = TAG_END;
+
+    return _tag;
+
+}
+
+}

third-party/DPVO/Pangolin/components/pango_packetstream/src/packetstream_reader.cpp

@@ -0,0 +1,428 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * 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/log/packetstream_reader.h>
+#include <pangolin/log/packetstream_writer.h>
+
+using std::string;
+using std::istream;
+using std::ios;
+using std::lock_guard;
+using std::runtime_error;
+using std::ios_base;
+using std::streampos;
+using std::streamoff;
+
+#include <thread>
+
+#ifndef _WIN_
+#  include <unistd.h>
+#endif
+
+namespace pangolin
+{
+
+PacketStreamReader::PacketStreamReader()
+    : _pipe_fd(-1)
+{
+}
+
+PacketStreamReader::PacketStreamReader(const std::string& filename)
+    : _pipe_fd(-1)
+{
+    Open(filename);
+}
+
+PacketStreamReader::~PacketStreamReader()
+{
+    Close();
+}
+
+void PacketStreamReader::Open(const std::string& filename)
+{
+    std::lock_guard<std::recursive_mutex> lg(_mutex);
+
+    Close();
+
+    _filename = filename;
+    _is_pipe = IsPipe(filename);
+    _stream.open(filename);
+
+    if (!_stream.is_open())
+        throw runtime_error(
+            "Cannot open stream from " + filename +
+            "\nAre you sure the file exists?"
+            );
+
+    for (auto i : PANGO_MAGIC)
+    {
+        if (_stream.get() != i)
+            throw runtime_error("Unrecognised file header.");
+        if (!_stream.good())
+            throw runtime_error("Bad stream");
+    }
+
+
+    ParseHeader();
+
+    while (_stream.peekTag() == TAG_ADD_SOURCE) {
+        ParseNewSource();
+    }
+
+    if(!SetupIndex()) {
+        FixFileIndex();
+    }
+}
+
+void PacketStreamReader::Close() {
+    std::lock_guard<std::recursive_mutex> lg(_mutex);
+
+    _stream.close();
+    _sources.clear();
+
+#ifndef _WIN_
+    if (_pipe_fd != -1) {
+        close(_pipe_fd);
+    }
+#endif
+}
+
+void PacketStreamReader::ParseHeader()
+{
+    _stream.readTag(TAG_PANGO_HDR);
+
+    picojson::value json_header;
+    picojson::parse(json_header, _stream);
+
+    // File timestamp
+    const int64_t start_us = json_header["time_us"].get<int64_t>();
+    packet_stream_start = SyncTime::TimePoint() + std::chrono::microseconds(start_us);
+
+    _stream.get(); // consume newline
+}
+
+void PacketStreamReader::ParseNewSource()
+{
+    _stream.readTag(TAG_ADD_SOURCE);
+    picojson::value json;
+    picojson::parse(json, _stream);
+    _stream.get(); // consume newline
+
+
+    const size_t src_id = json[pss_src_id].get<int64_t>();
+
+    if(_sources.size() <= src_id) {
+        _sources.resize(src_id+1);
+    }
+
+    PacketStreamSource& pss = _sources[src_id];
+    pss.id = src_id;
+    pss.driver = json[pss_src_driver].get<string>();
+    pss.uri = json[pss_src_uri].get<string>();
+    pss.info = json[pss_src_info];
+    pss.version = json[pss_src_version].get<int64_t>();
+    pss.data_alignment_bytes = json[pss_src_packet][pss_pkt_alignment_bytes].get<int64_t>();
+    pss.data_definitions = json[pss_src_packet][pss_pkt_definitions].get<string>();
+    pss.data_size_bytes = json[pss_src_packet][pss_pkt_size_bytes].get<int64_t>();
+}
+
+bool PacketStreamReader::SetupIndex()
+{
+    bool index_good = false;
+
+    if (_stream.seekable())
+    {
+        // Save current position
+        std::streampos pos = _stream.tellg();
+
+        // Look for footer at end of file (TAG_PANGO_FOOTER + index position).
+        _stream.seekg(-(static_cast<istream::off_type>(sizeof(uint64_t)) + TAG_LENGTH), ios_base::end);
+        if (_stream.peekTag() == TAG_PANGO_FOOTER)
+        {
+            //parsing the footer returns the index position
+            _stream.seekg(ParseFooter());
+            if (_stream.peekTag() == TAG_PANGO_STATS) {
+                // Read the pre-build index from the file
+                index_good = ParseIndex();
+            }
+        }
+
+        // Restore previous location
+        _stream.clear();
+        _stream.seekg(pos);
+    }
+
+    return index_good;
+}
+
+streampos PacketStreamReader::ParseFooter() //returns position of index.
+{
+    _stream.readTag(TAG_PANGO_FOOTER);
+    uint64_t index=0;
+    size_t bytes_read = _stream.read(reinterpret_cast<char*>(&index), sizeof(index));
+    PANGO_ENSURE(bytes_read == sizeof(index));
+    return index;
+}
+
+bool PacketStreamReader::ParseIndex()
+{
+    _stream.readTag(TAG_PANGO_STATS);
+    picojson::value json;
+    picojson::parse(json, _stream);
+
+    const bool index_good = json.contains("src_packet_index") && json.contains("src_packet_times");
+
+    if (index_good)
+    {
+        // This is a two-dimensional serialized array, [source id][sequence number] ---> packet position in stream
+        const auto& json_index = json["src_packet_index"].get<picojson::array>();
+        const auto& json_times = json["src_packet_times"].get<picojson::array>();
+
+        // We shouldn't have seen more sources than exist in the index
+        PANGO_ENSURE(_sources.size() <= json_index.size());
+        PANGO_ENSURE(json_index.size() == json_times.size());
+
+        _sources.resize(json_index.size());
+
+        // Populate index
+        for(size_t i=0; i < _sources.size(); ++i) {
+            PANGO_ENSURE(json_index[i].size() == json_times[i].size());
+            _sources[i].index.resize(json_index[i].size());
+            for(size_t f=0; f < json_index[i].size(); ++f) {
+                _sources[i].index[f].pos = json_index[i][f].get<int64_t>();
+                _sources[i].index[f].capture_time = json_times[i][f].get<int64_t>();
+            }
+        }
+    }
+
+    return index_good;
+}
+
+bool PacketStreamReader::GoodToRead()
+{
+    if(!_stream.good()) {
+#ifndef _WIN_
+        if (_is_pipe)
+        {
+            if (_pipe_fd == -1) {
+                _pipe_fd = ReadablePipeFileDescriptor(_filename);
+            }
+
+            if (_pipe_fd != -1) {
+                // Test whether the pipe has data to be read. If so, open the
+                // file stream and start reading. After this point, the file
+                // descriptor is owned by the reader.
+                if (PipeHasDataToRead(_pipe_fd))
+                {
+                    close(_pipe_fd);
+                    _pipe_fd = -1;
+                    Open(_filename);
+                    return _stream.good();
+                }
+            }
+        }
+#endif
+
+        return false;
+    }
+
+    return true;
+
+}
+
+Packet PacketStreamReader::NextFrame()
+{
+    std::unique_lock<std::recursive_mutex> lock(_mutex);
+
+    while (GoodToRead())
+    {
+        const PangoTagType t = _stream.peekTag();
+
+        switch (t)
+        {
+        case TAG_PANGO_SYNC:
+            SkipSync();
+            break;
+        case TAG_ADD_SOURCE:
+            ParseNewSource();
+            break;
+        case TAG_SRC_JSON: //frames are sometimes preceded by metadata, but metadata must ALWAYS be followed by a frame from the same source.
+        case TAG_SRC_PACKET:
+            return Packet(_stream, std::move(lock), _sources);
+        case TAG_PANGO_STATS:
+            ParseIndex();
+            break;
+        case TAG_PANGO_FOOTER: //end of frames
+        case TAG_END:
+            throw std::runtime_error("PacketStreamReader: end of stream");
+        case TAG_PANGO_HDR: //shoudln't encounter this
+            ParseHeader();
+            break;
+        case TAG_PANGO_MAGIC: //or this
+            SkipSync();
+            break;
+        default: //or anything else
+            pango_print_warn("Unexpected packet type: \"%s\". Resyncing()\n", tagName(t).c_str());
+            ReSync();
+            break;
+        }
+    }
+
+    // No frame
+    throw std::runtime_error("PacketStreamReader: no frame");
+}
+
+Packet PacketStreamReader::NextFrame(PacketStreamSourceId src)
+{
+    while (1)
+    {
+        // This will throw if nothing is left.
+        auto fi = NextFrame();
+        if (fi.src == src) {
+            return fi;
+        }
+    }
+}
+
+void PacketStreamReader::RebuildIndex()
+{
+    lock_guard<decltype(_mutex)> lg(_mutex);
+
+    if(_stream.seekable()) {
+        pango_print_warn("Index for '%s' bad / outdated. Rebuilding.\n", _filename.c_str());
+
+        // Save current position
+        std::streampos pos = _stream.tellg();
+
+        // Clear existing index
+        for(PacketStreamSource& s : _sources) {
+            s.index.clear();
+            s.next_packet_id = 0;
+        }
+
+        // Read through entire file, updating index
+        try{
+            while (1)
+            {
+                // This will throw if we've run out of frames
+                auto fi = NextFrame();
+                PacketStreamSource& s = _sources[fi.src];
+                PANGO_ENSURE(s.index.size() == fi.sequence_num);
+                s.index.push_back({fi.frame_streampos, fi.time});
+            }
+        }catch(...){
+        }
+
+        // Reset Packet id's
+        for(PacketStreamSource& s : _sources) {
+            s.next_packet_id = 0;
+        }
+
+        // Restore previous location
+        _stream.clear();
+        _stream.seekg(pos);
+    }
+}
+
+void PacketStreamReader::AppendIndex()
+{
+    lock_guard<decltype(_mutex)> lg(_mutex);
+
+    if(_stream.seekable()) {
+        // Open file again for append
+        std::ofstream of(_filename, std::ios::app | std::ios::binary);
+        if(of.is_open()) {
+            pango_print_warn("Appending new index to '%s'.\n", _filename.c_str());
+            uint64_t indexpos = (uint64_t)of.tellp();
+            writeTag(of, TAG_PANGO_STATS);
+            SourceStats(_sources).serialize(std::ostream_iterator<char>(of), false);
+            writeTag(of, TAG_PANGO_FOOTER);
+            of.write(reinterpret_cast<char*>(&indexpos), sizeof(uint64_t));
+        }
+    }
+}
+
+void PacketStreamReader::FixFileIndex()
+{
+    if(_stream.seekable())
+    {
+        RebuildIndex();
+        AppendIndex();
+    }
+}
+
+size_t PacketStreamReader::Seek(PacketStreamSourceId src, size_t framenum)
+{
+    lock_guard<decltype(_mutex)> lg(_mutex);
+
+    PANGO_ASSERT(_stream.seekable());
+    PANGO_ASSERT(src < _sources.size());
+    PacketStreamSource& source = _sources[src];
+    PANGO_ASSERT(framenum < source.index.size());
+
+    if(source.index[framenum].pos > 0) {
+        _stream.clear();
+        _stream.seekg(source.index[framenum].pos);
+        source.next_packet_id = framenum;
+    }
+    return source.next_packet_id;
+}
+
+// Jumps to the first packet with time >= time
+size_t PacketStreamReader::Seek(PacketStreamSourceId src, SyncTime::TimePoint time)
+{
+    PacketStreamSource& source = _sources[src];
+
+    PacketStreamSource::PacketInfo v = {
+        0, std::chrono::duration_cast<std::chrono::microseconds>(time.time_since_epoch()).count()
+    };
+
+    // Find time in indextime
+    auto lb = std::lower_bound(
+        source.index.begin(), source.index.end(), v,
+        [](const PacketStreamSource::PacketInfo& a, const PacketStreamSource::PacketInfo& b){
+            return a.capture_time < b.capture_time;
+        }
+    );
+
+    if(lb != source.index.end()) {
+        const size_t frame_num = lb - source.index.begin();
+        return Seek(src, frame_num);
+    }else{
+        return source.next_packet_id;
+    }
+}
+
+void PacketStreamReader::SkipSync()
+{
+    //Assume we have just read PAN, read GO
+    if (_stream.get() != 'G' && _stream.get() != 'O')
+        throw std::runtime_error("Unknown packet type.");
+
+    while (_stream.peekTag() != TAG_SRC_PACKET && _stream.peekTag() != TAG_END)
+        _stream.readTag();
+}
+
+}

third-party/DPVO/Pangolin/components/pango_packetstream/src/packetstream_writer.cpp

@@ -0,0 +1,156 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * 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/log/packetstream_writer.h>
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/utils/timer.h>
+
+using std::ios;
+using std::lock_guard;
+
+#define SCOPED_LOCK lock_guard<decltype(_lock)> lg(_lock)
+
+//#define SCOPED_LOCK
+
+namespace pangolin
+{
+
+static inline const std::string CurrentTimeStr()
+{
+    time_t time_now = time(0);
+    struct tm time_struct = *localtime(&time_now);
+    char buffer[80];
+    strftime(buffer, sizeof(buffer), "%Y-%m-%d %X", &time_struct);
+    return buffer;
+}
+
+void PacketStreamWriter::WriteHeader()
+{
+    SCOPED_LOCK;
+    _stream.write(PANGO_MAGIC.c_str(), PANGO_MAGIC.size());
+    picojson::value pango;
+    pango["pangolin_version"] = PANGOLIN_VERSION_STRING;
+    pango["time_us"] = Time_us(TimeNow());
+    pango["date_created"] = CurrentTimeStr();
+    pango["endian"] = "little_endian";
+
+    writeTag(_stream, TAG_PANGO_HDR);
+    pango.serialize(std::ostream_iterator<char>(_stream), true);
+
+    for (const auto& source : _sources)
+        Write(source);
+}
+
+void PacketStreamWriter::Write(const PacketStreamSource& source)
+{
+    SCOPED_LOCK;
+    picojson::value serialize;
+    serialize[pss_src_driver] = source.driver;
+    serialize[pss_src_id] = source.id;
+    serialize[pss_src_uri] = source.uri;
+    serialize[pss_src_info] = source.info;
+    serialize[pss_src_version] = source.version;
+    serialize[pss_src_packet][pss_pkt_alignment_bytes] = source.data_alignment_bytes;
+    serialize[pss_src_packet][pss_pkt_definitions] = source.data_definitions;
+    serialize[pss_src_packet][pss_pkt_size_bytes] = source.data_size_bytes;
+
+    writeTag(_stream, TAG_ADD_SOURCE);
+    serialize.serialize(std::ostream_iterator<char>(_stream), true);
+}
+
+
+PacketStreamSourceId PacketStreamWriter::AddSource(PacketStreamSource& source)
+{
+    SCOPED_LOCK;
+    source.id = AddSource(const_cast<const PacketStreamSource&>(source));
+    return source.id;
+}
+
+PacketStreamSourceId PacketStreamWriter::AddSource(const PacketStreamSource& source)
+{
+    SCOPED_LOCK;
+    PacketStreamSourceId r = _sources.size(); //source id is by vector position, so we must reassign.
+    _sources.push_back(source);
+    _sources.back().id = r;
+
+    if (_open) //we might be a pipe, in which case we may not be open
+        Write(_sources.back());
+
+    return _sources.back().id;
+}
+
+void PacketStreamWriter::WriteMeta(PacketStreamSourceId src, const picojson::value& data)
+{
+    SCOPED_LOCK;
+    writeTag(_stream, TAG_SRC_JSON);
+    writeCompressedUnsignedInt(_stream, src);
+    data.serialize(std::ostream_iterator<char>(_stream), false);
+}
+
+void PacketStreamWriter::WriteSourcePacket(PacketStreamSourceId src, const char* source, const int64_t receive_time_us, size_t sourcelen, const picojson::value& meta)
+{
+
+    SCOPED_LOCK;
+    _sources[src].index.push_back({_stream.tellp(), receive_time_us});
+
+    if (!meta.is<picojson::null>())
+        WriteMeta(src, meta);
+
+    writeTag(_stream, TAG_SRC_PACKET);
+    writeTimestamp(_stream, receive_time_us);
+    writeCompressedUnsignedInt(_stream, src);
+
+    if (_sources[src].data_size_bytes) {
+        if (sourcelen != static_cast<size_t>(_sources[src].data_size_bytes))
+            throw std::runtime_error("oPacketStream::writePacket --> Tried to write a fixed-size packet with bad size.");
+    } else {
+        writeCompressedUnsignedInt(_stream, sourcelen);
+    }
+
+    _stream.write(source, sourcelen);
+    _bytes_written += sourcelen;
+}
+
+void PacketStreamWriter::WriteSync()
+{
+    SCOPED_LOCK;
+    for (unsigned i = 0; i < 10; ++i)
+    writeTag(_stream, TAG_PANGO_SYNC);
+}
+
+void PacketStreamWriter::WriteEnd()
+{
+    SCOPED_LOCK;
+    if (!_indexable)
+        return;
+
+    auto indexpos = _stream.tellp();
+    writeTag(_stream, TAG_PANGO_STATS);
+    SourceStats(_sources).serialize(std::ostream_iterator<char>(_stream), false);
+    writeTag(_stream, TAG_PANGO_FOOTER);
+    _stream.write(reinterpret_cast<char*>(&indexpos), sizeof(uint64_t));
+}
+
+}

third-party/DPVO/Pangolin/components/pango_packetstream/src/playback_session.cpp

@@ -0,0 +1,32 @@
+#include <pangolin/log/playback_session.h>
+
+namespace pangolin {
+
+std::shared_ptr<PlaybackSession> PlaybackSession::Default()
+{
+    static std::shared_ptr<PlaybackSession> instance = std::make_shared<PlaybackSession>();
+    return instance;
+}
+
+std::shared_ptr<PlaybackSession> PlaybackSession::ChooseFromParams(const ParamReader& reader)
+{
+    return Choose(reader.Get<bool>("OrderedPlayback"));
+}
+
+std::shared_ptr<PlaybackSession> PlaybackSession::ChooseFromParams(const Params& params)
+{
+    return Choose(params.Get<bool>("OrderedPlayback", false));
+}
+
+std::shared_ptr<PlaybackSession> PlaybackSession::Choose(bool use_ordered_playback)
+{
+    if(use_ordered_playback)
+    {
+        return Default();
+    }
+    else
+    {
+        return std::make_shared<PlaybackSession>();
+    }
+}
+}

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

@@ -0,0 +1,17 @@
+get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME)
+
+target_sources( ${COMPONENT}
+PRIVATE
+    ${CMAKE_CURRENT_LIST_DIR}/src/datalog.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/plotter.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/loaders/csv_table_loader.cpp
+)
+
+target_link_libraries(${COMPONENT} pango_display)
+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_plot/include/pangolin/plot/datalog.h

@@ -0,0 +1,243 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/platform.h>
+
+#include <algorithm> // std::min, std::max
+#include <limits>
+#include <memory>
+#include <mutex>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#if defined(HAVE_EIGEN) && !defined(__CUDACC__) //prevent including Eigen in cuda files
+#define USE_EIGEN
+#endif
+
+#ifdef USE_EIGEN
+#include <Eigen/Core>
+#endif
+
+namespace pangolin
+{
+
+/// Simple statistics recorded for a logged input dimension.
+struct DimensionStats
+{
+    DimensionStats()
+    {
+        Reset();
+    }
+
+    void Reset()
+    {
+        isMonotonic = true;
+        sum = 0.0f;
+        sum_sq = 0.0f;
+        min = std::numeric_limits<float>::max();
+        max = std::numeric_limits<float>::lowest();
+    }
+
+    void Add(const float v)
+    {
+        isMonotonic = isMonotonic && (v >= max);
+        sum += v;
+        sum_sq += v*v;
+        min = std::min(min, v);
+        max = std::max(max, v);
+    }
+
+    bool isMonotonic;
+    float sum;
+    float sum_sq;
+    float min;
+    float max;
+};
+
+class DataLogBlock
+{
+public:
+    /// @param dim: dimension of sample
+    /// @param max_samples: maximum number of samples this block can hold
+    /// @param start_id: index of first sample (from entire dataset) in this buffer
+    DataLogBlock(size_t dim, size_t max_samples, size_t start_id)
+        : dim(dim), max_samples(max_samples), samples(0),
+          start_id(start_id)
+    {
+        sample_buffer = std::unique_ptr<float[]>(new float[dim*max_samples]);
+//        stats = std::unique_ptr<DimensionStats[]>(new DimensionStats[dim]);
+    }
+
+    ~DataLogBlock()
+    {
+    }
+
+    size_t Samples() const
+    {
+        return samples;
+    }
+
+    size_t MaxSamples() const
+    {
+        return max_samples;
+    }
+
+    /// Return how many more samples can fit in this block
+    size_t SampleSpaceLeft() const
+    {
+        return MaxSamples()- Samples();
+    }
+
+    bool IsFull() const
+    {
+        return Samples() >= MaxSamples();
+    }
+
+    /// Add data to block
+    void AddSamples(size_t num_samples, size_t dimensions, const float* data_dim_major );
+
+    /// Delete all samples
+    void ClearLinked()
+    {
+        samples = 0;
+        nextBlock.reset();
+    }
+
+    DataLogBlock* NextBlock() const
+    {
+        return nextBlock.get();
+    }
+
+    size_t StartId() const
+    {
+        return start_id;
+    }
+
+    float* DimData(size_t d) const
+    {
+        return sample_buffer.get() + d;
+    }
+
+    size_t Dimensions() const
+    {
+        return dim;
+    }
+
+    const float* Sample(size_t n) const
+    {
+        const int id = (int)n - (int)start_id;
+
+        if( 0 <= id && id < (int)samples ) {
+            return sample_buffer.get() + dim*id;
+        }else{
+            if(nextBlock) {
+                return nextBlock->Sample(n);
+            }else{
+                throw std::out_of_range("Index out of range.");
+            }
+        }
+    }
+
+protected:
+    size_t dim;
+    size_t max_samples;
+    size_t samples;
+    size_t start_id;
+    std::unique_ptr<float[]> sample_buffer;
+//    std::unique_ptr<DimensionStats[]> stats;
+    std::unique_ptr<DataLogBlock> nextBlock;
+};
+
+/// A DataLog can efficiently record floating point sample data of any size.
+/// Memory is allocated in blocks is transparent to the user.
+class PANGOLIN_EXPORT DataLog
+{
+public:
+    /// @param block_samples_alloc number of samples each memory block can hold.
+    DataLog(unsigned int block_samples_alloc = 10000 );
+
+    ~DataLog();
+
+    /// Provide textual labels corresponding to each dimension logged.
+    /// This information may be used by graphical interfaces to DataLog.
+    void SetLabels(const std::vector<std::string> & labels);
+    const std::vector<std::string>& Labels() const;
+
+    void Log(size_t dimension, const float * vals, unsigned int samples = 1);
+    void Log(float v);
+    void Log(float v1, float v2);
+    void Log(float v1, float v2, float v3);
+    void Log(float v1, float v2, float v3, float v4);
+    void Log(float v1, float v2, float v3, float v4, float v5);
+    void Log(float v1, float v2, float v3, float v4, float v5, float v6);
+    void Log(float v1, float v2, float v3, float v4, float v5, float v6, float v7);
+    void Log(float v1, float v2, float v3, float v4, float v5, float v6, float v7, float v8);
+    void Log(float v1, float v2, float v3, float v4, float v5, float v6, float v7, float v8, float v9);
+    void Log(float v1, float v2, float v3, float v4, float v5, float v6, float v7, float v8, float v9, float v10);
+    void Log(const std::vector<float> & vals);
+
+#ifdef USE_EIGEN
+    template<typename Derived>
+    void Log(const Eigen::MatrixBase<Derived>& M)
+    {
+        Log( M.rows() * M.cols(), M.template cast<float>().eval().data() );
+    }
+#endif
+
+    void Clear();
+    void Save(std::string filename);
+
+    // Return first block of stored data
+    const DataLogBlock* FirstBlock() const;
+
+    // Return last block of stored data
+    const DataLogBlock* LastBlock() const;
+
+    // Return number of samples stored in this DataLog
+    size_t Samples() const;
+
+    // Return pointer to stored sample n
+    const float* Sample(int n) const;
+
+    // Return stats computed for each dimension if enabled.
+    const DimensionStats& Stats(size_t dim) const;
+
+    std::mutex access_mutex;
+
+protected:
+    unsigned int block_samples_alloc;
+    std::vector<std::string> labels;
+    std::unique_ptr<DataLogBlock> block0;
+    DataLogBlock* blockn;
+    std::vector<DimensionStats> stats;
+    bool record_stats;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_plot/include/pangolin/plot/loaders/csv_table_loader.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <fstream>
+#include <memory>
+#include "table_loader.h"
+
+namespace pangolin {
+
+class CsvTableLoader : public TableLoaderInterface
+{
+public:
+    /// Construct to read from the set of files \param csv_files such that
+    /// each row consists of the columns of each file in the provided order
+    ///
+    /// \param csv_files a list of CSV files to read from
+    /// \param delim the field delimiter between columns, normally ',' for CSV
+    CsvTableLoader(const std::vector<std::string>& csv_files, char delim = ',', char comment = '#');
+
+    bool SkipLines(const std::vector<size_t>& lines_per_input);
+
+    bool ReadRow(std::vector<std::string>& row) override;
+
+private:
+    static bool AppendColumns(std::vector<std::string>& cols, std::istream& s, char delim, char comment);
+
+    char delim;
+    char comment;
+    std::vector<std::istream*> streams;
+    std::vector<std::unique_ptr<std::istream>> owned_streams;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_plot/include/pangolin/plot/loaders/table_loader.h

@@ -0,0 +1,12 @@
+#include <pangolin/platform.h>
+#include <vector>
+#include <string>
+
+namespace pangolin {
+
+struct TableLoaderInterface
+{
+    virtual bool ReadRow(std::vector<std::string>& row) = 0;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_plot/include/pangolin/plot/plotter.h

@@ -0,0 +1,295 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef PLOTTER_H
+#define PLOTTER_H
+
+#include <limits>
+
+#include <pangolin/display/view.h>
+#include <pangolin/gl/colour.h>
+#include <pangolin/gl/gl.h>
+#include <pangolin/gl/glfont.h>
+#include <pangolin/gl/glsl.h>
+#include <pangolin/handler/handler.h>
+#include <pangolin/utils/range.h>
+#include <pangolin/plot/datalog.h>
+
+#include <set>
+
+namespace pangolin
+{
+
+enum DrawingMode
+{
+    DrawingModePoints = GL_POINTS,
+    DrawingModeDashed = GL_LINES,
+    DrawingModeLine = GL_LINE_STRIP,
+    DrawingModeNone,
+};
+
+struct Marker
+{
+    enum Direction
+    {
+        Horizontal,
+        Vertical
+    };
+
+    enum Equality
+    {
+        LessThan = -1,
+        Equal = 0,
+        GreaterThan = 1
+    };
+
+    Marker(Direction d, float value, Equality leg = Equal, Colour c = Colour() )
+        : colour(c)
+    {
+        if(d == Horizontal) {
+            range.x = Rangef::Open();
+            range.y = Rangef::Containing(value);
+            if(leg == LessThan) {
+                range.y.Insert(std::numeric_limits<float>::lowest() );
+            }else if(leg == GreaterThan) {
+                range.y.Insert(std::numeric_limits<float>::max() );
+            }
+        }else if(d == Vertical) {
+            range.x = Rangef::Containing(value);
+            range.y = Rangef::Open();
+            if(leg == LessThan) {
+                range.x.Insert(std::numeric_limits<float>::lowest() );
+            }else if(leg == GreaterThan) {
+                range.x.Insert(std::numeric_limits<float>::max() );
+            }
+        }
+    }
+
+    Marker(const XYRangef& range, const Colour& c = Colour() )
+        : range(range), colour(c)
+    {
+    }
+
+    XYRangef range;
+    Colour colour;
+};
+
+class PANGOLIN_EXPORT Plotter : public View, Handler
+{
+public:
+    Plotter(
+        DataLog* default_log,
+        float left=0, float right=600, float bottom=-1, float top=1,
+        float tickx=30, float ticky=0.5,
+        Plotter* linked_plotter_x = 0,
+        Plotter* linked_plotter_y = 0
+    );
+
+    virtual ~Plotter();
+
+    void Render();
+
+    XYRangef& GetSelection();
+
+    XYRangef& GetDefaultView();
+    void SetDefaultView(const XYRangef& range);
+
+    XYRangef& GetView();
+    void SetView(const XYRangef& range);
+    void SetViewSmooth(const XYRangef& range);
+
+    void ScrollView(float x, float y);
+    void ScrollViewSmooth(float x, float y);
+
+    void ScaleView(float x, float y, float cx, float cy);
+    void ScaleViewSmooth(float x, float y, float cx, float cy);
+
+    void ResetView();
+
+    void SetTicks(float tickx, float ticky);
+
+    void Track(const std::string& x="$i", const std::string& y = "");
+    void ToggleTracking();
+
+    void Trigger(const std::string& x="$0", int edge = -1, float value = 0.0f);
+    void ToggleTrigger();
+
+    void SetBackgroundColour(const Colour& col);
+    void SetAxisColour(const Colour& col);
+    void SetTickColour(const Colour& col);
+
+    void ScreenToPlot(int xpix, int ypix, float &xplot, float &yplot);
+    void Keyboard(View&, unsigned char key, int x, int y, bool pressed);
+    void Mouse(View&, MouseButton button, int x, int y, bool pressed, int mouse_state);
+    void MouseMotion(View&, int x, int y, int mouse_state);
+    void PassiveMouseMotion(View&, int x, int y, int button_state);
+    void Special(View&, InputSpecial inType, float x, float y, float p1, float p2, float p3, float p4, int button_state);
+
+    /// Remove all current series plots
+    void ClearSeries();
+
+    /// Add series X,Y plot from glsl compatible expressions x_expr, y_expr
+    /// $i refers to integral index of datum in log.
+    /// $0, $1, $2, ... refers to nth series in log.
+    ///    e.g. x_expr = "$i", y_expr = "$0"       // index - data[0] plot
+    ///    e.g. x_expr = "$0", y_expr = "$1"       // data[0], data[1] X-Y plot
+    ///    e.g. x_exptr ="$i", y_expr = "sqrt($1)} // index - sqrt(data[0]) plot
+    void AddSeries(const std::string& x_expr, const std::string& y_expr,
+        DrawingMode drawing_mode = DrawingModeLine, Colour colour = Colour::Unspecified(),
+        const std::string &title = "$y", DataLog* log = nullptr
+    );
+
+    std::string PlotTitleFromExpr(const std::string& expr) const;
+
+    /// Remove all current markers
+    void ClearMarkers();
+
+    /// Add horizontal or vertical inequality marker; equal-to, less-than, or greater than.
+    /// This is useful for annotating a critical point or valid region.
+    Marker& AddMarker(
+        Marker::Direction d, float value,
+        Marker::Equality leg = Marker::Equal, Colour c = Colour()
+    );
+
+    Marker& AddMarker( const Marker& marker );
+
+    void ClearImplicitPlots();
+    void AddImplicitPlot();
+
+    /// Reset colour wheel to initial state. May be useful together with ClearSeries() / ClearMarkers()
+    void ResetColourWheel();
+
+    void ShowHoverLines(bool show)
+    {
+        showHoverLines = show;
+    }
+
+    void ShowTicks(bool show)
+    {
+        showTicks = show;
+    }
+
+protected:
+    struct PANGOLIN_EXPORT Tick
+    {
+        float val;
+        float factor;
+        std::string symbol;
+    };
+
+    struct PANGOLIN_EXPORT PlotAttrib
+    {
+        PlotAttrib(std::string name, int plot_id, int location = -1)
+            : name(name), plot_id(plot_id), location(location) { }
+
+        std::string name;
+        int plot_id;
+        int location;
+    };
+
+    struct PANGOLIN_EXPORT PlotSeries
+    {
+        PlotSeries();
+        void CreatePlot(const std::string& x, const std::string& y, Colour c, std::string title);
+
+        GlSlProgram prog;
+        GlText title;
+        bool contains_id;
+        std::vector<PlotAttrib> attribs;
+        DataLog* log;
+        GLenum drawing_mode;
+        Colour colour;
+        bool used;
+    };
+
+    struct PANGOLIN_EXPORT PlotImplicit
+    {
+        // Assign to gl_FragColor
+        void CreatePlot(const std::string& code);
+
+        // Expression uses x,y and assignes colours [0,1] to r,g,b,a
+        void CreateColouredPlot(const std::string& code);
+
+        // Expression uses x,y and evaluates to true/false;
+        void CreateInequality(const std::string& ie, Colour c);
+
+        // Expression uses x,y and evaluates to a number
+        void CreateDistancePlot(const std::string& dist);
+
+        GlSlProgram prog;
+    };
+
+    void FixSelection();
+    void UpdateView();
+    Tick FindTickFactor(float tick);
+
+    DataLog* default_log;
+
+    ColourWheel colour_wheel;
+    Colour colour_bg;
+    Colour colour_tk;
+    Colour colour_ax;
+
+    GlSlProgram prog_lines;
+    GlSlProgram prog_text;
+
+    std::vector<PlotSeries> plotseries;
+    std::vector<Marker> plotmarkers;
+    std::vector<PlotImplicit> plotimplicits;
+
+    Tick tick[2];
+    XYRangef rview_default;
+    XYRangef rview;
+    XYRangef target;
+    XYRangef selection;
+
+    void ComputeTrackValue( float track_val[2] );
+    XYRangef ComputeAutoSelection();
+
+    bool track;
+    std::string track_x;
+    std::string track_y;
+    float last_track_val[2];
+
+    // -1: falling, -0:disable, 1: rising
+    int trigger_edge;
+    float trigger_value;
+    std::string trigger;
+
+    float hover[2];
+    int last_mouse_pos[2];
+
+    Plotter* linked_plotter_x;
+    Plotter* linked_plotter_y;
+
+    bool showTicks;
+    bool showHoverLines;
+};
+
+} // namespace pangolin
+
+#endif // PLOTTER_H

third-party/DPVO/Pangolin/components/pango_plot/src/datalog.cpp

@@ -0,0 +1,289 @@
+/* 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/plot/datalog.h>
+
+#include <algorithm>
+#include <fstream>
+#include <limits>
+
+namespace pangolin
+{
+
+void DataLogBlock::AddSamples(size_t num_samples, size_t dimensions, const float* data_dim_major )
+{
+    if(nextBlock) {
+        // If next block exists, add to it instead
+        nextBlock->AddSamples(num_samples, dimensions, data_dim_major);
+    }else{
+        if(dimensions > dim) {
+            // If dimensions is too high for this block, start a new bigger one
+            nextBlock = std::unique_ptr<DataLogBlock>(new DataLogBlock(dimensions, max_samples, start_id + samples));
+            nextBlock->AddSamples(num_samples,dimensions,data_dim_major);
+        }else{
+            // Try to copy samples to this block
+            const size_t samples_to_copy = std::min(num_samples, SampleSpaceLeft());
+
+            if(dimensions == dim) {
+                // Copy entire block all together
+                std::copy(data_dim_major, data_dim_major + samples_to_copy*dim, sample_buffer.get()+samples*dim);
+                samples += samples_to_copy;
+                data_dim_major += samples_to_copy*dim;
+            }else{
+                // Copy sample at a time, filling with NaN's where needed.
+                float* dst = sample_buffer.get();
+                for(size_t i=0; i< samples_to_copy; ++i) {
+                    std::copy(data_dim_major, data_dim_major + dimensions, dst);
+                    for(size_t ii = dimensions; ii < dim; ++ii) {
+                        dst[ii] = std::numeric_limits<float>::quiet_NaN();
+                    }
+                    dst += dimensions;
+                    data_dim_major += dimensions;
+                }
+                samples += samples_to_copy;
+            }
+
+//            // Update Stats
+//            for(size_t s=0; s < samples_to_copy; ++s) {
+//                for(size_t d = 0; d < dimensions; ++d) {
+//                    stats[d].Add(data_dim_major[s*dim + d]);
+//                }
+//            }
+
+            // Copy remaining data to next block (this one is full)
+            if(samples_to_copy < num_samples) {
+                nextBlock = std::unique_ptr<DataLogBlock>(new DataLogBlock(dim, max_samples, start_id + Samples()));
+                nextBlock->AddSamples(num_samples-samples_to_copy, dimensions, data_dim_major);
+            }
+        }
+    }
+}
+
+DataLog::DataLog(unsigned int buffer_size)
+    : block_samples_alloc(buffer_size), block0(nullptr), blockn(nullptr), record_stats(true)
+{
+}
+
+DataLog::~DataLog()
+{
+    Clear();
+}
+
+void DataLog::SetLabels(const std::vector<std::string> & new_labels)
+{
+    std::lock_guard<std::mutex> l(access_mutex);
+
+    // Create new labels if needed
+    for( size_t i= labels.size(); i < new_labels.size(); ++i )
+        labels.push_back( std::string() );
+
+    // Add data to existing plots
+    for( unsigned int i=0; i<labels.size(); ++i )
+        labels[i] = new_labels[i];
+}
+
+const std::vector<std::string>& DataLog::Labels() const
+{
+    return labels;
+}
+
+void DataLog::Log(size_t dimension, const float* vals, unsigned int samples )
+{
+    if(!block0) {
+        // Create first block
+        block0 = std::unique_ptr<DataLogBlock>(new DataLogBlock(dimension, block_samples_alloc, 0));
+        blockn = block0.get();
+    }
+
+    if(record_stats) {
+        while(stats.size() < dimension) {
+            stats.push_back( DimensionStats() );
+        }
+        for(unsigned int d=0; d<dimension; ++d) {
+            DimensionStats& ds = stats[d];
+            for(unsigned int s=0; s<samples; ++s) {
+                ds.Add(vals[s*dimension+d]);
+            }
+        }
+    }
+
+    blockn->AddSamples(samples,dimension,vals);
+
+    // Update pointer to most recent block.
+    while(blockn->NextBlock()) {
+        blockn = blockn->NextBlock();
+    }
+}
+
+void DataLog::Log(float v)
+{
+    const float vs[] = {v};
+    Log(1,vs);
+}
+
+void DataLog::Log(float v1, float v2)
+{
+    const float vs[] = {v1,v2};
+    Log(2,vs);
+}
+
+void DataLog::Log(float v1, float v2, float v3)
+{
+    const float vs[] = {v1,v2,v3};
+    Log(3,vs);
+}
+void DataLog::Log(float v1, float v2, float v3, float v4)
+{
+    const float vs[] = {v1,v2,v3,v4};
+    Log(4,vs);
+}
+void DataLog::Log(float v1, float v2, float v3, float v4, float v5)
+{
+    const float vs[] = {v1,v2,v3,v4,v5};
+    Log(5,vs);
+}
+void DataLog::Log(float v1, float v2, float v3, float v4, float v5, float v6)
+{
+    const float vs[] = {v1,v2,v3,v4,v5,v6};
+    Log(6,vs);
+}
+
+void DataLog::Log(float v1, float v2, float v3, float v4, float v5, float v6, float v7)
+{
+    const float vs[] = {v1,v2,v3,v4,v5,v6,v7};
+    Log(7,vs);
+}
+
+void DataLog::Log(float v1, float v2, float v3, float v4, float v5, float v6, float v7, float v8)
+{
+    const float vs[] = {v1,v2,v3,v4,v5,v6,v7,v8};
+    Log(8,vs);
+}
+
+void DataLog::Log(float v1, float v2, float v3, float v4, float v5, float v6, float v7, float v8, float v9)
+{
+    const float vs[] = {v1,v2,v3,v4,v5,v6,v7,v8,v9};
+    Log(9,vs);
+}
+
+void DataLog::Log(float v1, float v2, float v3, float v4, float v5, float v6, float v7, float v8, float v9, float v10)
+{
+    const float vs[] = {v1,v2,v3,v4,v5,v6,v7,v8,v9,v10};
+    Log(10,vs);
+}
+
+void DataLog::Log(const std::vector<float> & vals)
+{
+    Log(vals.size(), &vals[0]);
+}
+
+void DataLog::Clear()
+{
+    std::lock_guard<std::mutex> l(access_mutex);
+
+    blockn = nullptr;
+    block0 = nullptr;
+
+    stats.clear();
+}
+
+void DataLog::Save(std::string filename)
+{
+    std::ofstream csvStream(filename);
+
+    if (!Labels().empty()) {
+      csvStream << Labels()[0];
+
+      for (size_t i = 1; i < Labels().size(); ++i) {
+        csvStream << "," << Labels()[i];
+      }
+
+      csvStream << std::endl;
+
+  }
+
+  const DataLogBlock * block = FirstBlock();
+
+  size_t i = 0;
+
+  while (block) {
+
+    const size_t blockEnd = i + block->Samples();
+
+    for (; i < blockEnd; ++i) {
+
+      csvStream << block->Sample(i)[0];
+
+      for (size_t d = 1; d < block->Dimensions(); ++d) {
+
+        csvStream << "," << block->Sample(i)[d];
+
+      }
+
+      csvStream << std::endl;
+
+    }
+
+    block = block->NextBlock();
+
+  }
+
+}
+
+const DataLogBlock* DataLog::FirstBlock() const
+{
+    return block0.get();
+}
+
+const DataLogBlock* DataLog::LastBlock() const
+{
+    return blockn;
+}
+
+const DimensionStats& DataLog::Stats(size_t dim) const
+{
+    return stats[dim];
+}
+
+size_t DataLog::Samples() const
+{
+    if(blockn) {
+        return blockn->StartId() + blockn->Samples();
+    }
+    return 0;
+}
+
+const float* DataLog::Sample(int n) const
+{
+    if(block0) {
+        return block0->Sample(n);
+    }else{
+        return 0;
+    }
+}
+
+}

third-party/DPVO/Pangolin/components/pango_plot/src/loaders/csv_table_loader.cpp

@@ -0,0 +1,81 @@
+#include <pangolin/plot/loaders/csv_table_loader.h>
+#include <fstream>
+#include <memory>
+
+namespace pangolin {
+
+CsvTableLoader::CsvTableLoader(const std::vector<std::string>& csv_files, char delim, char comment)
+    : delim(delim), comment(comment)
+{
+    for(const auto& f : csv_files) {
+        if(f == "-") {
+            streams.push_back(&std::cin);
+        }else{
+            std::ifstream* pFile = new std::ifstream(f);
+            owned_streams.emplace_back(pFile);
+            streams.push_back(pFile);
+            PANGO_ASSERT(pFile->is_open());
+        }
+    }
+}
+
+bool CsvTableLoader::SkipLines(const std::vector<size_t>& lines_per_input)
+{
+    if(lines_per_input.size()) {
+        PANGO_ASSERT(lines_per_input.size() == streams.size());
+        std::vector<std::string> dummy_row;
+
+        for(size_t i=0; i < streams.size(); ++i) {
+            for(size_t r=0; r < lines_per_input[i]; ++r) {
+                if(!AppendColumns(dummy_row, *streams[i], delim, '\0')) {
+                    return false;
+                }
+            }
+        }
+    }
+
+    return true;
+}
+
+bool CsvTableLoader::ReadRow(std::vector<std::string>& row)
+{
+    row.clear();
+
+    for(auto& s : streams) {
+        if(!AppendColumns(row, *s, delim, comment)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool CsvTableLoader::AppendColumns(std::vector<std::string>& cols, std::istream& s, char delim, char comment)
+{
+    // Read line from stream
+    std::string row;
+    do {
+        std::getline(s,row);
+    }while(row.length() > 0 && row[0] == comment);
+
+
+    // Failure if no lines to read
+    if(!s.good()) return false;
+
+    std::stringstream row_stream(row);
+    std::string cell;
+
+    // Read cells
+    while(std::getline(row_stream, cell, delim)) {
+        cols.push_back(cell);
+    }
+
+    // Check for an empty trailing cell
+    if (!row_stream && cell.empty()) {
+        cols.push_back("");
+    }
+
+    return true;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_plot/src/plotter.cpp

@@ -0,0 +1,1174 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/gl/gldraw.h>
+#include <pangolin/plot/plotter.h>
+#include <pangolin/display/default_font.h>
+
+#include <cctype>
+#include <iomanip>
+
+namespace pangolin
+{
+
+std::string ReplaceChar(const std::string& str, char from, char to)
+{
+    std::string ret = str;
+    for(size_t i=0; i<ret.length(); ++i) {
+        if(ret[i] == from) ret[i] = to;
+    }
+    return ret;
+}
+
+std::set<int> ConvertSequences(const std::string& str, char seq_char='$', char id_char='i')
+{
+    std::set<int> sequences;
+
+    for(size_t i=0; i<str.length(); ++i) {
+        if(str[i] == seq_char) {
+            if(i+1 < str.length() && str[i+1] == id_char) {
+                sequences.insert(-1);
+            }else{
+                int v = 0;
+                for(size_t j=i+1; std::isdigit(str[j]) && j< str.length(); ++j) {
+                    v = v*10 + (str[j] - '0');
+                }
+                sequences.insert(v);
+            }
+        }
+    }
+
+    return sequences;
+}
+
+Plotter::PlotSeries::PlotSeries()
+    : log(nullptr), drawing_mode(GL_LINE_STRIP)
+{
+
+}
+
+// X-Y Plot given C-Code style (GLSL) expressions x and y.
+void Plotter::PlotSeries::CreatePlot(const std::string &x, const std::string &y, Colour colour, std::string title)
+{
+    static const std::string vs_header =
+            "uniform float u_id_offset;\n"
+            "uniform vec4 u_color;\n"
+            "uniform vec2 u_scale;\n"
+            "uniform vec2 u_offset;\n"
+            "varying vec4 v_color;\n"
+            "void main() {\n";
+
+    static const std::string vs_footer =
+            "    vec2 pos = vec2(x, y);\n"
+            "    gl_Position = vec4(u_scale * (pos + u_offset),0.0,1.0);\n"
+            "    v_color = u_color;\n"
+            "}\n";
+
+    static const std::string fs =
+        #ifdef HAVE_GLES_2
+            "precision mediump float;\n"
+        #endif // HAVE_GLES_2
+            "varying vec4 v_color;\n"
+            "void main() {\n"
+            "  gl_FragColor = v_color;\n"
+            "}\n";
+
+    attribs.clear();
+
+    this->colour = colour;
+    this->title  = default_font().Text(title.c_str());
+    const std::set<int> ax = ConvertSequences(x);
+    const std::set<int> ay = ConvertSequences(y);
+    std::set<int> as;
+    as.insert(ax.begin(), ax.end());
+    as.insert(ay.begin(), ay.end());
+    contains_id = ( as.find(-1) != as.end() );
+
+    std::ostringstream oss_prog;
+
+    for(std::set<int>::const_iterator i=as.begin(); i != as.end(); ++i) {
+        std::ostringstream oss;
+        oss << "s" << *i;
+        const std::string name = *i >= 0 ? oss.str() : "sn";
+        attribs.push_back( PlotAttrib(name, *i) );
+        oss_prog << "attribute float " + name + ";\n";
+    }
+
+    oss_prog << vs_header;
+    if(contains_id) {
+        oss_prog << "float si = sn + u_id_offset;\n";
+    }
+    oss_prog << "float x = " + ReplaceChar(x,'$','s') + ";\n";
+    oss_prog << "float y = " + ReplaceChar(y,'$','s') + ";\n";
+    oss_prog << vs_footer;
+
+    prog.AddShader( GlSlVertexShader, oss_prog.str() );
+    prog.AddShader( GlSlFragmentShader, fs );
+    prog.Link();
+
+    // Lookup attribute locations in compiled shader
+    prog.SaveBind();
+    for(size_t i=0; i<attribs.size(); ++i) {
+        attribs[i].location = prog.GetAttributeHandle( attribs[i].name );
+    }
+    prog.Unbind();
+}
+
+void Plotter::PlotImplicit::CreatePlot(const std::string& code)
+{
+    static const std::string vs =
+            "attribute vec2 a_position;\n"
+            "uniform vec2 u_scale;\n"
+            "uniform vec2 u_offset;\n"
+            "varying float x;\n"
+            "varying float y;\n"
+            "void main() {\n"
+            "    gl_Position = vec4(u_scale * (a_position + u_offset),0,1);\n"
+            "    x = a_position.x;"
+            "    y = a_position.y;"
+            "}\n";
+
+    static const std::string fs1 =
+        #ifdef HAVE_GLES_2
+            "precision mediump float;\n"
+        #endif // HAVE_GLES_2
+            "varying float x;\n"
+            "varying float y;\n"
+            "void main() {\n";
+    static const std::string fs2 =
+            "   gl_FragColor = z;\n"
+            "}\n";
+
+    prog.AddShader( GlSlVertexShader, vs );
+    prog.AddShader( GlSlFragmentShader, fs1 + code + fs2 );
+    prog.BindPangolinDefaultAttribLocationsAndLink();
+}
+
+
+void Plotter::PlotImplicit::CreateColouredPlot(const std::string& code)
+{
+    CreatePlot(
+        "  float r=1.0;\n"
+        "  float g=1.0;\n"
+        "  float b=1.0;\n"
+        "  float a=0.5;\n" +
+           code +
+        "  z = vec4(r,g,b,a);\n"
+        );
+}
+
+void Plotter::PlotImplicit::CreateInequality(const std::string& ie, Colour c)
+{
+    std::ostringstream oss;
+    oss << std::fixed << std::setprecision(1);
+    oss << "if( !(" << ie << ") ) discard;\n";
+    oss << "z = vec4(" << c.r << "," << c.g << "," << c.b << "," << c.a << ");\n";
+
+    CreatePlot( oss.str() );
+}
+
+void Plotter::PlotImplicit::CreateDistancePlot(const std::string& /*dist*/)
+{
+
+}
+
+Plotter::Plotter(
+    DataLog* log,
+    float left, float right, float bottom, float top,
+    float tickx, float ticky,
+    Plotter* linked_plotter_x,
+    Plotter* linked_plotter_y
+)   : default_log(log),
+      colour_wheel(0.6f),
+      rview_default(left,right,bottom,top), rview(rview_default), target(rview),
+      selection(0,0,0,0),
+      track(false), track_x("$i"), track_y(""),
+      trigger_edge(0), trigger("$0"),
+      linked_plotter_x(linked_plotter_x),
+      linked_plotter_y(linked_plotter_y)
+{
+    // Prevent links to ourselves - this could cause infinite recursion.
+    if(linked_plotter_x == this) this->linked_plotter_x = 0;
+    if(linked_plotter_y == this) this->linked_plotter_y = 0;
+
+    // Handle our own mouse / keyboard events
+    this->handler = this;
+    hover[0] = 0;
+    hover[1] = 0;
+
+    // Default colour scheme
+    colour_bg = Colour(0.0f, 0.0f, 0.0f);
+    colour_tk = Colour(0.2f, 0.2f, 0.2f);
+    colour_ax = Colour(0.5f, 0.5f, 0.5f);
+
+    SetTicks(tickx, ticky);
+
+    // Create shader for drawing simple primitives
+    prog_lines.AddShader( GlSlVertexShader,
+                         "attribute vec2 a_position;\n"
+                         "uniform vec4 u_color;\n"
+                         "uniform vec2 u_scale;\n"
+                         "uniform vec2 u_offset;\n"
+                         "varying vec4 v_color;\n"
+                         "void main() {\n"
+                         "    gl_Position = vec4(u_scale * (a_position + u_offset),0,1);\n"
+                         "    v_color = u_color;\n"
+                         "}\n"
+                         );
+    prog_lines.AddShader( GlSlFragmentShader,
+                      #ifdef HAVE_GLES_2
+                          "precision mediump float;\n"
+                      #endif // HAVE_GLES_2
+                         "varying vec4 v_color;\n"
+                         "void main() {\n"
+                         "  gl_FragColor = v_color;\n"
+                         "}\n"
+                         );
+    prog_lines.BindPangolinDefaultAttribLocationsAndLink();
+
+    prog_text.AddShader( GlSlVertexShader,
+                         "attribute vec2 a_position;\n"
+                         "attribute vec2 a_texcoord;\n"
+                         "uniform vec4 u_color;\n"
+                         "uniform vec2 u_scale;\n"
+                         "uniform vec2 u_offset;\n"
+                         "varying vec4 v_color;\n"
+                         "varying vec2 v_texcoord;\n"
+                         "void main() {\n"
+                         "    gl_Position = vec4(u_scale * (a_position + u_offset),0,1);\n"
+                         "    v_color = u_color;\n"
+                         "    v_texcoord = a_texcoord;\n"
+                         "}\n"
+                         );
+    prog_text.AddShader( GlSlFragmentShader,
+                     #ifdef HAVE_GLES_2
+                         "precision mediump float;\n"
+                     #endif // HAVE_GLES_2
+                         "varying vec4 v_color;\n"
+                         "varying vec2 v_texcoord;\n"
+                         "uniform sampler2D u_texture;\n"
+                         "void main() {\n"
+                         "  gl_FragColor = v_color;\n"
+                         "  gl_FragColor.a *= texture2D(u_texture, v_texcoord).a;\n"
+                         "}\n"
+                         );
+    prog_text.BindPangolinDefaultAttribLocationsAndLink();
+
+    const size_t RESERVED_SIZE = 100;
+
+    // Setup default PlotSeries
+    plotseries.reserve(RESERVED_SIZE);
+    for(unsigned int i=0; i< 10; ++i) {
+        std::ostringstream ss;
+        ss << "$" << i;
+        if(log) AddSeries("$i", ss.str());
+    }
+
+    // Setup test PlotMarkers
+    plotmarkers.reserve(RESERVED_SIZE);
+//    plotmarkers.push_back( Marker( Marker::Vertical, 10, Marker::GreaterThan, Colour(1,0,0,0.2)) );
+//    plotmarkers.push_back( Marker( Marker::Horizontal, 1, Marker::LessThan, Colour(0,1,0,0.2)) );
+
+    // Setup test implicit plots.
+    plotimplicits.reserve(RESERVED_SIZE);
+//    plotimplicits.push_back( PlotImplicit() );
+//    plotimplicits.back().CreateInequality("x+y <= 150.0", colour_wheel.GetUniqueColour().WithAlpha(0.2) );
+//    plotimplicits.push_back( PlotImplicit() );
+//    plotimplicits.back().CreateInequality("x+2.0*y <= 170.0", colour_wheel.GetUniqueColour().WithAlpha(0.2) );
+//    plotimplicits.push_back( PlotImplicit() );
+//    plotimplicits.back().CreateInequality("3.0*y <= 180.0", colour_wheel.GetUniqueColour().WithAlpha(0.2) );
+
+    // Setup texture spectogram style plots
+    // ...
+
+    showTicks = true;
+    showHoverLines = true;
+}
+
+Plotter::~Plotter()
+{
+
+}
+
+template <typename T> int data_sgn(T val) {
+    return (T(0) < val) - (val < T(0));
+}
+
+void Plotter::ComputeTrackValue( float track_val[2] )
+{
+    if(trigger_edge) {
+        // Track last edge transition matching trigger_edge
+        const DataLogBlock* block = default_log->LastBlock();
+        if(block) {
+            int s = (int)block->StartId() + (int)block->Samples() - 1;
+            const size_t dim = block->Dimensions();
+            const float* data = block->Sample(s);
+            int last_sgn = 0;
+            for(; s >= 0; --s, data -= dim )
+            {
+                const float val = data[0] - trigger_value;
+                const int sgn = data_sgn(val);
+                if(last_sgn * sgn == -1 && last_sgn == trigger_edge) {
+                    track_val[0] = (float)s;
+                    track_val[1] = 0.0f;
+                    return;
+                }
+                last_sgn = sgn;
+            }
+        }
+        // Fall back to simple last value tracking
+    }
+
+    track_val[0] = (float)default_log->Samples();
+    track_val[1] = 0.0f;
+}
+
+XYRangef Plotter::ComputeAutoSelection()
+{
+    XYRangef range;
+    range.x = target.x;
+
+    const DataLogBlock* block = default_log->FirstBlock();
+
+    if(block) {
+        for(size_t i=0; i < plotseries.size(); ++i)
+        {
+            if( plotseries[i].attribs.size() == 2 && plotseries[i].attribs[0].plot_id == -1) {
+                const int id = plotseries[i].attribs[1].plot_id;
+                if( 0<= id && id < (int)block->Dimensions()) {
+                    range.y.Insert(default_log->Stats(id).min);
+                    range.y.Insert(default_log->Stats(id).max);
+                }
+            }
+
+        }
+    }
+
+    return range;
+}
+
+void Plotter::Render()
+{
+    // Animate scroll / zooming
+    UpdateView();
+
+#ifndef HAVE_GLES
+    glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT | GL_LINE_BIT);
+#endif
+
+    glClearColor(colour_bg.r, colour_bg.g, colour_bg.b, colour_bg.a);
+    ActivateAndScissor();
+
+    if(std::isfinite(colour_bg.a)) {
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    }
+
+    if(extern_draw_function && show) {
+        glMatrixMode(GL_PROJECTION);
+        ProjectionMatrixOrthographic(rview.x.min, rview.x.max, rview.y.max, rview.y.min, -1.0f, 1.0f).Load();
+        glMatrixMode(GL_MODELVIEW);
+        glLoadIdentity();
+
+        extern_draw_function(*this);
+    }
+
+    // Try to create smooth lines
+    glDisable(GL_MULTISAMPLE);
+    glLineWidth(1.5);
+    glEnable(GL_LINE_SMOOTH);
+    glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
+    glEnable (GL_BLEND);
+    glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glDisable(GL_LIGHTING);
+    glDisable( GL_DEPTH_TEST );
+
+    const float w = rview.x.AbsSize();
+    const float h = rview.y.AbsSize();
+    const float ox = -rview.x.Mid();
+    const float oy = -rview.y.Mid();
+    const float sx = 2.0f / w;
+    const float sy = 2.0f / h;
+
+    //////////////////////////////////////////////////////////////////////////
+    // Draw ticks
+    prog_lines.SaveBind();
+    prog_lines.SetUniform("u_scale",  sx, sy);
+    prog_lines.SetUniform("u_offset", ox, oy);
+    prog_lines.SetUniform("u_color",  colour_tk );
+
+    const float min_space = 80.0;
+    float ta[2] = {1,1};
+
+    while(true)
+    {
+        const float interval = v.w * tick[0].val / w;
+
+        if(ta[0] * interval < min_space)
+            ta[0] *=2;
+        if(ta[0] * interval < min_space)
+            ta[0] =(5*ta[0])/2;
+        if(ta[0] * interval < min_space)
+            ta[0] *=2;
+        else
+            break;
+    }
+    while(true)
+    {
+        const float interval = v.h * tick[1].val / h;
+
+        if(ta[1] * interval < min_space)
+            ta[1] *=2;
+        if(ta[1] * interval < min_space)
+            ta[1] =(5*ta[1])/2;
+        if(ta[1] * interval < min_space)
+            ta[1] *=2;
+        else
+            break;
+    }
+
+    const float tdelta[2] = {
+        tick[0].val * ta[0],
+        tick[1].val * ta[1]
+    };
+
+    const int tx[2] = {
+        (int)ceil(rview.x.min / tdelta[0]),
+        (int)ceil(rview.x.max / tdelta[0])
+    };
+
+    const int ty[2] = {
+        (int)ceil(rview.y.min / tdelta[1]),
+        (int)ceil(rview.y.max / tdelta[1])
+    };
+    if(showTicks)
+    {
+        for( int i=tx[0]; i<tx[1]; ++i ) {
+            glDrawLine((i)*tdelta[0], rview.y.min,   (i)*tdelta[0], rview.y.max);
+        }
+
+        for( int i=ty[0]; i<ty[1]; ++i ) {
+            glDrawLine(rview.x.min, (i)*tdelta[1],  rview.x.max, (i)*tdelta[1]);
+        }
+    }
+    prog_lines.Unbind();
+
+    //////////////////////////////////////////////////////////////////////////
+    // Draw axis
+
+    prog_lines.SaveBind();
+    prog_lines.SetUniform("u_color",  colour_ax );
+    glDrawLine(0, rview.y.min,  0, rview.y.max );
+    glDrawLine(rview.x.min,0,   rview.x.max,0  );
+    prog_lines.Unbind();
+
+    //////////////////////////////////////////////////////////////////////////
+    // Draw Implicits
+
+    for(size_t i=0; i < plotimplicits.size(); ++i) {
+        PlotImplicit& im = plotimplicits[i];
+        im.prog.SaveBind();
+
+        im.prog.SetUniform("u_scale",  sx, sy);
+        im.prog.SetUniform("u_offset", ox, oy);
+
+        glDrawRect(rview.x.min,rview.y.min,rview.x.max,rview.y.max);
+
+        im.prog.Unbind();
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // Draw series
+
+    static size_t id_size = 0;
+    static float* id_array = 0;
+
+    for(size_t i=0; i < plotseries.size(); ++i)
+    {
+        PlotSeries& ps = plotseries[i];
+
+        if(ps.drawing_mode != pangolin::DrawingModeNone)
+        {
+            GlSlProgram& prog = ps.prog;
+            ps.used = false;
+
+            prog.SaveBind();
+            prog.SetUniform("u_scale",  sx, sy);
+            prog.SetUniform("u_offset", ox, oy);
+            prog.SetUniform("u_color", ps.colour );
+
+            // TODO: Try to skip drawing of blocks which aren't in view.
+            DataLog* log = ps.log ? ps.log : default_log;
+            std::lock_guard<std::mutex> l(log->access_mutex);
+
+            const DataLogBlock* block = log->FirstBlock();
+            while(block) {
+                if(ps.contains_id ) {
+                    if(id_size < block->Samples() ) {
+                        // Create index array that we can bind
+                        delete[] id_array;
+                        id_size = block->MaxSamples();
+                        id_array = new float[id_size];
+                        for(size_t k=0; k < id_size; ++k) {
+                            id_array[k] = (float)k;
+                        }
+                    }
+                    prog.SetUniform("u_id_offset",  (float)block->StartId() );
+                }
+
+                // Enable appropriate attributes
+                bool shouldRender = true;
+                for(size_t i=0; i< ps.attribs.size(); ++i) {
+                    if(0 <= ps.attribs[i].plot_id && ps.attribs[i].plot_id < (int)block->Dimensions() ) {
+                        glVertexAttribPointer(ps.attribs[i].location, 1, GL_FLOAT, GL_FALSE, (GLsizei)(block->Dimensions()*sizeof(float)), block->DimData(ps.attribs[i].plot_id) );
+                        glEnableVertexAttribArray(ps.attribs[i].location);
+                    }else if( ps.attribs[i].plot_id == -1 ){
+                        glVertexAttribPointer(ps.attribs[i].location, 1, GL_FLOAT, GL_FALSE, 0, id_array );
+                        glEnableVertexAttribArray(ps.attribs[i].location);
+                    }else{
+                        // bad id: don't render
+                        shouldRender = false;
+                        break;
+                    }
+                }
+
+                if(shouldRender) {
+                    // Draw geometry
+                    glDrawArrays(ps.drawing_mode, 0, (GLsizei)block->Samples());
+                    ps.used = true;
+                }
+
+                // Disable enabled attributes
+                for(size_t i=0; i< ps.attribs.size(); ++i) {
+                    glDisableVertexAttribArray(ps.attribs[i].location);
+                }
+
+                block = block->NextBlock();
+            }
+            prog.Unbind();
+        }
+    }
+
+    prog_lines.SaveBind();
+
+    //////////////////////////////////////////////////////////////////////////
+    // Draw markers
+    glLineWidth(2.5f);
+
+    for( size_t i=0; i < plotmarkers.size(); ++i) {
+        const Marker& m = plotmarkers[i];
+
+        XYRangef draw_range = m.range;
+        draw_range.Clamp(rview);
+
+        prog_lines.SetUniform("u_color",  m.colour );
+        if(draw_range.x.Size() == 0.0  || draw_range.y.Size() == 0.0) {
+            // Horizontal or Vertical line
+            glDrawLine(draw_range.x.min, draw_range.y.min,  draw_range.x.max, draw_range.y.max );
+        }else{
+            // Region
+            glDrawRect(draw_range.x.min, draw_range.y.min,  draw_range.x.max, draw_range.y.max );
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // Draw hover / selection
+    glLineWidth(1.5f);
+
+    if(showHoverLines)
+    {
+        // hover over
+        prog_lines.SetUniform("u_color",  colour_ax.WithAlpha(0.3f) );
+        glDrawLine(hover[0], rview.y.min,  hover[0], rview.y.max );
+        glDrawLine(rview.x.min, hover[1],  rview.x.max, hover[1] );
+
+        // range
+        prog_lines.SetUniform("u_color",  colour_ax.WithAlpha(0.5) );
+        glDrawLine(selection.x.min, rview.y.min,  selection.x.min, rview.y.max );
+        glDrawLine(selection.x.max, rview.y.min,  selection.x.max, rview.y.max );
+        glDrawLine(rview.x.min, selection.y.min,  rview.x.max, selection.y.min );
+        glDrawLine(rview.x.min, selection.y.max,  rview.x.max, selection.y.max );
+        glDrawRect(selection.x.min, selection.y.min,  selection.x.max, selection.y.max);
+    }
+    prog_lines.Unbind();
+
+    prog_text.SaveBind();
+
+    //////////////////////////////////////////////////////////////////////////
+    // Draw Key
+
+    prog_text.SetUniform("u_scale",  2.0f / v.w, 2.0f / v.h);
+
+    int keyid = 0;
+    for(size_t i=0; i < plotseries.size(); ++i)
+    {
+        PlotSeries& ps = plotseries[i];
+        if(ps.used && ps.drawing_mode != pangolin::DrawingModeNone) {
+            prog_text.SetUniform("u_color", ps.colour );
+            prog_text.SetUniform("u_offset",
+                v.w-5-ps.title.Width() -(v.w/2.0f),
+                v.h-1.2*default_font().Height()*(++keyid) -(v.h/2.0f)
+            );
+            ps.title.DrawGlSl();
+        }
+    }
+
+    //////////////////////////////////////////////////////////////////////////
+    // Draw axis text
+
+    prog_text.SetUniform("u_scale",  2.0f / v.w, 2.0f / v.h);
+    prog_text.SetUniform("u_color", colour_ax );
+
+    for( int i=tx[0]; i<tx[1]; ++i ) {
+        std::ostringstream oss;
+        oss << i*tdelta[0]*tick[0].factor << tick[0].symbol;
+        GlText txt = default_font().Text(oss.str().c_str());
+        float sx = v.w*((i)*tdelta[0]-rview.x.Mid())/w - txt.Width()/2.0f;
+        prog_text.SetUniform("u_offset", sx, 15 -v.h/2.0f );
+        txt.DrawGlSl();
+    }
+
+    for( int i=ty[0]; i<ty[1]; ++i ) {
+        std::ostringstream oss;
+        oss << i*tdelta[1]*tick[1].factor << tick[1].symbol;
+        GlText txt = default_font().Text(oss.str().c_str());
+        float sy = v.h*((i)*tdelta[1]-rview.y.Mid())/h - txt.Height()/2.0f;
+        prog_text.SetUniform("u_offset", 15 -v.w/2.0f, sy );
+        txt.DrawGlSl();
+    }
+
+    prog_text.Unbind();
+
+
+    glLineWidth(1.0f);
+
+#ifndef HAVE_GLES
+    glPopAttrib();
+#endif
+
+}
+
+Plotter::Tick Plotter::FindTickFactor(float tick)
+{
+    Plotter::Tick ret;
+    ret.val = tick;
+
+    const float eps = 1E-6f;
+
+    if( std::abs(tick/M_PI - floor(tick/M_PI)) < eps ) {
+        ret.factor = 1.0f / (float)M_PI;
+        ret.symbol = "pi";
+    }else if( std::abs(tick/M_PI_2 - floor(tick/M_PI_2)) < eps ) {
+        ret.factor = 1.0f / (float)M_PI;
+        ret.symbol = "pi";
+    }else if( std::abs(tick/M_PI_4 - floor(tick/M_PI_4)) < eps ) {
+        ret.factor = 1.0f / (float)M_PI;
+        ret.symbol = "pi";
+    }else if( std::abs(tick/M_SQRT2 - floor(tick/M_SQRT2)) < eps ) {
+        ret.factor = 1.0f / (float)M_SQRT2;
+        ret.symbol = "\251 2";
+    }else if( std::abs(tick/M_E - floor(tick/M_E)) < eps ) {
+        ret.factor = 1.0f / (float)M_E;
+        ret.symbol = "e";
+    }else{
+        ret.factor = 1.0f;
+        ret.symbol = "";
+    }
+    return ret;
+}
+
+void Plotter::SetTicks(float tickx, float ticky)
+{
+    // Compute tick_factor, tick_label
+    tick[0] = FindTickFactor(tickx);
+    tick[1] = FindTickFactor(ticky);
+}
+
+void Plotter::Track(const std::string& x, const std::string& y)
+{
+    Plotter& p = linked_plotter_x ? *linked_plotter_x :
+                    (linked_plotter_y ? *linked_plotter_y : *this);
+
+    if( x != "$i" || y != "") {
+        throw std::runtime_error("Track option not fully implemented");
+    }
+
+    p.track_x = x;
+    p.track_y = y;
+    p.track = !p.track_x.empty() || !p.track_y.empty();
+    p.ComputeTrackValue(p.last_track_val);
+}
+
+void Plotter::ToggleTracking()
+{
+    Plotter& p = linked_plotter_x ? *linked_plotter_x :
+                    (linked_plotter_y ? *linked_plotter_y : *this);
+
+    p.track = !p.track;
+    p.ComputeTrackValue(p.last_track_val);
+}
+
+void Plotter::Trigger(const std::string& x, int edge, float value)
+{
+    if( x != "$0") {
+        throw std::runtime_error("Trigger option not fully implemented");
+    }
+
+    trigger = x;
+    trigger_edge = edge;
+    trigger_value = value;
+    ComputeTrackValue(last_track_val);
+}
+
+void Plotter::ToggleTrigger()
+{
+    trigger_edge = trigger_edge ? 0 : -1;
+    ComputeTrackValue(last_track_val);
+}
+
+void Plotter::SetBackgroundColour(const Colour& col)
+{
+    colour_bg = col;
+}
+
+void Plotter::SetAxisColour(const Colour& col)
+{
+    colour_ax = col;
+}
+
+void Plotter::SetTickColour(const Colour& col)
+{
+    colour_tk = col;
+}
+
+XYRangef& Plotter::GetView()
+{
+    return target;
+}
+
+XYRangef& Plotter::GetDefaultView()
+{
+    return rview_default;
+}
+
+XYRangef& Plotter::GetSelection()
+{
+    return selection;
+}
+
+void Plotter::FixSelection()
+{
+    // Make sure selection matches sign of current viewport
+    if( (selection.x.min<selection.x.max) != (rview.x.min<rview.x.max) ) {
+        std::swap(selection.x.min, selection.x.max);
+    }
+    if( (selection.y.min<selection.y.max) != (rview.y.min<rview.y.max) ) {
+        std::swap(selection.y.min, selection.y.max);
+    }
+}
+
+void Plotter::UpdateView()
+{
+    // Track value based on last log sample
+    if( (track || trigger_edge) && !(linked_plotter_x || linked_plotter_y) ) {
+        float newTrackVal[2];
+        ComputeTrackValue(newTrackVal);
+        if(target.x.max <= newTrackVal[0] ) {
+            ScrollView(newTrackVal[0]-last_track_val[0], newTrackVal[1]-last_track_val[1] );
+        }
+        last_track_val[0] = newTrackVal[0];
+        last_track_val[1] = newTrackVal[1];
+    }
+
+    const float sf = 1.0f / 20.0f;
+//    XYRange d = target - rview;
+//    rview += d * sf;
+
+    if( linked_plotter_x ) {
+        // Synchronise rview and target with linked plotter
+        rview.x = linked_plotter_x->rview.x;
+        target.x = linked_plotter_x->target.x;
+    }else{
+        // Animate view window toward target
+        Rangef d = target.x - rview.x;
+        rview.x += d * sf;
+    }
+
+    if( linked_plotter_y ) {
+        // Synchronise rview and target with linked plotter
+        rview.y = linked_plotter_y->rview.y;
+        target.y = linked_plotter_y->target.y;
+    }else{
+        // Animate view window toward target
+        Rangef d = target.y - rview.y;
+        rview.y += d * sf;
+    }
+}
+
+void Plotter::SetView(const XYRangef& range)
+{
+    Plotter& px = linked_plotter_x ? *linked_plotter_x : *this;
+    Plotter& py = linked_plotter_y ? *linked_plotter_y : *this;
+
+    px.rview.x = range.x;
+    py.rview.y = range.y;
+    px.target.x = range.x;
+    py.target.y = range.y;
+}
+
+void Plotter::SetViewSmooth(const XYRangef &range)
+{
+    Plotter& px = linked_plotter_x ? *linked_plotter_x : *this;
+    Plotter& py = linked_plotter_y ? *linked_plotter_y : *this;
+
+    px.target.x = range.x;
+    py.target.y = range.y;
+}
+
+void Plotter::SetDefaultView(const XYRangef &range)
+{
+    Plotter& px = linked_plotter_x ? *linked_plotter_x : *this;
+    Plotter& py = linked_plotter_y ? *linked_plotter_y : *this;
+
+    px.rview_default.x = range.x;
+    py.rview_default.y = range.y;
+}
+
+void Plotter::ScrollView(float x, float y)
+{
+    Plotter& px = linked_plotter_x ? *linked_plotter_x : *this;
+    Plotter& py = linked_plotter_y ? *linked_plotter_y : *this;
+
+    px.target.x += x;
+    py.target.y += y;
+    px.rview.x += x;
+    py.rview.y += y;
+}
+
+void Plotter::ScrollViewSmooth(float x, float y)
+{
+    Plotter& px = linked_plotter_x ? *linked_plotter_x : *this;
+    Plotter& py = linked_plotter_y ? *linked_plotter_y : *this;
+
+    px.target.x += x;
+    py.target.y += y;
+}
+
+void Plotter::ScaleView(float x, float y, float cx, float cy)
+{
+    Plotter& px = linked_plotter_x ? *linked_plotter_x : *this;
+    Plotter& py = linked_plotter_y ? *linked_plotter_y : *this;
+
+    px.target.x.Scale(x, cx);
+    py.target.y.Scale(y, cy);
+    px.rview.x.Scale(x, cx);
+    py.rview.y.Scale(y, cy);
+}
+
+void Plotter::ScaleViewSmooth(float x, float y, float cx, float cy)
+{
+    Plotter& px = linked_plotter_x ? *linked_plotter_x : *this;
+    Plotter& py = linked_plotter_y ? *linked_plotter_y : *this;
+
+    px.target.x.Scale(x,cx);
+    py.target.y.Scale(y,cy);
+}
+
+void Plotter::ResetView()
+{
+    Plotter& px = linked_plotter_x ? *linked_plotter_x : *this;
+    Plotter& py = linked_plotter_y ? *linked_plotter_y : *this;
+
+    px.target.x = px.rview_default.x;
+    py.target.y = py.rview_default.y;
+}
+
+void Plotter::Keyboard(View&, unsigned char key, int /*x*/, int /*y*/, bool pressed)
+{
+    const float mvfactor = 1.0f / 10.0f;
+
+    const float c[2] = {
+        track || trigger_edge ? target.x.max : rview.x.Mid(),
+        rview.y.Mid()
+    };
+
+    if(pressed) {
+        if(key == ' ') {
+            if( selection.Area() <= 0.0f) {
+                // Work out Auto zoom selection bounds
+                selection = ComputeAutoSelection();
+            }
+
+            if( selection.Area() > 0.0f) {
+                // Set view to equal selection
+                SetViewSmooth(selection);
+
+                // Reset selection
+                selection.x.max = selection.x.min;
+                selection.y.max = selection.y.min;
+            }
+        }else if(key == PANGO_SPECIAL + PANGO_KEY_LEFT) {
+            const float w = rview.x.Size();
+            const float dx = mvfactor*w;
+            ScrollViewSmooth(-dx, 0);
+        }else if(key == PANGO_SPECIAL + PANGO_KEY_RIGHT) {
+            const float w = rview.x.Size();
+            const float dx = mvfactor*w;
+            ScrollViewSmooth(+dx, 0);
+        }else if(key == PANGO_SPECIAL + PANGO_KEY_DOWN) {
+            const float h = target.y.Size();
+            const float dy = mvfactor*h;
+            ScrollViewSmooth(0, -dy);
+        }else if(key == PANGO_SPECIAL + PANGO_KEY_UP) {
+            const float h = target.y.Size();
+            const float dy = mvfactor*h;
+            ScrollViewSmooth(0, +dy);
+        }else if(key == '=') {
+            ScaleViewSmooth(0.5, 0.5, c[0], c[1]);
+        }else if(key == '-') {
+            ScaleViewSmooth(2.0, 2.0, c[0], c[1]);
+        }else if(key == 'r') {
+            ResetView();
+        }else if(key == 't') {
+            ToggleTracking();
+        }else if(key == 'e') {
+            ToggleTrigger();
+        }else if('1' <= key && key <= '9') {
+            const size_t id = key - '1';
+            if(id < plotseries.size()) {
+                PlotSeries& s = plotseries[id];
+                if(s.drawing_mode == DrawingModeNone) {
+                    s.drawing_mode = DrawingModePoints;
+                }else{
+                    ++s.drawing_mode;
+                    if(s.drawing_mode == GL_LINE_LOOP) {
+                        ++s.drawing_mode;
+                    }
+                }
+            }
+        }
+    }
+}
+
+void Plotter::ScreenToPlot(int xpix, int ypix, float& xplot, float& yplot)
+{
+    xplot = rview.x.min + rview.x.Size() * (xpix - v.l) / (float)v.w;
+    yplot = rview.y.min + rview.y.Size() * (ypix - v.b) / (float)v.h;
+}
+
+void Plotter::Mouse(View& /*view*/, MouseButton button, int x, int y, bool pressed, int button_state)
+{
+    // Update hover status (after potential resizing)
+    ScreenToPlot(x, y, hover[0], hover[1]);
+
+    const float scinc = 1.05f;
+    const float scdec = 1.0f/scinc;
+
+    const float c[2] = {
+        track || trigger_edge ? last_track_val[0] : hover[0],
+        hover[1]
+    };
+
+    if(button_state & KeyModifierShift) {
+        if(button == MouseWheelUp) {
+            ScaleViewSmooth(1.0f, scinc, c[0], c[1]);
+        }else if(button == MouseWheelDown) {
+            ScaleViewSmooth(1.0f, scdec, c[0], c[1]);
+        }else if(button == MouseWheelLeft) {
+            ScaleViewSmooth(scinc, 1.0f, c[0], c[1]);
+        }else if(button == MouseWheelRight) {
+            ScaleViewSmooth(scdec, 1.0f, c[0], c[1]);
+        }
+    }else if(button_state & KeyModifierCtrl) {
+        if(button == MouseWheelUp) {
+            ScaleViewSmooth(scinc, 1.0f, c[0], c[1]);
+        }else if(button == MouseWheelDown) {
+            ScaleViewSmooth(scdec, 1.0f, c[0], c[1]);
+        }
+    }else{
+        const float mvfactor = 1.0f/20.0f;
+
+        if(button == MouseButtonLeft) {
+            // Update selected range
+            if(pressed) {
+                selection.x.min = hover[0];
+                selection.y.min = hover[1];
+                trigger_value = selection.y.min;
+            }
+            selection.x.max = hover[0];
+            selection.y.max = hover[1];
+        }else if(button == MouseWheelUp) {
+            ScrollViewSmooth(0.0f, +mvfactor*rview.y.Size() );
+        }else if(button == MouseWheelDown) {
+            ScrollViewSmooth(0.0f, -mvfactor*rview.y.Size() );
+        }else if(button == MouseWheelLeft) {
+            ScrollViewSmooth(+mvfactor*rview.x.Size(), 0.0f );
+        }else if(button == MouseWheelRight) {
+            ScrollViewSmooth(-mvfactor*rview.x.Size(), 0.0f );
+        }
+    }
+
+    FixSelection();
+
+    last_mouse_pos[0] = x;
+    last_mouse_pos[1] = y;
+}
+
+void Plotter::MouseMotion(View& view, int x, int y, int button_state)
+{
+    const int d[2] = {x-last_mouse_pos[0], y-last_mouse_pos[1]};
+    const float is[2] = {rview.x.Size(), rview.y.Size() };
+    const float df[2] = {is[0]*d[0]/(float)v.w, is[1]*d[1]/(float)v.h};
+
+    // Update hover status (after potential resizing)
+    ScreenToPlot(x, y, hover[0], hover[1]);
+
+    if( button_state == MouseButtonLeft )
+    {
+        // Update selected range
+        selection.x.max = hover[0];
+        selection.y.max = hover[1];
+    }else if(button_state == MouseButtonMiddle )
+    {
+        Special(view, InputSpecialScroll, df[0], df[1], 0.0f, 0.0f, 0.0f, 0.0f, button_state);
+    }else if(button_state == MouseButtonRight )
+    {
+        const float c[2] = {
+            track || trigger_edge ? last_track_val[0] : hover[0],
+            hover[1]
+        };
+
+        const float scale[2] = {
+            1.0f + (float)d[0] / (float)v.w,
+            1.0f - (float)d[1] / (float)v.h,
+        };
+        ScaleView(scale[0], scale[1], c[0], c[1]);
+    }
+
+    last_mouse_pos[0] = x;
+    last_mouse_pos[1] = y;
+}
+
+void Plotter::PassiveMouseMotion(View&, int x, int y, int /*button_state*/)
+{
+    ScreenToPlot(x, y, hover[0], hover[1]);
+}
+
+void Plotter::Special(View&, InputSpecial inType, float x, float y, float p1, float p2, float /*p3*/, float /*p4*/, int button_state)
+{
+    if(inType == InputSpecialScroll) {
+        const float d[2] = {p1,-p2};
+        const float is[2] = {rview.x.Size(),rview.y.Size() };
+        const float df[2] = {is[0]*d[0]/(float)v.w, is[1]*d[1]/(float)v.h};
+
+        ScrollView(-df[0], -df[1]);
+    } else if(inType == InputSpecialZoom) {
+        float scalex = 1.0f-p1;
+        float scaley = 1.0f-p1;
+
+        if (button_state & (KeyModifierCmd | KeyModifierCtrl)) {
+            scaley = 1.0f;
+        }
+        if (button_state & (KeyModifierShift)) {
+            scalex = 1.0f;
+        }
+
+        const float c[2] = {
+            track || trigger_edge ? last_track_val[0] : hover[0],
+            hover[1]
+        };
+
+        ScaleView(scalex, scaley, c[0], c[1]);
+    }
+
+    // Update hover status (after potential resizing)
+    ScreenToPlot( (int)x, (int)y, hover[0], hover[1]);
+}
+
+void Plotter::AddSeries(const std::string& x_expr, const std::string& y_expr,
+    DrawingMode drawing_mode, Colour colour,
+    const std::string& title, DataLog *log)
+{
+    if( !std::isfinite(colour.r) ) {
+        colour = colour_wheel.GetUniqueColour();
+    }
+    plotseries.push_back( PlotSeries() );
+    plotseries.back().CreatePlot(x_expr, y_expr, colour, (title == "$y") ? PlotTitleFromExpr(y_expr) : title);
+    plotseries.back().log = log;
+    plotseries.back().drawing_mode = (GLenum)drawing_mode;
+}
+
+std::string Plotter::PlotTitleFromExpr(const std::string& expr) const
+{
+    const std::vector<std::string>& labels = default_log->Labels();
+
+    std::stringstream exp_in(expr);
+    std::stringstream exp_out;
+    while(!exp_in.eof()) {
+        int c = exp_in.get();
+        if(c=='$') {
+            size_t id = -1;
+            exp_in >> id;
+            if(id < labels.size()) {
+                exp_out << '\'' << labels[id] << '\'';
+            }else{
+                exp_out << '$' << id;
+            }
+        }else{
+            exp_out << (char)c;
+        }
+    }
+
+    return exp_out.str();
+}
+
+void Plotter::ClearSeries()
+{
+    plotseries.clear();
+}
+
+Marker& Plotter::AddMarker(Marker::Direction d, float value, Marker::Equality leg, Colour c )
+{
+    return AddMarker(Marker(d,value,leg,c));
+}
+
+Marker& Plotter::AddMarker( const Marker& marker )
+{
+    plotmarkers.push_back( marker );
+    return plotmarkers.back();
+}
+
+void Plotter::ClearMarkers()
+{
+    plotmarkers.clear();
+}
+
+void Plotter::ResetColourWheel()
+{
+    colour_wheel.Reset();
+}
+
+}

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

@@ -0,0 +1,90 @@
+get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME)
+
+option(BUILD_PANGOLIN_PYTHON "Build support for Pangolin Interactive Console" ON)
+
+if(BUILD_PANGOLIN_PYTHON)
+  find_package(Python COMPONENTS Interpreter Development QUIET)
+endif()
+
+if(BUILD_PANGOLIN_PYTHON AND Python_FOUND)
+    # If we've inited the submodule, use that
+    if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/pybind11/CMakeLists.txt")
+        add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/pybind11)
+    else()
+        find_package(pybind11 CONFIG QUIET)
+    endif()
+endif()
+
+if(BUILD_PANGOLIN_PYTHON AND Python_FOUND AND pybind11_FOUND)
+    set(SRC_BINDINGS
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/attach.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/colour.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/datalog.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/display.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/gl.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/gl_draw.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/glsl.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/glvbo.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/handler.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/image.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/image_view.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/opengl_render_state.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/params.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/pixel_format.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/plotter.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/pypangoio.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/var.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/video.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/view.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/viewport.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/widget.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin/window.cpp
+    )
+
+    target_sources(
+        ${COMPONENT} PRIVATE 
+        ${CMAKE_CURRENT_LIST_DIR}/src/pyinterpreter.cpp
+        ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin_embed.cpp 
+        ${SRC_BINDINGS} 
+    )
+
+    target_compile_definitions(${COMPONENT} PUBLIC HAVE_PYTHON)
+    target_link_libraries(${COMPONENT} PUBLIC
+        pango_core pango_display pango_plot pango_video pango_vars
+    )
+    target_link_libraries(${COMPONENT} PRIVATE pybind11::embed )
+    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}
+    )
+
+    PangolinRegisterFactory( InterpreterInterface PyInterpreter )
+
+    # Add python module as another target. For some reason, it doesn't work to just link against ${COMPONENT}
+    pybind11_add_module(pypangolin ${CMAKE_CURRENT_LIST_DIR}/src/pypangolin_module.cpp ${SRC_BINDINGS})
+    target_link_libraries(pypangolin PRIVATE pango_core pango_display pango_plot pango_video pango_vars pybind11::module)
+    target_include_directories(pypangolin PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+    )
+
+    # Create a target for generating a python wheel
+    include(MakePythonWheel)
+    MakeWheel( pypangolin
+        VERSION ${PANGOLIN_VERSION}
+        SUMMARY "Pangolin is a lightweight portable rapid development library for managing OpenGL display / interaction and abstracting video input."
+        HOMEPAGE "https://github.com/stevenlovegrove/Pangolin"
+        AUTHOR "Steven Lovegrove"
+        EMAIL "[email protected]"
+        LICENCE "MIT"
+        REQUIRES "pyopengl;pyopengl-accelerate;numpy;pillow;pybind11"
+        PRINT_HELP
+    )
+else()
+    #TODO: with the following line uncommented and BUILD_PANGOLIN_PYTHON=OFF, `make install` fails b/c it tries to install a missing libpango_python.a
+    #set_target_properties(${COMPONENT} PROPERTIES EXCLUDE_FROM_ALL 1 EXCLUDE_FROM_DEFAULT_BUILD 1)
+    target_sources( ${COMPONENT} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/../pango_core/src/dummy.cpp )
+endif()

third-party/DPVO/Pangolin/components/pango_python/include/pangolin/python/pyinterpreter.h

@@ -0,0 +1,72 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pybind11/embed.h>
+#include <pangolin/var/varextra.h>
+#include <pangolin/console/InterpreterInterface.h>
+#include <queue>
+#include <set>
+#include <thread>
+
+namespace pangolin
+{
+
+class PyInterpreter : public InterpreterInterface
+{
+public:
+    PyInterpreter();
+
+    ~PyInterpreter() override;
+
+    void PushCommand(const std::string &cmd) override;
+
+    bool PullLine(InterpreterLine& line) override;
+
+    std::vector<std::string> Complete(
+        const std::string& cmd, int max_options
+    ) override;
+
+private:
+    void  NewVarCallback(const pangolin::VarState::Event& e);
+
+    pybind11::scoped_interpreter guard;
+
+    pybind11::object pycompleter;
+    pybind11::object pycomplete;
+
+    std::string ToString(const pybind11::object& py);
+    pybind11::object EvalExec(const std::string& cmd);
+    void CheckPrintClearError();
+
+    std::queue<InterpreterLine> line_queue;
+    std::set<std::string> base_prefixes;
+    sigslot::scoped_connection var_added_connection;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_python/pybind11/.appveyor.yml

@@ -0,0 +1,37 @@
+version: 1.0.{build}
+image:
+- Visual Studio 2015
+test: off
+skip_branch_with_pr: true
+build:
+  parallel: true
+platform:
+- x86
+environment:
+  matrix:
+  - PYTHON: 36
+    CONFIG: Debug
+  - PYTHON: 27
+    CONFIG: Debug
+install:
+- ps: |
+    $env:CMAKE_GENERATOR = "Visual Studio 14 2015"
+    if ($env:PLATFORM -eq "x64") { $env:PYTHON = "$env:PYTHON-x64" }
+    $env:PATH = "C:\Python$env:PYTHON\;C:\Python$env:PYTHON\Scripts\;$env:PATH"
+    python -W ignore -m pip install --upgrade pip wheel
+    python -W ignore -m pip install pytest numpy --no-warn-script-location pytest-timeout
+- ps: |
+    Start-FileDownload 'https://gitlab.com/libeigen/eigen/-/archive/3.3.7/eigen-3.3.7.zip'
+    7z x eigen-3.3.7.zip -y > $null
+    $env:CMAKE_INCLUDE_PATH = "eigen-3.3.7;$env:CMAKE_INCLUDE_PATH"
+build_script:
+- cmake -G "%CMAKE_GENERATOR%" -A "%CMAKE_ARCH%"
+    -DCMAKE_CXX_STANDARD=14
+    -DPYBIND11_WERROR=ON
+    -DDOWNLOAD_CATCH=ON
+    -DCMAKE_SUPPRESS_REGENERATION=1
+    .
+- set MSBuildLogger="C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
+- cmake --build . --config %CONFIG% --target pytest -- /m /v:m /logger:%MSBuildLogger%
+- cmake --build . --config %CONFIG% --target cpptest -- /m /v:m /logger:%MSBuildLogger%
+on_failure: if exist "tests\test_cmake_build" type tests\test_cmake_build\*.log*

third-party/DPVO/Pangolin/components/pango_python/pybind11/.clang-format

@@ -0,0 +1,19 @@
+---
+# See all possible options and defaults with:
+# clang-format --style=llvm --dump-config
+BasedOnStyle: LLVM
+AccessModifierOffset: -4
+AlwaysBreakTemplateDeclarations: Yes
+BinPackArguments: false
+BinPackParameters: false
+BreakBeforeBinaryOperators: All
+BreakConstructorInitializers: BeforeColon
+ColumnLimit: 99
+IndentCaseLabels: true
+IndentPPDirectives: AfterHash
+IndentWidth: 4
+Language: Cpp
+SpaceAfterCStyleCast: true
+Standard: Cpp11
+TabWidth: 4
+...

third-party/DPVO/Pangolin/components/pango_python/pybind11/.clang-tidy

@@ -0,0 +1,58 @@
+FormatStyle: file
+
+Checks: '
+cppcoreguidelines-init-variables,
+clang-analyzer-optin.cplusplus.VirtualCall,
+llvm-namespace-comment,
+misc-misplaced-const,
+misc-non-copyable-objects,
+misc-static-assert,
+misc-throw-by-value-catch-by-reference,
+misc-uniqueptr-reset-release,
+misc-unused-parameters,
+modernize-avoid-bind,
+modernize-make-shared,
+modernize-redundant-void-arg,
+modernize-replace-auto-ptr,
+modernize-replace-disallow-copy-and-assign-macro,
+modernize-replace-random-shuffle,
+modernize-shrink-to-fit,
+modernize-use-auto,
+modernize-use-bool-literals,
+modernize-use-equals-default,
+modernize-use-equals-delete,
+modernize-use-default-member-init,
+modernize-use-noexcept,
+modernize-use-emplace,
+modernize-use-override,
+modernize-use-using,
+*performance*,
+readability-avoid-const-params-in-decls,
+readability-container-size-empty,
+readability-else-after-return,
+readability-delete-null-pointer,
+readability-implicit-bool-conversion,
+readability-make-member-function-const,
+readability-misplaced-array-index,
+readability-non-const-parameter,
+readability-redundant-function-ptr-dereference,
+readability-redundant-smartptr-get,
+readability-redundant-string-cstr,
+readability-simplify-subscript-expr,
+readability-static-accessed-through-instance,
+readability-static-definition-in-anonymous-namespace,
+readability-string-compare,
+readability-uniqueptr-delete-release,
+'
+
+CheckOptions:
+- key:             performance-for-range-copy.WarnOnAllAutoCopies
+  value:           true
+- key:             performance-unnecessary-value-param.AllowedTypes
+  value:           'exception_ptr$;'
+- key:             readability-implicit-bool-conversion.AllowPointerConditions
+  value:           true
+
+HeaderFilterRegex: 'pybind11/.*h'
+
+WarningsAsErrors: '*'

third-party/DPVO/Pangolin/components/pango_python/pybind11/.cmake-format.yaml

@@ -0,0 +1,73 @@
+parse:
+  additional_commands:
+    pybind11_add_module:
+      flags:
+        - THIN_LTO
+        - MODULE
+        - SHARED
+        - NO_EXTRAS
+        - EXCLUDE_FROM_ALL
+        - SYSTEM
+
+format:
+  line_width: 99
+  tab_size: 2
+
+  # If an argument group contains more than this many sub-groups
+  # (parg or kwarg groups) then force it to a vertical layout.
+  max_subgroups_hwrap: 2
+
+  # If a positional argument group contains more than this many
+  # arguments, then force it to a vertical layout.
+  max_pargs_hwrap: 6
+
+  # If a cmdline positional group consumes more than this many
+  # lines without nesting, then invalidate the layout (and nest)
+  max_rows_cmdline: 2
+  separate_ctrl_name_with_space: false
+  separate_fn_name_with_space: false
+  dangle_parens: false
+
+  # If the trailing parenthesis must be 'dangled' on its on
+  # 'line, then align it to this reference: `prefix`: the start'
+  # 'of the statement,  `prefix-indent`: the start of the'
+  # 'statement, plus one indentation  level, `child`: align to'
+  # the column of the arguments
+  dangle_align: prefix
+  # If the statement spelling length (including space and
+  # parenthesis) is smaller than this amount, then force reject
+  # nested layouts.
+  min_prefix_chars: 4
+
+  # If the statement spelling length (including space and
+  # parenthesis) is larger than the tab width by more than this
+  # amount, then force reject un-nested layouts.
+  max_prefix_chars: 10
+
+  # If a candidate layout is wrapped horizontally but it exceeds
+  # this many lines, then reject the layout.
+  max_lines_hwrap: 2
+
+  line_ending: unix
+
+  # Format command names consistently as 'lower' or 'upper' case
+  command_case: canonical
+
+  # Format keywords consistently as 'lower' or 'upper' case
+  # unchanged is valid too
+  keyword_case: 'upper'
+
+  # A list of command names which should always be wrapped
+  always_wrap: []
+
+  # If true, the argument lists which are known to be sortable
+  # will be sorted lexicographically
+  enable_sort: true
+
+  # If true, the parsers may infer whether or not an argument
+  # list is sortable (without annotation).
+  autosort: false
+
+# Causes a few issues - can be solved later, possibly.
+markup:
+  enable_markup: false

third-party/DPVO/Pangolin/components/pango_python/pybind11/.pre-commit-config.yaml

@@ -0,0 +1,119 @@
+# To use:
+#
+#     pre-commit run -a
+#
+# Or:
+#
+#     pre-commit install  # (runs every time you commit in git)
+#
+# To update this file:
+#
+#     pre-commit autoupdate
+#
+# See https://github.com/pre-commit/pre-commit
+
+repos:
+# Standard hooks
+- repo: https://github.com/pre-commit/pre-commit-hooks
+  rev: v4.0.1
+  hooks:
+  - id: check-added-large-files
+  - id: check-case-conflict
+  - id: check-merge-conflict
+  - id: check-symlinks
+  - id: check-yaml
+  - id: debug-statements
+  - id: end-of-file-fixer
+  - id: mixed-line-ending
+  - id: requirements-txt-fixer
+  - id: trailing-whitespace
+  - id: fix-encoding-pragma
+    exclude: ^noxfile.py$
+
+- repo: https://github.com/asottile/pyupgrade
+  rev: v2.23.1
+  hooks:
+  - id: pyupgrade
+
+# Black, the code formatter, natively supports pre-commit
+- repo: https://github.com/psf/black
+  rev: 21.7b0
+  hooks:
+  - id: black
+    # By default, this ignores pyi files, though black supports them
+    types: [text]
+    files: \.pyi?$
+
+# Changes tabs to spaces
+- repo: https://github.com/Lucas-C/pre-commit-hooks
+  rev: v1.1.10
+  hooks:
+  - id: remove-tabs
+
+# Flake8 also supports pre-commit natively (same author)
+- repo: https://github.com/PyCQA/flake8
+  rev: 3.9.2
+  hooks:
+  - id: flake8
+    additional_dependencies: [flake8-bugbear, pep8-naming]
+    exclude: ^(docs/.*|tools/.*)$
+
+# CMake formatting
+- repo: https://github.com/cheshirekow/cmake-format-precommit
+  rev: v0.6.13
+  hooks:
+  - id: cmake-format
+    additional_dependencies: [pyyaml]
+    types: [file]
+    files: (\.cmake|CMakeLists.txt)(.in)?$
+
+# Check static types with mypy
+- repo: https://github.com/pre-commit/mirrors-mypy
+  rev: v0.910
+  hooks:
+  - id: mypy
+    # The default Python type ignores .pyi files, so let's rerun if detected
+    types: [text]
+    files: ^pybind11.*\.pyi?$
+    # Running per-file misbehaves a bit, so just run on all files, it's fast
+    pass_filenames: false
+    additional_dependencies: [typed_ast]
+
+# Checks the manifest for missing files (native support)
+- repo: https://github.com/mgedmin/check-manifest
+  rev: "0.46"
+  hooks:
+  - id: check-manifest
+    # This is a slow hook, so only run this if --hook-stage manual is passed
+    stages: [manual]
+    additional_dependencies: [cmake, ninja]
+
+- repo: https://github.com/codespell-project/codespell
+  rev: v2.1.0
+  hooks:
+  - id: codespell
+    exclude: ".supp$"
+    args: ["-L", "nd,ot,thist"]
+
+-   repo: https://github.com/shellcheck-py/shellcheck-py
+    rev: v0.7.2.1
+    hooks:
+    -   id: shellcheck
+
+# The original pybind11 checks for a few C++ style items
+- repo: local
+  hooks:
+  - id: disallow-caps
+    name: Disallow improper capitalization
+    language: pygrep
+    entry: PyBind|Numpy|Cmake|CCache|PyTest
+    exclude: .pre-commit-config.yaml
+
+- repo: local
+  hooks:
+  - id: check-style
+    name: Classic check-style
+    language: system
+    types:
+    - c++
+    entry: ./tools/check-style.sh

third-party/DPVO/Pangolin/components/pango_python/pybind11/.readthedocs.yml

@@ -0,0 +1,3 @@
+python:
+  version: 3
+requirements_file: docs/requirements.txt

third-party/DPVO/Pangolin/components/pango_python/pybind11/CMakeLists.txt

@@ -0,0 +1,290 @@
+# CMakeLists.txt -- Build system for the pybind11 modules
+#
+# Copyright (c) 2015 Wenzel Jakob <[email protected]>
+#
+# All rights reserved. Use of this source code is governed by a
+# BSD-style license that can be found in the LICENSE file.
+
+cmake_minimum_required(VERSION 3.4)
+
+# The `cmake_minimum_required(VERSION 3.4...3.18)` syntax does not work with
+# some versions of VS that have a patched CMake 3.11. This forces us to emulate
+# the behavior using the following workaround:
+if(${CMAKE_VERSION} VERSION_LESS 3.18)
+  cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
+else()
+  cmake_policy(VERSION 3.18)
+endif()
+
+# Extract project version from source
+file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/include/pybind11/detail/common.h"
+     pybind11_version_defines REGEX "#define PYBIND11_VERSION_(MAJOR|MINOR|PATCH) ")
+
+foreach(ver ${pybind11_version_defines})
+  if(ver MATCHES [[#define PYBIND11_VERSION_(MAJOR|MINOR|PATCH) +([^ ]+)$]])
+    set(PYBIND11_VERSION_${CMAKE_MATCH_1} "${CMAKE_MATCH_2}")
+  endif()
+endforeach()
+
+if(PYBIND11_VERSION_PATCH MATCHES [[\.([a-zA-Z0-9]+)$]])
+  set(pybind11_VERSION_TYPE "${CMAKE_MATCH_1}")
+endif()
+string(REGEX MATCH "^[0-9]+" PYBIND11_VERSION_PATCH "${PYBIND11_VERSION_PATCH}")
+
+project(
+  pybind11
+  LANGUAGES CXX
+  VERSION "${PYBIND11_VERSION_MAJOR}.${PYBIND11_VERSION_MINOR}.${PYBIND11_VERSION_PATCH}")
+
+# Standard includes
+include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+include(CMakeDependentOption)
+
+if(NOT pybind11_FIND_QUIETLY)
+  message(STATUS "pybind11 v${pybind11_VERSION} ${pybind11_VERSION_TYPE}")
+endif()
+
+# Avoid infinite recursion if tests include this as a subdirectory
+if(DEFINED PYBIND11_MASTER_PROJECT)
+  set(PYBIND11_TEST OFF)
+endif()
+
+# Check if pybind11 is being used directly or via add_subdirectory
+if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR AND NOT DEFINED PYBIND11_MASTER_PROJECT)
+  ### Warn if not an out-of-source builds
+  if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR)
+    set(lines
+        "You are building in-place. If that is not what you intended to "
+        "do, you can clean the source directory with:\n"
+        "rm -r CMakeCache.txt CMakeFiles/ cmake_uninstall.cmake pybind11Config.cmake "
+        "pybind11ConfigVersion.cmake tests/CMakeFiles/\n")
+    message(AUTHOR_WARNING ${lines})
+  endif()
+
+  set(PYBIND11_MASTER_PROJECT ON)
+
+  if(OSX AND CMAKE_VERSION VERSION_LESS 3.7)
+    # Bug in macOS CMake < 3.7 is unable to download catch
+    message(WARNING "CMAKE 3.7+ needed on macOS to download catch, and newer HIGHLY recommended")
+  elseif(WINDOWS AND CMAKE_VERSION VERSION_LESS 3.8)
+    # Only tested with 3.8+ in CI.
+    message(WARNING "CMAKE 3.8+ tested on Windows, previous versions untested")
+  endif()
+
+  message(STATUS "CMake ${CMAKE_VERSION}")
+
+  if(CMAKE_CXX_STANDARD)
+    set(CMAKE_CXX_EXTENSIONS OFF)
+    set(CMAKE_CXX_STANDARD_REQUIRED ON)
+  endif()
+
+  set(pybind11_system "")
+else()
+  set(PYBIND11_MASTER_PROJECT OFF)
+  set(pybind11_system SYSTEM)
+endif()
+
+# Options
+option(PYBIND11_INSTALL "Install pybind11 header files?" ${PYBIND11_MASTER_PROJECT})
+option(PYBIND11_TEST "Build pybind11 test suite?" ${PYBIND11_MASTER_PROJECT})
+option(PYBIND11_NOPYTHON "Disable search for Python" OFF)
+
+cmake_dependent_option(
+  USE_PYTHON_INCLUDE_DIR
+  "Install pybind11 headers in Python include directory instead of default installation prefix"
+  OFF "PYBIND11_INSTALL" OFF)
+
+cmake_dependent_option(PYBIND11_FINDPYTHON "Force new FindPython" OFF
+                       "NOT CMAKE_VERSION VERSION_LESS 3.12" OFF)
+
+# NB: when adding a header don't forget to also add it to setup.py
+set(PYBIND11_HEADERS
+    include/pybind11/detail/class.h
+    include/pybind11/detail/common.h
+    include/pybind11/detail/descr.h
+    include/pybind11/detail/init.h
+    include/pybind11/detail/internals.h
+    include/pybind11/detail/type_caster_base.h
+    include/pybind11/detail/typeid.h
+    include/pybind11/attr.h
+    include/pybind11/buffer_info.h
+    include/pybind11/cast.h
+    include/pybind11/chrono.h
+    include/pybind11/common.h
+    include/pybind11/complex.h
+    include/pybind11/options.h
+    include/pybind11/eigen.h
+    include/pybind11/embed.h
+    include/pybind11/eval.h
+    include/pybind11/gil.h
+    include/pybind11/iostream.h
+    include/pybind11/functional.h
+    include/pybind11/numpy.h
+    include/pybind11/operators.h
+    include/pybind11/pybind11.h
+    include/pybind11/pytypes.h
+    include/pybind11/stl.h
+    include/pybind11/stl_bind.h
+    include/pybind11/stl/filesystem.h)
+
+# Compare with grep and warn if mismatched
+if(PYBIND11_MASTER_PROJECT AND NOT CMAKE_VERSION VERSION_LESS 3.12)
+  file(
+    GLOB_RECURSE _pybind11_header_check
+    LIST_DIRECTORIES false
+    RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
+    CONFIGURE_DEPENDS "include/pybind11/*.h")
+  set(_pybind11_here_only ${PYBIND11_HEADERS})
+  set(_pybind11_disk_only ${_pybind11_header_check})
+  list(REMOVE_ITEM _pybind11_here_only ${_pybind11_header_check})
+  list(REMOVE_ITEM _pybind11_disk_only ${PYBIND11_HEADERS})
+  if(_pybind11_here_only)
+    message(AUTHOR_WARNING "PYBIND11_HEADERS has extra files:" ${_pybind11_here_only})
+  endif()
+  if(_pybind11_disk_only)
+    message(AUTHOR_WARNING "PYBIND11_HEADERS is missing files:" ${_pybind11_disk_only})
+  endif()
+endif()
+
+# CMake 3.12 added list(TRANSFORM <list> PREPEND
+# But we can't use it yet
+string(REPLACE "include/" "${CMAKE_CURRENT_SOURCE_DIR}/include/" PYBIND11_HEADERS
+               "${PYBIND11_HEADERS}")
+
+# Cache variable so this can be used in parent projects
+set(pybind11_INCLUDE_DIR
+    "${CMAKE_CURRENT_LIST_DIR}/include"
+    CACHE INTERNAL "Directory where pybind11 headers are located")
+
+# Backward compatible variable for add_subdirectory mode
+if(NOT PYBIND11_MASTER_PROJECT)
+  set(PYBIND11_INCLUDE_DIR
+      "${pybind11_INCLUDE_DIR}"
+      CACHE INTERNAL "")
+endif()
+
+# Note: when creating targets, you cannot use if statements at configure time -
+# you need generator expressions, because those will be placed in the target file.
+# You can also place ifs *in* the Config.in, but not here.
+
+# This section builds targets, but does *not* touch Python
+# Non-IMPORT targets cannot be defined twice
+if(NOT TARGET pybind11_headers)
+  # Build the headers-only target (no Python included):
+  # (long name used here to keep this from clashing in subdirectory mode)
+  add_library(pybind11_headers INTERFACE)
+  add_library(pybind11::pybind11_headers ALIAS pybind11_headers) # to match exported target
+  add_library(pybind11::headers ALIAS pybind11_headers) # easier to use/remember
+
+  target_include_directories(
+    pybind11_headers ${pybind11_system} INTERFACE $<BUILD_INTERFACE:${pybind11_INCLUDE_DIR}>
+                                                  $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
+
+  target_compile_features(pybind11_headers INTERFACE cxx_inheriting_constructors cxx_user_literals
+                                                     cxx_right_angle_brackets)
+else()
+  # It is invalid to install a target twice, too.
+  set(PYBIND11_INSTALL OFF)
+endif()
+
+include("${CMAKE_CURRENT_SOURCE_DIR}/tools/pybind11Common.cmake")
+
+# Relative directory setting
+if(USE_PYTHON_INCLUDE_DIR AND DEFINED Python_INCLUDE_DIRS)
+  file(RELATIVE_PATH CMAKE_INSTALL_INCLUDEDIR ${CMAKE_INSTALL_PREFIX} ${Python_INCLUDE_DIRS})
+elseif(USE_PYTHON_INCLUDE_DIR AND DEFINED PYTHON_INCLUDE_DIR)
+  file(RELATIVE_PATH CMAKE_INSTALL_INCLUDEDIR ${CMAKE_INSTALL_PREFIX} ${PYTHON_INCLUDE_DIRS})
+endif()
+
+if(PYBIND11_INSTALL)
+  install(DIRECTORY ${pybind11_INCLUDE_DIR}/pybind11 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+  set(PYBIND11_CMAKECONFIG_INSTALL_DIR
+      "${CMAKE_INSTALL_DATAROOTDIR}/cmake/${PROJECT_NAME}"
+      CACHE STRING "install path for pybind11Config.cmake")
+
+  if(IS_ABSOLUTE "${CMAKE_INSTALL_INCLUDEDIR}")
+    set(pybind11_INCLUDEDIR "${CMAKE_INSTALL_FULL_INCLUDEDIR}")
+  else()
+    set(pybind11_INCLUDEDIR "\$\{PACKAGE_PREFIX_DIR\}/${CMAKE_INSTALL_INCLUDEDIR}")
+  endif()
+
+  configure_package_config_file(
+    tools/${PROJECT_NAME}Config.cmake.in "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
+    INSTALL_DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR})
+
+  if(CMAKE_VERSION VERSION_LESS 3.14)
+    # Remove CMAKE_SIZEOF_VOID_P from ConfigVersion.cmake since the library does
+    # not depend on architecture specific settings or libraries.
+    set(_PYBIND11_CMAKE_SIZEOF_VOID_P ${CMAKE_SIZEOF_VOID_P})
+    unset(CMAKE_SIZEOF_VOID_P)
+
+    write_basic_package_version_file(
+      ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
+      VERSION ${PROJECT_VERSION}
+      COMPATIBILITY AnyNewerVersion)
+
+    set(CMAKE_SIZEOF_VOID_P ${_PYBIND11_CMAKE_SIZEOF_VOID_P})
+  else()
+    # CMake 3.14+ natively supports header-only libraries
+    write_basic_package_version_file(
+      ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
+      VERSION ${PROJECT_VERSION}
+      COMPATIBILITY AnyNewerVersion ARCH_INDEPENDENT)
+  endif()
+
+  install(
+    FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
+          ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
+          tools/FindPythonLibsNew.cmake
+          tools/pybind11Common.cmake
+          tools/pybind11Tools.cmake
+          tools/pybind11NewTools.cmake
+    DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR})
+
+  if(NOT PYBIND11_EXPORT_NAME)
+    set(PYBIND11_EXPORT_NAME "${PROJECT_NAME}Targets")
+  endif()
+
+  install(TARGETS pybind11_headers EXPORT "${PYBIND11_EXPORT_NAME}")
+
+  install(
+    EXPORT "${PYBIND11_EXPORT_NAME}"
+    NAMESPACE "pybind11::"
+    DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR})
+
+  # Uninstall target
+  if(PYBIND11_MASTER_PROJECT)
+    configure_file("${CMAKE_CURRENT_SOURCE_DIR}/tools/cmake_uninstall.cmake.in"
+                   "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" IMMEDIATE @ONLY)
+
+    add_custom_target(uninstall COMMAND ${CMAKE_COMMAND} -P
+                                        ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)
+  endif()
+endif()
+
+# BUILD_TESTING takes priority, but only if this is the master project
+if(PYBIND11_MASTER_PROJECT AND DEFINED BUILD_TESTING)
+  if(BUILD_TESTING)
+    if(_pybind11_nopython)
+      message(FATAL_ERROR "Cannot activate tests in NOPYTHON mode")
+    else()
+      add_subdirectory(tests)
+    endif()
+  endif()
+else()
+  if(PYBIND11_TEST)
+    if(_pybind11_nopython)
+      message(FATAL_ERROR "Cannot activate tests in NOPYTHON mode")
+    else()
+      add_subdirectory(tests)
+    endif()
+  endif()
+endif()
+
+# Better symmetry with find_package(pybind11 CONFIG) mode.
+if(NOT PYBIND11_MASTER_PROJECT)
+  set(pybind11_FOUND
+      TRUE
+      CACHE INTERNAL "True if pybind11 and all required components found on the system")
+endif()

third-party/DPVO/Pangolin/components/pango_python/pybind11/docs/_static/theme_overrides.css

@@ -0,0 +1,11 @@
+.wy-table-responsive table td,
+.wy-table-responsive table th {
+    white-space: initial !important;
+}
+.rst-content table.docutils td {
+    vertical-align: top !important;
+}
+div[class^='highlight'] pre {
+    white-space: pre;
+    white-space: pre-wrap;
+}

third-party/DPVO/Pangolin/components/pango_python/pybind11/docs/advanced/cast/chrono.rst

@@ -0,0 +1,81 @@
+Chrono
+======
+
+When including the additional header file :file:`pybind11/chrono.h` conversions
+from C++11 chrono datatypes to python datetime objects are automatically enabled.
+This header also enables conversions of python floats (often from sources such
+as ``time.monotonic()``, ``time.perf_counter()`` and ``time.process_time()``)
+into durations.
+
+An overview of clocks in C++11
+------------------------------
+
+A point of confusion when using these conversions is the differences between
+clocks provided in C++11. There are three clock types defined by the C++11
+standard and users can define their own if needed. Each of these clocks have
+different properties and when converting to and from python will give different
+results.
+
+The first clock defined by the standard is ``std::chrono::system_clock``. This
+clock measures the current date and time. However, this clock changes with to
+updates to the operating system time. For example, if your time is synchronised
+with a time server this clock will change. This makes this clock a poor choice
+for timing purposes but good for measuring the wall time.
+
+The second clock defined in the standard is ``std::chrono::steady_clock``.
+This clock ticks at a steady rate and is never adjusted. This makes it excellent
+for timing purposes, however the value in this clock does not correspond to the
+current date and time. Often this clock will be the amount of time your system
+has been on, although it does not have to be. This clock will never be the same
+clock as the system clock as the system clock can change but steady clocks
+cannot.
+
+The third clock defined in the standard is ``std::chrono::high_resolution_clock``.
+This clock is the clock that has the highest resolution out of the clocks in the
+system. It is normally a typedef to either the system clock or the steady clock
+but can be its own independent clock. This is important as when using these
+conversions as the types you get in python for this clock might be different
+depending on the system.
+If it is a typedef of the system clock, python will get datetime objects, but if
+it is a different clock they will be timedelta objects.
+
+Provided conversions
+--------------------
+
+.. rubric:: C++ to Python
+
+- ``std::chrono::system_clock::time_point`` → ``datetime.datetime``
+    System clock times are converted to python datetime instances. They are
+    in the local timezone, but do not have any timezone information attached
+    to them (they are naive datetime objects).
+
+- ``std::chrono::duration`` → ``datetime.timedelta``
+    Durations are converted to timedeltas, any precision in the duration
+    greater than microseconds is lost by rounding towards zero.
+
+- ``std::chrono::[other_clocks]::time_point`` → ``datetime.timedelta``
+    Any clock time that is not the system clock is converted to a time delta.
+    This timedelta measures the time from the clocks epoch to now.
+
+.. rubric:: Python to C++
+
+- ``datetime.datetime`` or ``datetime.date`` or ``datetime.time`` → ``std::chrono::system_clock::time_point``
+    Date/time objects are converted into system clock timepoints. Any
+    timezone information is ignored and the type is treated as a naive
+    object.
+
+- ``datetime.timedelta`` → ``std::chrono::duration``
+    Time delta are converted into durations with microsecond precision.
+
+- ``datetime.timedelta`` → ``std::chrono::[other_clocks]::time_point``
+    Time deltas that are converted into clock timepoints are treated as
+    the amount of time from the start of the clocks epoch.
+
+- ``float`` → ``std::chrono::duration``
+    Floats that are passed to C++ as durations be interpreted as a number of
+    seconds. These will be converted to the duration using ``duration_cast``
+    from the float.
+
+- ``float`` → ``std::chrono::[other_clocks]::time_point``
+    Floats that are passed to C++ as time points will be interpreted as the
+    number of seconds from the start of the clocks epoch.