3737b3723fd97bb0284fe37da43d665041a758f698eeb86f73a3901fcaeb33dc

third-party/DPVO/Pangolin/components/pango_geometry/src/geometry.cpp

@@ -0,0 +1,50 @@
+/* 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/geometry/geometry.h>
+#include <pangolin/geometry/geometry_ply.h>
+#include <pangolin/geometry/geometry_obj.h>
+#include <pangolin/utils/file_extension.h>
+#include <pangolin/utils/file_utils.h>
+
+namespace pangolin {
+
+// TODO: Replace this with proper factory registry
+pangolin::Geometry LoadGeometry(const std::string& filename)
+{
+    const std::string expanded_filename = PathExpand(filename);
+    const ImageFileType ft = FileType(expanded_filename);
+    if(ft == ImageFileTypePly) {
+        return LoadGeometryPly(expanded_filename);
+    }else if(ft == ImageFileTypeObj) {
+        return LoadGeometryObj(expanded_filename);
+    }else{
+        throw std::runtime_error("Unsupported geometry file type.");
+    }
+}
+
+}

third-party/DPVO/Pangolin/components/pango_geometry/src/geometry_obj.cpp

@@ -0,0 +1,252 @@
+/* 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 <unordered_set>
+
+#include <pangolin/geometry/geometry_obj.h>
+#include <tinyobj/tiny_obj_loader.h>
+#include <pangolin/utils/variadic_all.h>
+#include <pangolin/utils/simple_math.h>
+
+#include <pangolin/image/image_io.h>
+#include <pangolin/utils/file_utils.h>
+
+namespace std {
+
+template<>
+struct hash<tinyobj::index_t> {
+
+    std::size_t operator()(const tinyobj::index_t & t) const noexcept {
+        static std::hash<int> h;
+        return h(t.vertex_index) ^ h(t.normal_index) ^ h(t.texcoord_index);
+    }
+
+};
+
+} // namespace std
+
+namespace tinyobj {
+
+bool operator==(const index_t a, const index_t b) {
+    return a.vertex_index == b.vertex_index && a.normal_index == b.normal_index && a.texcoord_index == b.texcoord_index;
+}
+
+} // namespace tinyobj
+
+namespace pangolin {
+
+template<typename T>
+Geometry::Element ConvertVectorToGeometryElement(const std::vector<T>& v, size_t count_per_element, const std::string& attribute_name )
+{
+    PANGO_ASSERT(v.size() % count_per_element == 0);
+    const size_t num_elements = v.size() / count_per_element;
+
+    // Allocate buffer and copy into it
+    Geometry::Element el(sizeof(T) * count_per_element, num_elements);
+    el.CopyFrom(Image<T>(v.data(), count_per_element, num_elements));
+    el.attributes[attribute_name] = el.template UnsafeReinterpret<T>();
+    return el;
+}
+
+template<typename T>
+Image<T> GetImageWrapper(std::vector<T>& vec, size_t count_per_element)
+{
+    PANGO_ASSERT(vec.size() % count_per_element == 0);
+    if(vec.size()) {
+        return Image<T>(vec.data(), count_per_element, vec.size() / count_per_element, count_per_element * sizeof(T));
+    }else{
+        return Image<T>();
+    }
+}
+
+
+pangolin::Geometry LoadGeometryObj(const std::string& filename)
+{
+    pangolin::Geometry geom;
+
+    tinyobj::attrib_t attrib;
+    std::vector<tinyobj::shape_t> shapes;
+    std::vector<tinyobj::material_t> materials;
+
+    std::string warn;
+    std::string err;
+    if(tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, filename.c_str(), PathParent(filename).c_str())) {
+        PANGO_ASSERT(attrib.vertices.size() % 3 == 0);
+        PANGO_ASSERT(attrib.normals.size() % 3 == 0);
+        PANGO_ASSERT(attrib.colors.size() % 3 == 0);
+        PANGO_ASSERT(attrib.texcoords.size() % 2 == 0);
+
+        // Load textures - a bit of a hack for now.
+        for(size_t i=0; i < materials.size(); ++i) {
+            if(!materials[i].diffuse_texname.empty()) {
+              const std::string tex_name = FormatString("texture_%",i);
+              try {
+                TypedImage& tex_image = geom.textures[tex_name];
+                tex_image = LoadImage(PathParent(filename) + "/" + materials[i].diffuse_texname);
+                const int row_bytes = tex_image.w * tex_image.fmt.bpp / 8;
+                std::vector<unsigned char> tmp_row(row_bytes);
+                for (std::size_t y=0; y < (tex_image.h >> 1); ++y) {
+                    std::memcpy(tmp_row.data(), tex_image.RowPtr(y), row_bytes);
+                    std::memcpy(tex_image.RowPtr(y), tex_image.RowPtr(tex_image.h - 1 - y), row_bytes);
+                    std::memcpy(tex_image.RowPtr(tex_image.h - 1 - y), tmp_row.data(), row_bytes);
+                }
+              } catch(const std::exception& e) {
+                pango_print_warn("Unable to read texture '%s'\n", tex_name.c_str());
+                geom.textures.erase(tex_name);
+              }
+            }
+        }
+
+//        PANGO_ASSERT(all_of(
+//            [&](const size_t& v){return (v == 0) || (v == num_verts);},
+//            attrib.normals.size() / 3,
+//            attrib.colors.size() / 3));
+
+        // Get rid of color buffer if all elements are equal.
+        if ( std::adjacent_find( attrib.colors.begin(), attrib.colors.end(), std::not_equal_to<float>() ) == attrib.colors.end() )
+        {
+            attrib.colors.clear();
+        }
+
+        Image<float> tiny_vs = GetImageWrapper(attrib.vertices, 3);
+        Image<float> tiny_ns = GetImageWrapper(attrib.normals, 3);
+        Image<float> tiny_cs = GetImageWrapper(attrib.colors, 3);
+        Image<float> tiny_ts = GetImageWrapper(attrib.texcoords, 2);
+
+        // Some vertices are used with multiple texture coordinates or multiple normals, and will need to be split.
+        // First, we'll find the number of unique combinations of vertex, texture, and normal indices used, as each
+        // will result in a separate vertex in the buffers
+        std::unordered_map<tinyobj::index_t, std::size_t> reindex_map;
+
+        for(auto& shape : shapes) {
+
+            if(shape.mesh.indices.size() == 0) {
+                continue;
+            }
+
+            const size_t num_indices = shape.mesh.indices.size() ;
+
+            for(size_t i=0; i < num_indices; ++i) {
+
+                const tinyobj::index_t index = shape.mesh.indices[i];
+
+                if (reindex_map.find(index) == reindex_map.end()) {
+
+                    reindex_map.insert(std::pair<tinyobj::index_t, std::size_t>(index, reindex_map.size()));
+
+                }
+
+            }
+
+        }
+
+        const int num_unique_verts = reindex_map.size();
+
+        // Create unified verts attribute
+        auto& verts = geom.buffers["geometry"];
+        Image<float> new_vs, new_ns, new_cs, new_ts;
+        {
+            verts.Reinitialise(sizeof(float)*(tiny_vs.w + tiny_ns.w + tiny_cs.w + tiny_ts.w),num_unique_verts);
+            size_t float_offset = 0;
+            if(tiny_vs.IsValid()) {
+                new_vs = verts.UnsafeReinterpret<float>().SubImage(float_offset,0,3,num_unique_verts);
+                verts.attributes["vertex"] = new_vs;
+                float_offset += 3;
+                for (auto& el : reindex_map) {
+                    new_vs.Row(el.second).CopyFrom(tiny_vs.Row(el.first.vertex_index));
+                }
+            }
+            if(tiny_ns.IsValid()) {
+                new_ns = verts.UnsafeReinterpret<float>().SubImage(float_offset,0,3,num_unique_verts);
+                verts.attributes["normal"] = new_ns;
+                float_offset += 3;
+                for (auto& el : reindex_map) {
+                    new_ns.Row(el.second).CopyFrom(tiny_ns.Row(el.first.normal_index));
+                }
+            }
+            if(tiny_cs.IsValid()) {
+                new_cs = verts.UnsafeReinterpret<float>().SubImage(float_offset,0,3,num_unique_verts);
+                verts.attributes["color"] = new_cs;
+                float_offset += 3;
+                for (auto& el : reindex_map) {
+                    new_cs.Row(el.second).CopyFrom(tiny_cs.Row(el.first.vertex_index));
+                }
+            }
+            if(tiny_ts.IsValid()) {
+                new_ts = verts.UnsafeReinterpret<float>().SubImage(float_offset,0,2,num_unique_verts);
+                verts.attributes["uv"] = new_ts;
+                float_offset += 2;
+                for (auto& el : reindex_map) {
+                    new_ts.Row(el.second).CopyFrom(tiny_ts.Row(el.first.texcoord_index));
+                }
+            }
+            PANGO_ASSERT(float_offset * sizeof(float) == verts.w);
+        }
+
+        for(auto& shape : shapes) {
+            if(shape.mesh.indices.size() == 0) {
+                continue;
+            }
+
+            auto faces = geom.objects.emplace(shape.name, Geometry::Element());
+
+            if(std::all_of( shape.mesh.num_face_vertices.begin(), shape.mesh.num_face_vertices.end(),
+                [](unsigned char num){return num==3;}
+            )) {
+                // tri mesh
+                const size_t num_indices = shape.mesh.indices.size() ;
+                const size_t num_faces = shape.mesh.indices.size() / 3;
+                PANGO_ASSERT(num_indices % 3 == 0);
+
+                // Use vert_ibo as our new IBO
+                faces->second.Reinitialise(3*sizeof(uint32_t), num_faces);
+                Image<uint32_t> new_ibo = faces->second.UnsafeReinterpret<uint32_t>().SubImage(0,0,3,num_faces);
+                for(size_t f=0; f < num_faces; ++f) {
+                    for(size_t v=0; v < 3; ++v) {
+                        new_ibo(v,f) = reindex_map[shape.mesh.indices[3 * f + v]];
+                    }
+                }
+                faces->second.attributes["vertex_indices"] = new_ibo;
+
+            }else if(std::all_of( shape.mesh.num_face_vertices.begin(), shape.mesh.num_face_vertices.end(),
+                [](unsigned char num){return num==4;}
+            )) {
+                // Quad mesh
+                throw std::runtime_error("Do not support quad meshes yet.");
+            }else{
+                // ???
+                throw std::runtime_error("Do not support meshes with mixed triangles and quads.");
+            }
+        }
+    }else{
+        throw std::runtime_error(FormatString("Unable to load OBJ file '%'. Error: '%'", filename, err));
+    }
+
+    return geom;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_geometry/src/geometry_ply.cpp

@@ -0,0 +1,498 @@
+/* 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/geometry/geometry_ply.h>
+
+#include <pangolin/utils/file_utils.h>
+#include <pangolin/utils/variadic_all.h>
+#include <pangolin/utils/parse.h>
+#include <pangolin/utils/type_convert.h>
+#include <pangolin/utils/simple_math.h>
+#include <pangolin/image/image_io.h>
+
+namespace pangolin {
+
+#define FORMAT_STRING_LIST(x) #x,
+
+const char* PlyHeaderString[] = {
+   PLY_HEADER_LIST(FORMAT_STRING_LIST)
+};
+
+const char* PlyFormatString[] = {
+   PLY_FORMAT_LIST(FORMAT_STRING_LIST)
+};
+
+const char* PlyTypeString[] = {
+   PLY_TYPE_LIST(FORMAT_STRING_LIST)
+};
+
+#undef FORMAT_STRING_LIST
+
+PLY_GROUP_LIST(PANGOLIN_DEFINE_PARSE_TOKEN)
+
+void ParsePlyHeader(PlyHeaderDetails& ply, std::istream& is)
+{
+    // 'Active' element for property definitions.
+    int current_element = -1;
+
+    // Check header is correct
+    PlyHeader token = ParseTokenPlyHeader(is);
+    if( token != PlyHeader_ply) {
+        throw std::runtime_error("Bad PLY header magic.");
+    }
+    ConsumeToNewline(is);
+
+    while(is.good() && token != PlyHeader_end_header) {
+        token = ParseTokenPlyHeader(is);
+        switch (token) {
+        case PlyHeader_format:
+            // parse PLY format and version
+            ConsumeWhitespace(is);
+            ply.format = ParseTokenPlyFormat(is);
+            ConsumeWhitespace(is);
+            ply.version = ReadToken(is);
+            break;
+        case PlyHeader_element:
+        {
+            current_element = ply.elements.size();
+            PlyElementDetails el;
+            el.stride_bytes = 0;
+            ConsumeWhitespace(is);
+            el.name = ReadToken(is);
+            ConsumeWhitespace(is);
+            el.num_items = FromString<int>(ReadToken(is));
+            ply.elements.push_back(el);
+            break;
+        }
+        case PlyHeader_property:
+            if(current_element >= 0) {
+                PlyElementDetails& el = ply.elements[current_element];
+                PlyPropertyDetails prop;
+                ConsumeWhitespace(is);
+                const PlyType t = ParseTokenPlyType(is);
+                if( t == PlyType_list) {
+                    ConsumeWhitespace(is);
+                    const PlyType idtype = ParseTokenPlyType(is);
+                    ConsumeWhitespace(is);
+                    const PlyType itemtype = ParseTokenPlyType(is);
+                    prop.list_index_type = idtype;
+                    prop.type = itemtype;
+                    prop.offset_bytes = el.stride_bytes;
+                    prop.num_items = -1;
+                    el.stride_bytes = -1;
+                }else{
+                    prop.list_index_type = PlyType_none;
+                    prop.type = t;
+                    prop.offset_bytes = el.stride_bytes;
+                    prop.num_items = 1;
+                    const size_t size_bytes = PlyTypeSizeBytes[prop.type];
+                    if( el.stride_bytes >= 0) {
+                        el.stride_bytes += size_bytes;
+                    }
+                }
+                ConsumeWhitespace(is);
+                prop.name = ReadToken(is);
+                el.properties.push_back(prop);
+            }else{
+                pango_print_warn("PLY Parser: property declaration before element. Ignoring line.");
+            }
+            break;
+        case PlyHeader_comment:
+        case PlyHeader_end_header:
+            break;
+        default:
+            pango_print_warn("PLY Parser: Unknown token - ignoring line.");
+        }
+        ConsumeToNewline(is);
+    }
+}
+
+void ParsePlyAscii(pangolin::Geometry& /*geom*/, const PlyHeaderDetails& /*ply*/, std::istream& /*is*/)
+{
+    throw std::runtime_error("ASCII Ply loading not currently supported. Consider converting to binary.");
+}
+
+void AddVertexNormals(pangolin::Geometry& geom)
+{
+    auto it_geom = geom.buffers.find("geometry");
+    auto it_face = geom.objects.find("default");
+
+    if(it_geom != geom.buffers.end() && it_face != geom.objects.end())
+    {
+        const auto it_vbo = it_geom->second.attributes.find("vertex");
+        const auto it_ibo = it_face->second.attributes.find("vertex_indices");
+
+        if(it_vbo != it_geom->second.attributes.end() && it_ibo != it_face->second.attributes.end()) {
+            const auto& ibo = std::get<Image<uint32_t>>(it_ibo->second);
+            const auto& vbo = std::get<Image<float>>(it_vbo->second);
+
+            // Assume we have triangles.
+            PANGO_ASSERT(ibo.w == 3 && vbo.w == 3);
+
+            ManagedImage<float> vert_normals(3, vbo.h);
+            ManagedImage<size_t> vert_face_count(1, vbo.h);
+            vert_normals.Fill(0.0f);
+            vert_face_count.Fill(0);
+
+            float ab[3];
+            float ac[3];
+            float fn[3];
+
+            for(size_t i=0; i < ibo.h; ++i) {
+                uint32_t i0 = ibo(0,i);
+                uint32_t i1 = ibo(1,i);
+                uint32_t i2 = ibo(2,i);
+                MatSub<3,1>(ab, vbo.RowPtr(i1), vbo.RowPtr(i0));
+                MatSub<3,1>(ac, vbo.RowPtr(i2), vbo.RowPtr(i0));
+                VecCross3(fn, ab, ac);
+                Normalise<3>(fn);
+                for(size_t v=0; v < 3; ++v) {
+                    MatAdd<3,1>(vert_normals.RowPtr(ibo(v,i)), vert_normals.RowPtr(ibo(v,i)), fn);
+                    ++vert_face_count(0,ibo(v,i));
+                }
+            }
+
+            for(size_t v=0; v < vert_normals.h; ++v) {
+                // Compute average
+                MatMul<3,1>(vert_normals.RowPtr(v), 1.0f / vert_face_count(0,v));
+            }
+
+            auto& el = geom.buffers["normal"];
+            (ManagedImage<float>&)el = std::move(vert_normals);
+            auto& attr_norm = el.attributes["normal"];
+            attr_norm = Image<float>((float*)el.ptr, 3, el.h, el.pitch);
+        }
+    }
+
+}
+
+void StandardizeXyzToVertex(pangolin::Geometry& geom)
+{
+    auto it_verts = geom.buffers.find("geometry");
+
+    if(it_verts != geom.buffers.end()) {
+        auto& verts = it_verts->second;
+        auto it_x = verts.attributes.find("x");
+        auto it_y = verts.attributes.find("y");
+        auto it_z = verts.attributes.find("z");
+        if(all_found(verts.attributes, it_x, it_y, it_z)) {
+            if(verts.attributes.find("vertex") == verts.attributes.end()) {
+                auto& vertex = verts.attributes["vertex"];
+                auto& imx = std::get<Image<float>>(it_x->second);
+                auto& imy = std::get<Image<float>>(it_y->second);
+                auto& imz = std::get<Image<float>>(it_z->second);
+
+                if(imx.ptr + 1 == imy.ptr && imy.ptr + 1 == imz.ptr) {
+                    vertex = Image<float>((float*)imx.ptr, 3, verts.h, imx.pitch);
+                }else{
+                    throw std::runtime_error("Ooops");
+                }
+            }
+            verts.attributes.erase(it_x);
+            verts.attributes.erase(it_y);
+            verts.attributes.erase(it_z);
+        }
+    }
+}
+
+void StandardizeRgbToColor(pangolin::Geometry& geom)
+{
+    auto it_verts = geom.buffers.find("geometry");
+
+    if(it_verts != geom.buffers.end()) {
+        auto& verts = it_verts->second;
+        auto it_r = verts.attributes.find("r");
+        auto it_g = verts.attributes.find("g");
+        auto it_b = verts.attributes.find("b");
+        auto it_a = verts.attributes.find("a");
+
+        if(!all_found(verts.attributes, it_r, it_b, it_g)) {
+            it_r = verts.attributes.find("red");
+            it_g = verts.attributes.find("green");
+            it_b = verts.attributes.find("blue");
+            it_a = verts.attributes.find("alpha");
+        }
+
+        if(all_found(verts.attributes, it_r, it_g, it_b)) {
+            const bool have_alpha = it_a != verts.attributes.end();
+
+            if(verts.attributes.find("color") == verts.attributes.end()) {
+                Geometry::Element::Attribute& red = it_r->second;
+                Geometry::Element::Attribute& color = verts.attributes["color"];
+
+                // TODO: Check that these really are contiguous in memory...
+                if(auto attrib = std::get_if<Image<float>>(&red)) {
+                    color = Image<float>(attrib->ptr, have_alpha ? 4 : 3, verts.h, verts.pitch);
+                }else if(auto attrib = std::get_if<Image<uint8_t>>(&red)) {
+                    color = Image<uint8_t>(attrib->ptr, have_alpha ? 4 : 3, verts.h, verts.pitch);
+                }else if(auto attrib = std::get_if<Image<uint16_t>>(&red)) {
+                    color = Image<uint16_t>(attrib->ptr, have_alpha ? 4 : 3, verts.h, verts.pitch);
+                }else if(auto attrib = std::get_if<Image<uint32_t>>(&red)) {
+                    color = Image<uint32_t>(attrib->ptr, have_alpha ? 4 : 3, verts.h, verts.pitch);
+                }
+            }
+            verts.attributes.erase(it_r);
+            verts.attributes.erase(it_g);
+            verts.attributes.erase(it_b);
+            if(have_alpha) verts.attributes.erase(it_a);
+        }
+    }
+}
+
+void StandardizeMultiTextureFaceToXyzuv(pangolin::Geometry& geom)
+{
+    const auto it_multi_texture_face = geom.buffers.find("multi_texture_face");
+    const auto it_multi_texture_vertex = geom.buffers.find("multi_texture_vertex");
+    const auto it_geom = geom.buffers.find("geometry");
+    const auto it_face = geom.objects.find("default");
+
+    if(it_geom != geom.buffers.end() && it_face != geom.objects.end())
+    {
+        const auto it_vbo = it_geom->second.attributes.find("vertex");
+        const auto it_ibo = it_face->second.attributes.find("vertex_indices");
+
+        if(all_found(geom.buffers, it_multi_texture_face, it_multi_texture_vertex) &&
+                it_vbo != it_geom->second.attributes.end() &&
+                it_ibo != it_face->second.attributes.end()
+        ) {
+            const auto it_uv_ibo = it_multi_texture_face->second.attributes.find("texture_vertex_indices");
+            const auto it_tx = it_multi_texture_face->second.attributes.find("tx");
+            const auto it_tn = it_multi_texture_face->second.attributes.find("tn");
+
+            const auto it_u = it_multi_texture_vertex->second.attributes.find("u");
+            const auto it_v = it_multi_texture_vertex->second.attributes.find("v");
+
+            if(all_found(it_multi_texture_vertex->second.attributes, it_u, it_v) &&
+                    it_uv_ibo != it_multi_texture_face->second.attributes.end()
+            ) {
+                // We're going to create a new vertex buffer to hold uv's too
+                auto& orig_ibo = std::get<Image<uint32_t>>(it_ibo->second);
+                const auto& orig_xyz = std::get<Image<float>>(it_vbo->second);
+                const auto& uv_ibo = std::get<Image<uint32_t>>(it_uv_ibo->second);
+                const auto& u = std::get<Image<float>>(it_u->second);
+                const auto& v = std::get<Image<float>>(it_v->second);
+                const auto& tx = std::get<Image<uint8_t>>(it_tx->second);
+                const auto& tn = std::get<Image<uint32_t>>(it_tn->second);
+
+                PANGO_ASSERT(u.h == v.h);
+                PANGO_ASSERT(orig_ibo.w == 3 && uv_ibo.w == 3);
+
+                pangolin::Geometry::Element new_xyzuv(5*sizeof(float), u.h);
+                Image<float> new_xyz = new_xyzuv.UnsafeReinterpret<float>().SubImage(0,0,3,new_xyzuv.h);
+                Image<float> new_uv = new_xyzuv.UnsafeReinterpret<float>().SubImage(3,0,2,new_xyzuv.h);
+                new_xyzuv.attributes["vertex"] = new_xyz;
+                new_xyzuv.attributes["uv"] = new_uv;
+
+                for(size_t face=0; face < orig_ibo.h; ++face) {
+                    uint32_t vtn = tn(0,face);
+                    uint8_t vtx = tx(0,face);
+                    PANGO_ASSERT(vtx==0, "Haven't implemented multi-texture yet.");
+
+                    for(size_t vert=0; vert < 3; ++vert)
+                    {
+                        uint32_t& orig_xyz_index = orig_ibo(vert,vtn);
+                        const uint32_t uv_index = uv_ibo(vert,face);
+                        PANGO_ASSERT(uv_index < new_xyzuv.h && orig_xyz_index < orig_xyz.h);
+
+                        for(int el=0; el < 3; ++el) {
+                            new_xyz(el,uv_index) = orig_xyz(el,orig_xyz_index);
+                        }
+                        new_uv(0,uv_index) = u(0,uv_index);
+                        new_uv(1,uv_index) = v(0,uv_index);
+                        orig_xyz_index = uv_index;
+                    }
+                }
+
+                geom.buffers["geometry"] = std::move(new_xyzuv);
+                geom.buffers.erase(it_multi_texture_face);
+                geom.buffers.erase(it_multi_texture_vertex);
+            }
+
+        }
+    }
+}
+
+void Standardize(pangolin::Geometry& geom)
+{
+    StandardizeXyzToVertex(geom);
+    StandardizeRgbToColor(geom);
+    StandardizeMultiTextureFaceToXyzuv(geom);
+    AddVertexNormals(geom);
+}
+
+inline int ReadGlIntType(PlyType type, std::istream& is)
+{
+    // TODO: This seems really dodgey...
+    // int may not be big enough and if the datatype is smaller will it be padded?
+    int v = 0;
+    is.read( (char*)&v, PlyTypeSizeBytes[type]);
+    return v;
+}
+
+inline void ReadInto(std::vector<unsigned char>& vec, std::istream& is, size_t num_bytes)
+{
+    const size_t current_size = vec.size();
+    vec.resize(current_size + num_bytes);
+    is.read((char*)vec.data() + current_size, num_bytes);
+}
+
+void ParsePlyLE(pangolin::Geometry& geom, PlyHeaderDetails& ply, std::istream& is)
+{
+    std::vector<uint8_t> buffer;
+
+    for(auto& el : ply.elements) {
+        pangolin::Geometry::Element geom_el;
+
+        if(el.stride_bytes > 0) {
+            // This will usually be the case for vertex buffers with a known number of attributes
+            PANGO_ASSERT(el.num_items > 0);
+            geom_el.Reinitialise(el.stride_bytes, el.num_items);
+            is.read((char*)geom_el.ptr, geom_el.Area());
+        }else {
+            // This will generally be the case for face data (containing a list of vertex indices)
+
+            // Reserve enough space for a list of quads
+            buffer.clear();
+            buffer.reserve(el.num_items * el.properties.size() * 4);
+
+            for(int i=0; i< el.num_items; ++i) {
+                size_t offset_bytes = 0;
+                for(auto& prop : el.properties) {
+                    if(prop.isList()) {
+                        const int list_items = ReadGlIntType(prop.list_index_type, is);
+                        if(prop.num_items == -1) {
+                            prop.num_items = list_items;
+                            prop.offset_bytes = offset_bytes;
+                        }else{
+                            PANGO_ASSERT(prop.num_items == list_items);
+                        }
+                    }
+                    const size_t num_bytes = prop.num_items * PlyTypeSizeBytes[prop.type];
+                    ReadInto(buffer, is, num_bytes);
+                    offset_bytes += num_bytes;
+                }
+            }
+
+            // Update element stride now we know
+            el.stride_bytes = 0;
+            for(auto& prop : el.properties) {
+                el.stride_bytes += prop.num_items * PlyTypeSizeBytes[prop.type];
+            }
+
+            geom_el.Reinitialise(el.stride_bytes, el.num_items);
+            PANGO_ASSERT(geom_el.SizeBytes() == buffer.size());
+            std::memcpy(geom_el.ptr, buffer.data(), buffer.size());
+        }
+
+        for(auto& prop : el.properties) {
+            Image<uint8_t> attrib(geom_el.ptr + prop.offset_bytes, prop.num_items, el.num_items, geom_el.pitch);
+            switch (prop.type) {
+            case PlyType_char:
+            case PlyType_uchar:
+                geom_el.attributes[prop.name] = attrib.UnsafeReinterpret<uint8_t>();
+                break;
+            case PlyType_short:
+            case PlyType_ushort:
+                geom_el.attributes[prop.name] = attrib.UnsafeReinterpret<uint16_t>();
+                break;
+            case PlyType_int:
+            case PlyType_uint:
+                geom_el.attributes[prop.name] = attrib.UnsafeReinterpret<uint32_t>();
+                break;
+            case PlyType_float:
+                geom_el.attributes[prop.name] = attrib.UnsafeReinterpret<float>();
+                break;
+            default:
+                throw std::runtime_error("Unsupported PLY data type");
+            }
+        }
+        if(el.name == "vertex") {
+            geom.buffers["geometry"] = std::move(geom_el);
+        }else if(el.name == "face") {
+            geom.objects.emplace("default", std::move(geom_el));
+        }else{
+            geom.buffers[el.name] = std::move(geom_el);
+        }
+    }
+
+    Standardize(geom);
+}
+
+void ParsePlyBE(pangolin::Geometry& /*geom*/, const PlyHeaderDetails& /*ply*/, std::istream& /*is*/)
+{
+    throw std::runtime_error("Not implemented.");
+}
+
+void AttachAssociatedTexturesPly(pangolin::Geometry& geom, const std::string& filename)
+{
+    // For PLY, texture names are generally implicit
+    auto dot = filename.find_last_of('.');
+    if(dot != filename.npos) {
+        const std::string base = filename.substr(0, dot);
+        for(int i=0; i < 10; ++i) {
+            const std::string glob = FormatString("%_%.*", base, i);
+            std::vector<std::string> file_vec;
+            if(FilesMatchingWildcard(glob, file_vec)) {
+                for(const auto& file : file_vec) {
+                    try {
+                        geom.textures[FormatString("texture_%",i)] = LoadImage(file);
+                        break;
+                    }catch(std::runtime_error&)
+                    {
+                    }
+                }
+            }
+        }
+    }
+}
+
+pangolin::Geometry LoadGeometryPly(const std::string& filename)
+{
+    std::ifstream bFile( filename.c_str(), std::ios::in | std::ios::binary );
+    if( !bFile.is_open() ) throw std::runtime_error("Unable to open PLY file: " + filename);
+
+    PlyHeaderDetails ply;
+    ParsePlyHeader(ply, bFile);
+
+    // Initialise geom object
+    pangolin::Geometry geom;
+
+    // Fill in geometry from file.
+    if(ply.format == PlyFormat_ascii) {
+        ParsePlyAscii(geom, ply, bFile);
+    }else if(ply.format == PlyFormat_binary_little_endian) {
+        ParsePlyLE(geom, ply, bFile);
+    }else if(ply.format == PlyFormat_binary_big_endian) {
+        ParsePlyBE(geom, ply, bFile);
+    }
+
+    AttachAssociatedTexturesPly(geom, filename);
+
+    return geom;
+}
+
+}

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

@@ -0,0 +1,15 @@
+get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME)
+
+target_sources( ${COMPONENT}
+PRIVATE
+    ${CMAKE_CURRENT_LIST_DIR}/src/glgeometry.cpp
+)
+
+target_link_libraries(${COMPONENT} pango_geometry pango_opengl)
+target_include_directories(${COMPONENT} PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
+install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/include"
+  DESTINATION ${CMAKE_INSTALL_PREFIX}
+)

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

@@ -0,0 +1,87 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/geometry/geometry.h>
+#include <pangolin/gl/gl.h>
+#include <pangolin/gl/glsl.h>
+
+namespace pangolin {
+
+struct GlGeometry
+{
+    GlGeometry() = default;
+    GlGeometry(GlGeometry&&) = default;
+    GlGeometry& operator=(GlGeometry&&) = default;
+
+    struct Element : public GlBufferData
+    {
+        Element() = default;
+        Element(Element&&) = default;
+        Element& operator=(Element&&) = default;
+
+        Element(GlBufferType buffer_type, size_t size_bytes, GLenum gluse, uint8_t* data)
+            : GlBufferData(buffer_type, size_bytes, gluse, data)
+        {}
+
+        inline bool HasAttribute(const std::string& name) const {
+            return attributes.find(name) != attributes.end();
+        }
+
+        struct Attribute {
+            // Stuff needed by glVertexAttribPointer
+            GLenum gltype;
+            size_t count_per_element;
+            size_t num_elements;
+            size_t offset;
+            size_t stride_bytes;
+        };
+        std::map<std::string, Attribute> attributes;
+    };
+
+    inline bool HasAttribute(const std::string& name) const
+    {
+        for(const auto& b : buffers) if(b.second.HasAttribute(name)) return true;
+        return false;
+    }
+
+    // Store vertices and attributes
+    std::map<std::string, Element> buffers;
+    // Stores index buffers for each sub-object
+    std::multimap<std::string, Element> objects;
+    // Stores pixmaps
+    std::map<std::string, GlTexture> textures;
+};
+
+GlGeometry::Element ToGlGeometry(const Geometry::Element& el, GlBufferType buffertype);
+
+GlGeometry ToGlGeometry(const Geometry& geom);
+
+void GlDraw(GlSlProgram& prog, const GlGeometry& geom, const GlTexture *matcap);
+
+}

third-party/DPVO/Pangolin/components/pango_glgeometry/src/glgeometry.cpp

@@ -0,0 +1,142 @@
+/* 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/geometry/glgeometry.h>
+
+#include <pangolin/gl/glformattraits.h>
+
+namespace pangolin {
+
+GlGeometry::Element ToGlGeometryElement(const Geometry::Element& el, GlBufferType buffertype)
+{
+    GlGeometry::Element glel(buffertype, el.SizeBytes(), GL_STATIC_DRAW, el.ptr );
+    for(const auto& attrib_variant : el.attributes) {
+        visit([&](auto&& attrib){
+            using T = std::decay_t<decltype(attrib)>;
+            auto& glattrib = glel.attributes[attrib_variant.first];
+            glattrib.gltype = GlFormatTraits<typename T::PixelType>::gltype;
+            glattrib.count_per_element = attrib.w;
+            glattrib.num_elements = attrib.h;
+            glattrib.offset = (uint8_t*)attrib.ptr - el.ptr;
+            glattrib.stride_bytes = attrib.pitch;
+        }, attrib_variant.second);
+    }
+    return glel;
+}
+
+GlGeometry ToGlGeometry(const Geometry& geom)
+{
+    GlGeometry gl;
+    for(const auto& b : geom.buffers)
+        gl.buffers[b.first] = ToGlGeometryElement(b.second, GlArrayBuffer);
+
+    for(const auto& b : geom.objects)
+        gl.objects.emplace(b.first, ToGlGeometryElement(b.second, GlElementArrayBuffer));
+
+    for(const auto& tex : geom.textures) {
+        auto& gltex = gl.textures[tex.first];
+        gltex.Load(tex.second);
+    }
+    return gl;
+}
+
+void BindGlElement(GlSlProgram& prog, const GlGeometry::Element& el)
+{
+    el.Bind();
+    for(auto& a : el.attributes) {
+        const GLint attrib_handle = prog.GetAttributeHandle(a.first);
+        const GlGeometry::Element::Attribute& attr = a.second;
+        if(attrib_handle >= 0) {
+            glEnableVertexAttribArray(attrib_handle);
+            glVertexAttribPointer(
+                attrib_handle, attr.count_per_element, attr.gltype, GL_TRUE,
+                attr.stride_bytes,
+                reinterpret_cast<uint8_t*>(attr.offset)
+            );
+        }
+    }
+}
+
+void UnbindGlElements(GlSlProgram& prog, const GlGeometry::Element& el)
+{
+    for(auto& a : el.attributes) {
+        const GLint attrib_handle = prog.GetAttributeHandle(a.first);
+        if(attrib_handle >= 0) {
+            glDisableVertexAttribArray(attrib_handle);
+        }
+    }
+    el.Unbind();
+}
+
+void GlDraw(GlSlProgram& prog, const GlGeometry& geom, const GlTexture* matcap)
+{
+    // Bind textures
+    int num_tex_bound = 0;
+    for(auto& tex : geom.textures) {
+        glActiveTexture(GL_TEXTURE0 + num_tex_bound);
+        tex.second.Bind();
+        prog.SetUniform(tex.first, (int)num_tex_bound);
+        ++num_tex_bound;
+    }
+
+    if(matcap) {
+        glActiveTexture(GL_TEXTURE0 + num_tex_bound);
+        matcap->Bind();
+        prog.SetUniform("matcap", (int)num_tex_bound);
+        ++num_tex_bound;
+    }
+
+    // Bind all attribute buffers
+    for(auto& buffer : geom.buffers) {
+        BindGlElement(prog, buffer.second);
+    }
+
+    // Draw all geometry
+    for(auto& buffer : geom.objects) {
+        auto it_indices = buffer.second.attributes.find("vertex_indices");
+        if(it_indices != buffer.second.attributes.end()) {
+            buffer.second.Bind();
+            auto& attrib = it_indices->second;
+            glDrawElements(
+               GL_TRIANGLES, attrib.count_per_element * attrib.num_elements,
+               attrib.gltype, reinterpret_cast<uint8_t*>(attrib.offset)
+            );
+            buffer.second.Unbind();
+        }
+    }
+
+    // Unbind attribute buffers
+    for(auto& buffer : geom.buffers) {
+        UnbindGlElements(prog, buffer.second);
+    }
+
+    // Unbind textures
+    glBindTexture(GL_TEXTURE_2D, 0);
+    glActiveTexture(GL_TEXTURE0);
+}
+
+}

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

@@ -0,0 +1,112 @@
+get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME)
+
+option(BUILD_PANGOLIN_LIBPNG "Build support for libpng image input" ON)
+if(BUILD_PANGOLIN_LIBPNG)
+    find_package(PNG QUIET)
+    if(PNG_FOUND)
+        target_compile_definitions(${COMPONENT} PRIVATE HAVE_PNG)
+        target_include_directories(${COMPONENT} PRIVATE ${PNG_INCLUDE_DIR} )
+        target_link_libraries(${COMPONENT} PRIVATE ${PNG_LIBRARY} ${ZLIB_LIBRARY})
+        message(STATUS "libpng Found and Enabled")
+    endif()
+endif()
+
+option(BUILD_PANGOLIN_LIBJPEG "Build support for libjpeg image input" ON)
+if(BUILD_PANGOLIN_LIBJPEG)
+    find_package(JPEG QUIET)
+    if(JPEG_FOUND)
+        target_compile_definitions(${COMPONENT} PRIVATE HAVE_JPEG)
+        target_include_directories(${COMPONENT} PRIVATE ${JPEG_INCLUDE_DIR} )
+        target_link_libraries(${COMPONENT} PRIVATE ${JPEG_LIBRARY})
+        message(STATUS "libjpeg Found and Enabled")
+    endif()
+endif()
+
+option(BUILD_PANGOLIN_LIBTIFF "Build support for libtiff image input" ON)
+if(BUILD_PANGOLIN_LIBTIFF)
+    find_package(TIFF QUIET)
+    if(TIFF_FOUND)
+        target_compile_definitions(${COMPONENT} PRIVATE HAVE_LIBTIFF)
+        target_include_directories(${COMPONENT} PRIVATE ${TIFF_INCLUDE_DIR} )
+        target_link_libraries(${COMPONENT} PRIVATE ${TIFF_LIBRARY})
+        message(STATUS "libtiff Found and Enabled")
+    endif()
+endif()
+
+option(BUILD_PANGOLIN_LIBOPENEXR "Build support for libopenexr image input" ON)
+if(BUILD_PANGOLIN_LIBOPENEXR)
+    find_package(OpenEXR QUIET)
+    if(OpenEXR_FOUND)
+        target_compile_definitions(${COMPONENT} PRIVATE HAVE_OPENEXR)
+        target_include_directories(${COMPONENT} PRIVATE ${OpenEXR_INCLUDE_DIR} )
+        target_link_libraries(${COMPONENT} PRIVATE ${OpenEXR_LIBRARY})
+        target_compile_options(${COMPONENT} PRIVATE
+            $<$<OR:$<CXX_COMPILER_ID:AppleClang>,$<CXX_COMPILER_ID:Clang>,$<CXX_COMPILER_ID:GNU>>:
+            -Wno-deprecated-register -Wno-deprecated>
+        )
+        # https://github.com/stevenlovegrove/Pangolin/issues/677
+        set_target_properties(${COMPONENT} PROPERTIES CXX_STANDARD 11)
+        message(STATUS "libopenexr Found and Enabled")
+    endif()
+endif()
+
+option(BUILD_PANGOLIN_LZ4 "Build support for liblz4 compression" ON)
+if(BUILD_PANGOLIN_LZ4)
+    find_package(Lz4 QUIET)
+    if(Lz4_FOUND)
+        target_compile_definitions(${COMPONENT} PRIVATE HAVE_LZ4)
+        target_include_directories(${COMPONENT} PRIVATE ${Lz4_INCLUDE_DIRS} )
+        target_link_libraries(${COMPONENT} PRIVATE ${Lz4_LIBRARIES})
+        message(STATUS "liblz4 Found and Enabled")
+    endif()
+endif()
+
+option(BUILD_PANGOLIN_ZSTD "Build support for libzstd compression" ON)
+if(BUILD_PANGOLIN_ZSTD)
+    find_package(zstd QUIET)
+    if(zstd_FOUND)
+        target_compile_definitions(${COMPONENT} PRIVATE HAVE_ZSTD)
+        target_include_directories(${COMPONENT} PRIVATE ${zstd_INCLUDE_DIR} )
+        target_link_libraries(${COMPONENT} PRIVATE ${zstd_LIBRARY})
+        message(STATUS "libzstd Found and Enabled")
+    endif()
+endif()
+
+option(BUILD_PANGOLIN_LIBRAW "Build support for raw images (libraw)" ON)
+if(BUILD_PANGOLIN_LIBRAW)
+    find_package(libraw QUIET)
+    if(libraw_FOUND)
+        target_compile_definitions(${COMPONENT} PRIVATE HAVE_LIBRAW)
+        target_include_directories(${COMPONENT} PRIVATE ${libraw_INCLUDE_DIR} )
+        target_link_libraries(${COMPONENT} PRIVATE ${libraw_LIBRARIES})
+        message(STATUS "libraw Found and Enabled")
+    endif()
+endif()
+
+target_sources( ${COMPONENT}
+PRIVATE
+    ${CMAKE_CURRENT_LIST_DIR}/src/pixel_format.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/image_io.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/image_io_exr.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/image_io_jpg.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/image_io_lz4.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/image_io_packed12bit.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/image_io_pango.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/image_io_png.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/image_io_ppm.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/image_io_raw.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/image_io_tga.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/image_io_bmp.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/image_io_zstd.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/image_io_libraw.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/image_io_tiff.cpp
+)
+
+target_link_libraries(${COMPONENT} PUBLIC pango_core)
+target_include_directories(${COMPONENT} PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
+install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/include"
+  DESTINATION ${CMAKE_INSTALL_PREFIX}
+)

third-party/DPVO/Pangolin/components/pango_image/include/pangolin/image/copy.h

@@ -0,0 +1,45 @@
+/* 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
+
+namespace pangolin {
+
+// Hold a reference to an object to be copied
+template<typename T>
+struct CopyObject {
+    CopyObject(const T& obj) : obj(obj) { }
+    const T& obj;
+};
+
+// Return copy wrapper for assignment to another object.
+template<typename T>
+typename pangolin::CopyObject<T> Copy(const T& obj) {
+    return typename pangolin::CopyObject<T>(obj);
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/include/pangolin/image/image.h

@@ -0,0 +1,428 @@
+/* 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/image/memcpy.h>
+
+#include <cstddef>
+#include <functional>
+#include <limits>
+#include <cstring>
+
+#ifdef PANGO_ENABLE_BOUNDS_CHECKS
+#   define PANGO_BOUNDS_ASSERT(...) PANGO_ENSURE(##__VA_ARGS__)
+#else
+#   define PANGO_BOUNDS_ASSERT(...) ((void)0)
+#endif
+
+// Allow user defined macro to be inserted into Image class.
+#ifndef PANGO_EXTENSION_IMAGE
+#  define PANGO_EXTENSION_IMAGE
+#endif
+
+namespace pangolin
+{
+
+// Simple image wrapper
+template<typename T>
+struct Image
+{
+    using PixelType = T;
+
+    inline Image()
+        : pitch(0), ptr(0), w(0), h(0)
+    {
+    }
+
+    inline Image(T* ptr, size_t w, size_t h, size_t pitch)
+        : pitch(pitch), ptr(ptr), w(w), h(h)
+    {
+    }
+
+
+    PANGO_HOST_DEVICE inline
+    size_t SizeBytes() const
+    {
+        return pitch * h;
+    }
+    
+    PANGO_HOST_DEVICE inline
+    size_t Area() const
+    {
+        return w * h;
+    }
+
+    PANGO_HOST_DEVICE inline
+    bool IsValid() const
+    {
+        return ptr != 0;
+    }
+
+    PANGO_HOST_DEVICE inline
+    bool IsContiguous() const
+    {
+        return w*sizeof(T) == pitch;
+    }
+
+    //////////////////////////////////////////////////////
+    // Iterators
+    //////////////////////////////////////////////////////
+
+    PANGO_HOST_DEVICE inline
+    T* begin()
+    {
+        return ptr;
+    }
+
+    PANGO_HOST_DEVICE inline
+    T* end()
+    {
+        return RowPtr(h-1) + w;
+    }
+
+    PANGO_HOST_DEVICE inline
+    const T* begin() const
+    {
+        return ptr;
+    }
+
+    PANGO_HOST_DEVICE inline
+    const T* end() const
+    {
+        return RowPtr(h-1) + w;
+    }
+
+    PANGO_HOST_DEVICE inline
+    size_t size() const
+    {
+        return w*h;
+    }
+
+    //////////////////////////////////////////////////////
+    // Image transforms
+    //////////////////////////////////////////////////////
+
+    template<typename UnaryOperation>
+    PANGO_HOST_DEVICE inline
+    void Transform(UnaryOperation unary_op)
+    {
+        PANGO_ASSERT(IsValid());
+
+        for(size_t y=0; y < h; ++y) {
+            T* el = RowPtr(y);
+            const T* el_end = el+w;
+            for( ; el != el_end; ++el) {
+                *el = unary_op(*el);
+            }
+        }
+    }
+
+    PANGO_HOST_DEVICE inline
+    void Fill(const T& val)
+    {
+        Transform( [&](const T&) {return val;} );
+    }
+
+    PANGO_HOST_DEVICE inline
+    void Replace(const T& oldval, const T& newval)
+    {
+        Transform( [&](const T& val) {
+            return (val == oldval) ? newval : val;
+        });
+    }
+
+    inline
+    void Memset(unsigned char v = 0)
+    {
+        PANGO_ASSERT(IsValid());
+        if(IsContiguous()) {
+            ::pangolin::Memset((char*)ptr, v, pitch*h);
+        }else{
+            for(size_t y=0; y < h; ++y) {
+                ::pangolin::Memset((char*)RowPtr(y), v, pitch);
+            }
+        }
+    }
+
+    inline
+    void CopyFrom(const Image<T>& img)
+    {
+        if(IsValid() && img.IsValid()) {
+            PANGO_ASSERT(w >= img.w && h >= img.h);
+            PitchedCopy((char*)ptr,pitch,(char*)img.ptr,img.pitch, std::min(img.w,w)*sizeof(T), std::min(img.h,h) );
+        }else if( img.IsValid() != IsValid() ){
+            PANGO_ASSERT(false && "Cannot copy from / to an unasigned image." );
+        }
+    }
+
+    //////////////////////////////////////////////////////
+    // Reductions
+    //////////////////////////////////////////////////////
+
+    template<typename BinaryOperation>
+    PANGO_HOST_DEVICE inline
+    T Accumulate(const T init, BinaryOperation binary_op)
+    {
+        PANGO_ASSERT(IsValid());
+
+        T val = init;
+        for(size_t y=0; y < h; ++y) {
+            T* el = RowPtr(y);
+            const T* el_end = el+w;
+            for(; el != el_end; ++el) {
+                val = binary_op(val, *el);
+            }
+        }
+        return val;
+    }
+
+    std::pair<T,T> MinMax() const
+    {
+        PANGO_ASSERT(IsValid());
+
+        std::pair<T,T> minmax(std::numeric_limits<T>::max(), std::numeric_limits<T>::lowest());
+        for(size_t r=0; r < h; ++r) {
+            const T* ptr = RowPtr(r);
+            const T* end = ptr + w;
+            while( ptr != end) {
+                minmax.first  = std::min(*ptr, minmax.first);
+                minmax.second = std::max(*ptr, minmax.second);
+                ++ptr;
+            }
+        }
+        return minmax;
+    }
+
+    template<typename Tout=T>
+    Tout Sum() const
+    {
+        return Accumulate((T)0, [](const T& lhs, const T& rhs){ return lhs + rhs; });
+    }
+
+    template<typename Tout=T>
+    Tout Mean() const
+    {
+        return Sum<Tout>() / Area();
+    }
+
+
+    //////////////////////////////////////////////////////
+    // Direct Pixel Access
+    //////////////////////////////////////////////////////
+
+    PANGO_HOST_DEVICE inline
+    T* RowPtr(size_t y)
+    {
+        return (T*)((unsigned char*)(ptr) + y*pitch);
+    }
+
+    PANGO_HOST_DEVICE inline
+    const T* RowPtr(size_t y) const
+    {
+        return (T*)((unsigned char*)(ptr) + y*pitch);
+    }
+
+    PANGO_HOST_DEVICE inline
+    T& operator()(size_t x, size_t y)
+    {
+        PANGO_BOUNDS_ASSERT( InBounds(x,y) );
+        return RowPtr(y)[x];
+    }
+
+    PANGO_HOST_DEVICE inline
+    const T& operator()(size_t x, size_t y) const
+    {
+        PANGO_BOUNDS_ASSERT( InBounds(x,y) );
+        return RowPtr(y)[x];
+    }
+
+    template<typename TVec>
+    PANGO_HOST_DEVICE inline
+    T& operator()(const TVec& p)
+    {
+        PANGO_BOUNDS_ASSERT( InBounds(p[0],p[1]) );
+        return RowPtr(p[1])[p[0]];
+    }
+
+    template<typename TVec>
+    PANGO_HOST_DEVICE inline
+    const T& operator()(const TVec& p) const
+    {
+        PANGO_BOUNDS_ASSERT( InBounds(p[0],p[1]) );
+        return RowPtr(p[1])[p[0]];
+    }
+
+    PANGO_HOST_DEVICE inline
+    T& operator[](size_t ix)
+    {
+        PANGO_BOUNDS_ASSERT( InImage(ptr+ix) );
+        return ptr[ix];
+    }
+
+    PANGO_HOST_DEVICE inline
+    const T& operator[](size_t ix) const
+    {
+        PANGO_BOUNDS_ASSERT( InImage(ptr+ix) );
+        return ptr[ix];
+    }
+
+    //////////////////////////////////////////////////////
+    // Bounds Checking
+    //////////////////////////////////////////////////////
+
+    PANGO_HOST_DEVICE
+    bool InImage(const T* ptest) const
+    {
+        return ptr <= ptest && ptest < RowPtr(h);
+    }
+
+    PANGO_HOST_DEVICE inline
+    bool InBounds(int x, int y) const
+    {
+        return 0 <= x && x < (int)w && 0 <= y && y < (int)h;
+    }
+
+    PANGO_HOST_DEVICE inline
+    bool InBounds(float x, float y, float border) const
+    {
+        return border <= x && x < (w-border) && border <= y && y < (h-border);
+    }
+
+    template<typename TVec, typename TBorder>
+    PANGO_HOST_DEVICE inline
+    bool InBounds( const TVec& p, const TBorder border = (TBorder)0 ) const
+    {
+        return  border <= p[0] && p[0] < ((int)w - border) &&  border <= p[1] && p[1] < ((int)h - border);
+    }
+
+    //////////////////////////////////////////////////////
+    // Obtain slices / subimages
+    //////////////////////////////////////////////////////
+
+    PANGO_HOST_DEVICE inline
+    const Image<const T> SubImage(size_t x, size_t y, size_t width, size_t height) const
+    {
+        PANGO_ASSERT( (x+width) <= w && (y+height) <= h);
+        return Image<const T>( RowPtr(y)+x, width, height, pitch);
+    }
+
+    PANGO_HOST_DEVICE inline
+    Image<T> SubImage(size_t x, size_t y, size_t width, size_t height)
+    {
+        PANGO_ASSERT( (x+width) <= w && (y+height) <= h);
+        return Image<T>( RowPtr(y)+x, width, height, pitch);
+    }
+
+    PANGO_HOST_DEVICE inline
+    const Image<T> Row(int y) const
+    {
+        return SubImage(0,y,w,1);
+    }
+
+    PANGO_HOST_DEVICE inline
+    Image<T> Row(int y)
+    {
+        return SubImage(0,y,w,1);
+    }
+
+    PANGO_HOST_DEVICE inline
+    const Image<T> Col(int x) const
+    {
+        return SubImage(x,0,1,h);
+    }
+
+    PANGO_HOST_DEVICE inline
+    Image<T> Col(int x)
+    {
+        return SubImage(x,0,1,h);
+    }
+
+    //////////////////////////////////////////////////////
+    // Data mangling
+    //////////////////////////////////////////////////////
+
+    template<typename TRecast>
+    PANGO_HOST_DEVICE inline
+    Image<TRecast> Reinterpret() const
+    {
+        PANGO_ASSERT(sizeof(TRecast) == sizeof(T), "sizeof(TRecast) must match sizeof(T): % != %", sizeof(TRecast), sizeof(T) );
+        return UnsafeReinterpret<TRecast>();
+    }
+
+    template<typename TRecast>
+    PANGO_HOST_DEVICE inline
+    Image<TRecast> UnsafeReinterpret() const
+    {
+        return Image<TRecast>((TRecast*)ptr,w,h,pitch);
+    }
+
+    //////////////////////////////////////////////////////
+    // Deprecated methods
+    //////////////////////////////////////////////////////
+
+//    PANGOLIN_DEPRECATED inline
+    Image(size_t w, size_t h, size_t pitch, T* ptr)
+        : pitch(pitch), ptr(ptr), w(w), h(h)
+    {
+    }
+
+    // Use RAII/move aware pangolin::ManagedImage instead
+//    PANGOLIN_DEPRECATED inline
+    void Dealloc()
+    {
+        if(ptr) {
+            ::operator delete(ptr);
+            ptr = nullptr;
+        }
+    }
+
+    // Use RAII/move aware pangolin::ManagedImage instead
+//    PANGOLIN_DEPRECATED inline
+    void Alloc(size_t w, size_t h, size_t pitch)
+    {
+        Dealloc();
+        this->w = w;
+        this->h = h;
+        this->pitch = pitch;
+        this->ptr = (T*)::operator new(h*pitch);
+    }
+
+    //////////////////////////////////////////////////////
+    // Data members
+    //////////////////////////////////////////////////////
+
+    size_t pitch;
+    T* ptr;
+    size_t w;
+    size_t h;
+
+    PANGO_EXTENSION_IMAGE
+};
+
+}

third-party/DPVO/Pangolin/components/pango_image/include/pangolin/image/image_convert.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <pangolin/image/managed_image.h>
+#include <pangolin/utils/compontent_cast.h>
+
+namespace pangolin
+{
+
+template <typename To, typename T>
+void ImageConvert(Image<To>& dst, const Image<T>& src, To scale = 1.0)
+{
+    for(unsigned int y = 0; y < dst.h; ++y)
+    {
+        const T* prs = src.RowPtr(y);
+        To* prd = dst.RowPtr(y);
+        for(unsigned int x = 0; x < dst.w; ++x)
+        {
+            *(prd++) = scale * ComponentCast<To, T>::cast(*(prs++));
+        }
+    }
+}
+
+template <typename To, typename T>
+ManagedImage<To> ImageConvert(const Image<T>& src, To scale = 1.0)
+{
+    ManagedImage<To> dst(src.w, src.h);
+    ImageConvert<To,T>(dst,src,scale);
+    return dst;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/include/pangolin/image/image_io.h

@@ -0,0 +1,65 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/platform.h>
+
+#include <pangolin/image/typed_image.h>
+#include <pangolin/utils/file_extension.h>
+
+namespace pangolin {
+
+PANGOLIN_EXPORT
+TypedImage LoadImage(std::istream& in, ImageFileType file_type);
+
+PANGOLIN_EXPORT
+TypedImage LoadImage(const std::string& filename, ImageFileType file_type);
+
+PANGOLIN_EXPORT
+TypedImage LoadImage(const std::string& filename);
+
+PANGOLIN_EXPORT
+TypedImage LoadImage(const std::string& filename, const PixelFormat& raw_fmt, size_t raw_width, size_t raw_height, size_t raw_pitch);
+
+/// Quality \in [0..100] for lossy formats
+PANGOLIN_EXPORT
+void SaveImage(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, std::ostream& out, ImageFileType file_type, bool top_line_first = true, float quality = 100.0f);
+
+/// Quality \in [0..100] for lossy formats
+PANGOLIN_EXPORT
+void SaveImage(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, const std::string& filename, ImageFileType file_type, bool top_line_first = true, float quality = 100.0f);
+
+/// Quality \in [0..100] for lossy formats
+PANGOLIN_EXPORT
+void SaveImage(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, const std::string& filename, bool top_line_first = true, float quality = 100.0f);
+
+/// Quality \in [0..100] for lossy formats
+PANGOLIN_EXPORT
+void SaveImage(const TypedImage& image, const std::string& filename, bool top_line_first = true, float quality = 100.0f);
+
+}

third-party/DPVO/Pangolin/components/pango_image/include/pangolin/image/image_utils.h

@@ -0,0 +1,185 @@
+/* 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 <limits>
+#include <utility>
+
+#include <pangolin/image/image.h>
+#include <pangolin/utils/range.h>
+#include <pangolin/gl/gl.h>
+#include <pangolin/gl/glpixformat.h>
+
+namespace pangolin
+{
+
+namespace internal
+{
+
+template <typename T>
+std::pair<float, float> GetMinMax(const Image<T>& img, size_t channels)
+{
+    const size_t max_channels = 3;
+    const size_t colour_channels = std::min(channels, max_channels);
+    std::pair<float, float> chan_mm[max_channels];
+    for(size_t c = 0; c < max_channels; ++c)
+    {
+        chan_mm[c].first = +std::numeric_limits<float>::max();
+        chan_mm[c].second = -std::numeric_limits<float>::max();
+    }
+
+    for(size_t y = 0; y < img.h; ++y)
+    {
+        T* pix = (T*)((char*)img.ptr + y * img.pitch);
+        for(size_t x = 0; x < img.w; ++x)
+        {
+            for(size_t c = 0; c < colour_channels; ++c)
+            {
+                if(pix[c] < chan_mm[c].first)
+                    chan_mm[c].first = (float)pix[c];
+                if(pix[c] > chan_mm[c].second)
+                    chan_mm[c].second = (float)pix[c];
+            }
+
+            pix += channels;
+        }
+    }
+
+    // Find min / max of all channels, ignoring 4th alpha channel
+    std::pair<float, float> mm = chan_mm[0];
+    for(size_t c = 1; c < colour_channels; ++c)
+    {
+        mm.first = std::min(mm.first, chan_mm[c].first);
+        mm.second = std::max(mm.second, chan_mm[c].second);
+    }
+
+    return mm;
+}
+
+template<typename T>
+pangolin::Image<T> GetImageRoi( pangolin::Image<T> img, size_t channels, const pangolin::XYRangei& roi )
+{
+    return pangolin::Image<T>(
+        img.RowPtr(std::min(roi.y.min,roi.y.max)) + channels*std::min(roi.x.min,roi.x.max),
+        roi.x.AbsSize(), roi.y.AbsSize(),
+        img.pitch
+    );
+}
+
+template<typename T>
+std::pair<float,float> GetOffsetScale(const pangolin::Image<T>& img, size_t channels, float type_max, float format_max)
+{
+    // Find min / max of all channels, ignoring 4th alpha channel
+    const std::pair<float,float> mm = internal::GetMinMax<T>(img,channels);
+    const float type_scale = format_max / type_max;
+    const float offset = -type_scale* mm.first;
+    const float scale = type_max / (mm.second - mm.first);
+    return std::pair<float,float>(offset, scale);
+}
+
+template<typename T>
+float GetScaleOnly(const pangolin::Image<T>& img, size_t channels, float type_max, float /*format_max*/)
+{
+    // Find min / max of all channels, ignoring 4th alpha channel
+    const std::pair<float,float> mm = internal::GetMinMax<T>(img,channels);
+    const float scale = type_max / mm.second;
+    return scale;
+}
+
+} // internal
+
+inline std::pair<float, float> GetMinMax(
+    const Image<unsigned char>& img,
+    XYRangei iroi, const GlPixFormat& glfmt
+) {
+    using namespace internal;
+
+    iroi.Clamp(0, (int)img.w - 1, 0, (int)img.h - 1);
+
+    const size_t num_channels = pangolin::GlFormatChannels(glfmt.glformat);
+
+    if(glfmt.gltype == GL_UNSIGNED_BYTE) {
+        return GetMinMax(GetImageRoi(img.template UnsafeReinterpret<unsigned char>(), num_channels, iroi), num_channels);
+    } else if(glfmt.gltype == GL_UNSIGNED_SHORT) {
+        return GetMinMax(GetImageRoi(img.template UnsafeReinterpret<unsigned short>(), num_channels, iroi), num_channels);
+    } else if(glfmt.gltype == GL_FLOAT) {
+        return GetMinMax(GetImageRoi(img.template UnsafeReinterpret<float>(), num_channels, iroi), num_channels);
+    } else if(glfmt.gltype == GL_DOUBLE) {
+        return GetMinMax(GetImageRoi(img.template UnsafeReinterpret<double>(), num_channels, iroi), num_channels);
+    } else {
+        return std::pair<float, float>(std::numeric_limits<float>::max(), std::numeric_limits<float>::lowest());
+    }
+}
+
+inline std::pair<float,float> GetOffsetScale(
+    const pangolin::Image<unsigned char>& img,
+    pangolin::XYRangei iroi, const pangolin::GlPixFormat& glfmt
+) {
+    using namespace internal;
+
+    iroi.Clamp(0, (int)img.w-1, 0, (int)img.h-1 );
+
+    const size_t num_channels = pangolin::GlFormatChannels(glfmt.glformat);
+
+    if(glfmt.gltype == GL_UNSIGNED_BYTE) {
+        return GetOffsetScale(GetImageRoi(img.template UnsafeReinterpret<unsigned char>(), num_channels, iroi), num_channels, 255.0f, 1.0f);
+    }else if(glfmt.gltype == GL_UNSIGNED_SHORT) {
+        return GetOffsetScale(GetImageRoi(img.template UnsafeReinterpret<unsigned short>(), num_channels, iroi), num_channels, 65535.0f, 1.0f);
+    }else if(glfmt.gltype == GL_FLOAT) {
+        return GetOffsetScale(GetImageRoi(img.template UnsafeReinterpret<float>(), num_channels, iroi), num_channels, 1.0f, 1.0f);
+    }else if(glfmt.gltype == GL_DOUBLE) {
+        return GetOffsetScale(GetImageRoi(img.template UnsafeReinterpret<double>(), num_channels, iroi), num_channels, 1.0f, 1.0f);
+    }else{
+        return std::pair<float,float>(0.0f, 1.0f);
+    }
+}
+
+inline float GetScaleOnly(
+    const pangolin::Image<unsigned char>& img,
+    pangolin::XYRangei iroi, const pangolin::GlPixFormat& glfmt
+) {
+    using namespace internal;
+
+    iroi.Clamp(0, (int)img.w-1, 0, (int)img.h-1 );
+
+    const size_t num_channels = pangolin::GlFormatChannels(glfmt.glformat);
+
+    if(glfmt.gltype == GL_UNSIGNED_BYTE) {
+        return GetScaleOnly(GetImageRoi(img.template UnsafeReinterpret<unsigned char>(), num_channels, iroi), num_channels, 255.0f, 1.0f);
+    }else if(glfmt.gltype == GL_UNSIGNED_SHORT) {
+        return GetScaleOnly(GetImageRoi(img.template UnsafeReinterpret<unsigned short>(), num_channels, iroi), num_channels, 65535.0f, 1.0f);
+    }else if(glfmt.gltype == GL_FLOAT) {
+        return GetScaleOnly(GetImageRoi(img.template UnsafeReinterpret<float>(), num_channels, iroi), num_channels, 1.0f, 1.0f);
+    }else if(glfmt.gltype == GL_DOUBLE) {
+        return GetScaleOnly(GetImageRoi(img.template UnsafeReinterpret<double>(), num_channels, iroi), num_channels, 1.0f, 1.0f);
+    }else{
+        return 1.0f;
+    }
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/include/pangolin/image/managed_image.h

@@ -0,0 +1,174 @@
+/* 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/image/image.h>
+#include <pangolin/image/copy.h>
+
+namespace pangolin {
+
+template<class T> using DefaultImageAllocator = std::allocator<T>;
+
+// Image that manages it's own memory, storing a strong pointer to it's memory
+template<typename T, class Allocator = DefaultImageAllocator<T> >
+class ManagedImage : public Image<T>
+{
+public:
+    // Destructor
+    inline
+    ~ManagedImage()
+    {
+        Deallocate();
+    }
+
+    // Null image
+    inline
+    ManagedImage()
+    {
+    }
+
+    // Row image
+    inline
+    ManagedImage(size_t w)
+        : Image<T>(
+              Allocator().allocate(w),
+               w, 1, w*sizeof(T)
+              )
+    {
+    }
+
+    inline
+    ManagedImage(size_t w, size_t h)
+        : Image<T>(
+              Allocator().allocate(w*h),
+               w, h, w*sizeof(T)
+              )
+    {
+    }
+
+    inline
+    ManagedImage(size_t w, size_t h, size_t pitch_bytes)
+        : Image<T>(
+              Allocator().allocate( (h*pitch_bytes) / sizeof(T)),
+               w, h, pitch_bytes)
+    {
+    }
+
+    // Not copy constructable
+    inline
+    ManagedImage( const ManagedImage<T>& other ) = delete;
+
+    // Move constructor
+    inline
+    ManagedImage(ManagedImage<T,Allocator>&& img)
+    {
+        *this = std::move(img);
+    }
+
+    // Move asignment
+    inline
+    void operator=(ManagedImage<T,Allocator>&& img)
+    {
+        Deallocate();
+        Image<T>::pitch = img.pitch;
+        Image<T>::ptr   = img.ptr;
+        Image<T>::w     = img.w;
+        Image<T>::h     = img.h;
+        img.ptr = nullptr;
+    }
+
+    // Explicit copy constructor
+    template<typename TOther>
+    ManagedImage( const CopyObject<TOther>& other )
+    {
+        CopyFrom(other.obj);
+    }
+
+    // Explicit copy assignment
+    template<typename TOther>
+    void operator=(const CopyObject<TOther>& other)
+    {
+        CopyFrom(other.obj);
+    }
+
+    inline
+    void Swap(ManagedImage<T>& img)
+    {
+        std::swap(img.pitch, Image<T>::pitch);
+        std::swap(img.ptr, Image<T>::ptr);
+        std::swap(img.w, Image<T>::w);
+        std::swap(img.h, Image<T>::h);
+    }
+
+    inline
+    void CopyFrom(const Image<T>& img)
+    {
+        if(!Image<T>::IsValid() || Image<T>::w != img.w || Image<T>::h != img.h) {
+            Reinitialise(img.w,img.h);
+        }
+        Image<T>::CopyFrom(img);
+    }
+
+    inline
+    void Reinitialise(size_t w, size_t h)
+    {
+        if(!Image<T>::ptr || Image<T>::w != w || Image<T>::h != h) {
+            *this = ManagedImage<T,Allocator>(w,h);
+        }
+    }
+
+    inline
+    void Reinitialise(size_t w, size_t h, size_t pitch)
+    {
+        if(!Image<T>::ptr || Image<T>::w != w || Image<T>::h != h || Image<T>::pitch != pitch) {
+            *this = ManagedImage<T,Allocator>(w,h,pitch);
+        }
+    }
+
+    inline void Deallocate()
+    {
+        if (Image<T>::ptr) {
+            Allocator().deallocate(Image<T>::ptr, (Image<T>::h * Image<T>::pitch) / sizeof(T) );
+            Image<T>::ptr = nullptr;
+        }
+    }
+
+    // Move asignment
+    template<typename TOther, typename AllocOther> inline
+    void OwnAndReinterpret(ManagedImage<TOther,AllocOther>&& img)
+    {
+        Deallocate();
+        Image<T>::pitch = img.pitch;
+        Image<T>::ptr   = (T*)img.ptr;
+        Image<T>::w     = img.w;
+        Image<T>::h     = img.h;
+        img.ptr = nullptr;
+    }
+};
+
+}

third-party/DPVO/Pangolin/components/pango_image/include/pangolin/image/memcpy.h

@@ -0,0 +1,110 @@
+/* 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 <cstring>
+
+#ifdef HAVE_CUDA
+#  include <cuda_runtime.h>
+#endif
+
+namespace pangolin {
+
+template<typename T>
+PANGO_HOST_DEVICE inline
+bool IsDevicePtr(T* ptr)
+{
+#ifdef HAVE_CUDA
+    cudaPointerAttributes attributes;
+    cudaError_t res = cudaPointerGetAttributes(&attributes,ptr);
+
+    //Flushing the error flag for future CUDA error checks
+    if(res != cudaSuccess)
+    {
+        cudaGetLastError();
+        return false;
+    }
+
+    return attributes.memoryType == cudaMemoryTypeDevice;
+#else
+    PANGOLIN_UNUSED(ptr);
+    return false;
+#endif
+}
+
+PANGO_HOST_DEVICE inline
+void MemCopy(void *dst, const void *src, size_t size_bytes)
+{
+#ifdef HAVE_CUDA
+    cudaMemcpy(dst,src, size_bytes, cudaMemcpyDefault);
+#else
+    std::memcpy(dst, src, size_bytes);
+#endif
+}
+
+inline
+void PitchedCopy(char* dst, unsigned int dst_pitch_bytes, const char* src, unsigned int src_pitch_bytes, unsigned int width_bytes, unsigned int height)
+{
+#ifdef HAVE_CUDA
+    cudaMemcpy2D(dst, dst_pitch_bytes, src, src_pitch_bytes, width_bytes, height, cudaMemcpyDefault);
+#else
+    if(dst_pitch_bytes == width_bytes && src_pitch_bytes == width_bytes ) {
+        std::memcpy(dst, src, height * width_bytes);
+    }else{
+        for(unsigned int row=0; row < height; ++row) {
+            std::memcpy(dst, src, width_bytes);
+            dst += dst_pitch_bytes;
+            src += src_pitch_bytes;
+        }
+    }
+#endif
+}
+
+PANGO_HOST_DEVICE inline
+void Memset(char* ptr, unsigned char v, size_t size_bytes)
+{
+#ifdef __CUDA_ARCH__
+    // Called in kernel
+    char* end = ptr + size_bytes;
+    for(char* p=ptr; p != end; ++p) *p = v;
+#else
+#  ifdef HAVE_CUDA
+        if(IsDevicePtr(ptr))
+        {
+            cudaMemset(ptr, v, size_bytes);
+        }else
+#  endif // HAVE_CUDA
+        {
+            std::memset(ptr, v, size_bytes);
+        }
+#endif // __CUDA_ARCH__
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/include/pangolin/image/pixel_format.h

@@ -0,0 +1,69 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011-2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/platform.h>
+#include <string>
+#include <vector>
+
+namespace pangolin
+{
+
+struct PANGOLIN_EXPORT PixelFormat
+{
+    // Previously, VideoInterface::PixFormat returned a string.
+    // For compatibility, make this string convertable
+    inline operator std::string() const { return format; }
+
+    std::string  format;
+    unsigned int channels;
+    unsigned int channel_bits[4]; //Of the data type
+    unsigned int bpp; //Of the data type
+    unsigned int channel_bit_depth; //Of the data
+    bool planar;
+};
+
+
+//! Return Pixel Format properties given string specification in
+//! FFMPEG notation.
+PANGOLIN_EXPORT
+PixelFormat PixelFormatFromString(const std::string& format);
+
+std::vector<PixelFormat> GetSupportedPixelFormats();
+
+////////////////////////////////////////////////////////////////////
+/// Deprecated aliases for above
+
+PANGOLIN_DEPRECATED("Use PixelFormat instead")
+typedef PixelFormat VideoPixelFormat;
+PANGOLIN_DEPRECATED("Use PixelFormatFromString instead")
+inline PixelFormat VideoFormatFromString(const std::string& format) {
+    return PixelFormatFromString(format);
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/include/pangolin/image/shared_image.h

@@ -0,0 +1,145 @@
+/* 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/image/image.h>
+#include <pangolin/image/copy.h>
+
+namespace pangolin {
+
+template<class T> using DefaultImageAllocator = std::allocator<T>;
+
+// Image that manages it's own memory, storing a strong pointer to it's memory
+template<typename T>
+class SharedImage : public Image<T>
+{
+private:
+    std::shared_ptr<T[]> shared_memory;
+
+public:
+    // Destructor
+    inline
+    ~SharedImage()
+    {
+    }
+
+    // Null image
+    inline
+    SharedImage()
+    {
+    }
+
+    // Row image
+    inline
+    SharedImage(size_t w)
+        : Image<T>( nullptr, w, 1, w*sizeof(T) ),
+          shared_memory(new T[w])
+    {
+        Image<T>::ptr = shared_memory.get();
+    }
+
+    inline
+    SharedImage(size_t w, size_t h)
+        : Image<T>( nullptr, w, h, w*sizeof(T) ),
+          shared_memory(new T[w*h])
+    {
+        Image<T>::ptr = shared_memory.get();
+    }
+
+    inline
+    SharedImage(size_t w, size_t h, size_t pitch_bytes)
+        : Image<T>( nullptr, w, h, pitch_bytes),
+          shared_memory(new T[h*pitch_bytes / sizeof(T)])
+    {
+        Image<T>::ptr = shared_memory.get();
+    }
+
+    // Copyable with shared semantics (not a deep copy).
+    inline
+    SharedImage( const SharedImage<T>& other ) = default;
+
+    // Move constructor
+    inline
+    SharedImage(SharedImage<T>&& img)
+    {
+        *this = std::move(img);
+    }
+
+    // Move asignment
+    inline
+    void operator=(SharedImage<T>&& img)
+    {
+        Image<T>::pitch = img.pitch;
+        Image<T>::ptr   = img.ptr;
+        Image<T>::w     = img.w;
+        Image<T>::h     = img.h;
+        shared_memory = std::move(img.shared_memory);
+        img.ptr = nullptr;
+    }
+
+    // Explicit copy constructor
+    template<typename TOther>
+    SharedImage( const CopyObject<TOther>& other )
+    {
+        CopyFrom(other.obj);
+    }
+
+    // Explicit copy assignment
+    template<typename TOther>
+    void operator=(const CopyObject<TOther>& other)
+    {
+        CopyFrom(other.obj);
+    }
+
+    inline
+    void Swap(SharedImage<T>& img)
+    {
+        std::swap(img.pitch, Image<T>::pitch);
+        std::swap(img.ptr, Image<T>::ptr);
+        std::swap(img.w, Image<T>::w);
+        std::swap(img.h, Image<T>::h);
+        std::swap(img.shared_memory, shared_memory);
+    }
+
+    inline
+    void CopyFrom(const Image<T>& img)
+    {
+        if(!Image<T>::IsValid() || Image<T>::w != img.w || Image<T>::h != img.h) {
+            throw std::runtime_error("Incompatible image specification for copy");
+        }
+        Image<T>::CopyFrom(img);
+    }
+
+    inline void Deallocate()
+    {
+        shared_memory = nullptr;
+        Image<T>::ptr = nullptr;
+    }
+};
+
+}

third-party/DPVO/Pangolin/components/pango_image/include/pangolin/image/typed_image.h

@@ -0,0 +1,91 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/image/managed_image.h>
+#include <pangolin/image/pixel_format.h>
+
+namespace pangolin {
+
+struct TypedImage : public ManagedImage<unsigned char>
+{
+    typedef ManagedImage<unsigned char> Base;
+
+    inline TypedImage()
+        : Base()
+    {
+    }
+
+    inline TypedImage(size_t w, size_t h, const PixelFormat& fmt)
+        : Base(w,h,w*fmt.bpp/8), fmt(fmt)
+    {
+    }
+
+    inline TypedImage(size_t w, size_t h, const PixelFormat& fmt, size_t pitch )
+        : Base(w,h, pitch), fmt(fmt)
+    {
+    }
+
+    inline
+    void Reinitialise(size_t w, size_t h, const PixelFormat& fmt)
+    {
+        Base::Reinitialise(w, h, w*fmt.bpp/8);
+        this->fmt = fmt;
+    }
+
+    inline
+    void Reinitialise(size_t w, size_t h, const PixelFormat& fmt, size_t pitch)
+    {
+        Base::Reinitialise(w, h, pitch);
+        this->fmt = fmt;
+    }
+
+    // Not copy constructable
+    inline
+    TypedImage( const TypedImage& other ) = delete;
+
+    // Move constructor
+    inline
+    TypedImage(TypedImage&& img)
+    {
+        *this = std::move(img);
+    }
+
+    // Move asignment
+    inline
+    void operator=(TypedImage&& img)
+    {
+        fmt = img.fmt;
+        Base::operator =( std::move(img));
+    }
+
+
+    PixelFormat fmt;
+};
+
+}

third-party/DPVO/Pangolin/components/pango_image/src/image_io.cpp

@@ -0,0 +1,197 @@
+/* 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/image/image_io.h>
+
+#include <fstream>
+
+namespace pangolin {
+
+// PNG
+TypedImage LoadPng(std::istream& in);
+void SavePng(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, std::ostream& out, bool top_line_first, int zlib_compression_level );
+
+// JPG
+TypedImage LoadJpg(std::istream& in);
+void SaveJpg(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, std::ostream& out, float quality);
+
+// PPM
+TypedImage LoadPpm(std::istream& in);
+void SavePpm(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, std::ostream& out, bool top_line_first);
+
+// TGA
+TypedImage LoadTga(std::istream& in);
+
+// Pango
+TypedImage LoadPango(const std::string& filename);
+void SavePango(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, const std::string& filename, bool top_line_first);
+
+// EXR
+TypedImage LoadExr(std::istream& source);
+void SaveExr(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, const std::string& filename, bool top_line_first);
+
+// BMP
+TypedImage LoadBmp(std::istream& source);
+void SaveBmp(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, std::ostream& out, bool top_line_first);
+
+// ZSTD (https://github.com/facebook/zstd)
+TypedImage LoadZstd(std::istream& in);
+void SaveZstd(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, std::ostream& out, int compression_level);
+
+// https://github.com/lz4/lz4
+TypedImage LoadLz4(std::istream& in);
+void SaveLz4(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, std::ostream& out, int compression_level);
+
+// packed 12 bit image (obtained from unpacked 16bit)
+TypedImage LoadPacked12bit(std::istream& in);
+void SavePacked12bit(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, std::ostream& out);
+
+// LibRaw raw camera files
+TypedImage LoadLibRaw(const std::string& filename);
+
+// TIFF
+TypedImage LoadTiff(const std::string& filename);
+
+TypedImage LoadImage(std::istream& in, ImageFileType file_type)
+{
+    switch (file_type) {
+    case ImageFileTypePng:
+        return LoadPng(in);
+    case ImageFileTypeJpg:
+        return LoadJpg(in);
+    case ImageFileTypePpm:
+        return LoadPpm(in);
+    case ImageFileTypeTga:
+        return LoadTga(in);
+    case ImageFileTypeZstd:
+        return LoadZstd(in);
+    case ImageFileTypeLz4:
+        return LoadLz4(in);
+    case ImageFileTypeP12b:
+        return LoadPacked12bit(in);
+    case ImageFileTypeExr:
+        return LoadExr(in);
+    case ImageFileTypeBmp:
+        return LoadBmp(in);
+    default:
+        throw std::runtime_error("Unable to load image file-type through std::istream");
+    }
+}
+
+TypedImage LoadImage(const std::string& filename, ImageFileType file_type)
+{
+    switch (file_type) {
+    case ImageFileTypePng:
+    case ImageFileTypeJpg:
+    case ImageFileTypePpm:
+    case ImageFileTypeTga:
+    case ImageFileTypeZstd:
+    case ImageFileTypeLz4:
+    case ImageFileTypeP12b:
+    case ImageFileTypeExr:
+    case ImageFileTypeBmp:
+    {
+        std::ifstream ifs(filename, std::ios_base::in|std::ios_base::binary);
+        return LoadImage(ifs, file_type);
+    }
+    case ImageFileTypePango:
+        return LoadPango(filename);
+    case ImageFileTypeArw:
+        return LoadLibRaw(filename);
+    case ImageFileTypeTiff:
+        return LoadTiff(filename);
+    default:
+        throw std::runtime_error("Unsupported image file type, '" + filename + "'");
+    }
+}
+
+TypedImage LoadImage(const std::string& filename)
+{
+    ImageFileType file_type = FileType(filename);
+    return LoadImage( filename, file_type );
+}
+
+void SaveImage(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, std::ostream& out, ImageFileType file_type, bool top_line_first, float quality)
+{
+    switch (file_type) {
+    case ImageFileTypePng:
+        // map quality [0..100] to PNG compression levels [0..9]
+        return SavePng(image, fmt, out, top_line_first, int(quality*0.09));
+    case ImageFileTypeJpg:
+        return SaveJpg(image, fmt, out, quality);
+    case ImageFileTypePpm:
+        return SavePpm(image, fmt, out, top_line_first);
+    case ImageFileTypeZstd:
+        return SaveZstd(image, fmt, out, (int)quality);
+    case ImageFileTypeLz4:
+        return SaveLz4(image, fmt, out, (int)quality);
+    case ImageFileTypeP12b:
+        return SavePacked12bit(image, fmt, out);
+    case ImageFileTypeBmp:
+        return SaveBmp(image, fmt, out, top_line_first);
+    default:
+        throw std::runtime_error("Unable to save image file-type through std::istream");
+    }
+}
+
+
+void SaveImage(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, const std::string& filename, ImageFileType file_type, bool top_line_first, float quality)
+{
+    switch (file_type) {
+    case ImageFileTypePng:
+    case ImageFileTypeJpg:
+    case ImageFileTypePpm:
+    case ImageFileTypeZstd:
+    case ImageFileTypeLz4:
+    case ImageFileTypeP12b:
+    case ImageFileTypeBmp:
+    {
+        std::ofstream ofs(filename, std::ios_base::binary);
+        return SaveImage(image, fmt, ofs, file_type, top_line_first, quality);
+    }
+    case ImageFileTypeExr:
+        return SaveExr(image, fmt, filename, top_line_first);
+    case ImageFileTypePango:
+        return SavePango(image, fmt, filename, top_line_first);
+    default:
+        throw std::runtime_error("Unsupported image file type, '" + filename + "'");
+    }
+}
+
+void SaveImage(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, const std::string& filename, bool top_line_first, float quality)
+{
+    const std::string ext = FileLowercaseExtention(filename);
+    const ImageFileType file_type = FileTypeExtension(ext);
+    SaveImage(image, fmt, filename,file_type, top_line_first, quality);
+}
+
+void SaveImage(const TypedImage& image, const std::string& filename, bool top_line_first, float quality)
+{
+    SaveImage(image, image.fmt, filename, top_line_first, quality);
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/src/image_io_bmp.cpp

@@ -0,0 +1,94 @@
+#include <fstream>
+#include <pangolin/image/typed_image.h>
+
+namespace pangolin {
+
+#pragma pack(push, 1)
+struct BitmapHeader
+{
+  uint16_t magic;
+  uint32_t filesize_bytes;
+  uint32_t reserved;
+  uint32_t offset_bytes;  
+};
+struct BitmapInfoHeader
+{
+  uint32_t header_size_bytes;
+  uint32_t width;
+  uint32_t height;
+  uint16_t color_planes;
+  uint16_t bits_per_pixel;
+  uint32_t compression_method;
+  uint32_t imagesize_bytes;
+  uint32_t w_pixel_per_meter;
+  uint32_t h_pixel_per_meter;
+  uint32_t colors_in_pallete;
+  uint32_t important_colors;
+};
+
+static_assert(sizeof(BitmapHeader) == 14, "Unexpected padding on struct");
+static_assert(sizeof(BitmapInfoHeader) == 40, "Unexpected padding on struct");
+#pragma pack(pop)
+
+
+// https://en.wikipedia.org/wiki/BMP_file_format
+TypedImage LoadBmp(std::istream& in)
+{
+  constexpr uint16_t expected_magic = 'B' | 'M' << 8;
+
+  BitmapHeader bmp_file_header;
+  BitmapInfoHeader bmp_info_header;
+
+  memset((char*)&bmp_file_header, 0, sizeof(bmp_file_header));
+  memset((char*)&bmp_info_header, 0, sizeof(bmp_info_header));
+
+  in.read((char*)&bmp_file_header, sizeof(bmp_file_header));
+  if(!in.good() || bmp_file_header.magic != expected_magic) 
+    throw std::runtime_error("LoadBmp: invalid magic header");
+
+  in.read((char*)&bmp_info_header, sizeof(bmp_info_header));
+  if(!in.good() || bmp_info_header.header_size_bytes != 40)
+    throw std::runtime_error("LoadBmp: unknown info header");
+
+  if(bmp_info_header.bits_per_pixel != 24 )
+    throw std::runtime_error("LoadBmp: unexpected format");
+
+  const PixelFormat fmt = PixelFormatFromString("RGB24");
+
+  const size_t w = bmp_info_header.width;
+  const size_t h = bmp_info_header.height;
+  const size_t padding_bytes = ((4 - (w * 3) % 4) % 4);
+
+  if( w == 0 || h == 0)
+    throw std::runtime_error("LoadBmp: Invalid Bitmap size");
+
+  TypedImage img(w, h, fmt);
+
+  for (int y = ( (int)h - 1); y != -1; y--)
+  {
+    char* p_pix = (char*)img.RowPtr(y);
+    in.read(p_pix, w * fmt.channels);
+    
+    if(!in.good()) 
+      throw std::runtime_error("LoadBmp: Unexpected end of stream.");
+
+    // Convert from BGR to RGB
+    for (size_t x = 0; x < w; x++)
+    {
+      // BGR -> RGB
+      std::swap(p_pix[0], p_pix[2]);
+      p_pix += fmt.channels;
+    }
+
+    in.ignore(padding_bytes);
+  }
+
+  return img;
+}
+
+void SaveBmp(const Image<unsigned char>& /*image*/, const pangolin::PixelFormat& /*fmt*/, std::ostream& /*out*/, bool /*top_line_first*/)
+{
+  throw std::runtime_error("SaveBMP: Not implemented");
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/src/image_io_exr.cpp

@@ -0,0 +1,231 @@
+#include <pangolin/platform.h>
+
+#include <fstream>
+#include <pangolin/image/typed_image.h>
+
+#ifdef HAVE_OPENEXR
+#include <ImfChannelList.h>
+#include <ImfInputFile.h>
+#include <ImfOutputFile.h>
+#include <ImfIO.h>
+#endif // HAVE_OPENEXR
+
+namespace pangolin {
+
+#ifdef HAVE_OPENEXR
+Imf::PixelType OpenEXRPixelType(int channel_bits)
+{
+    if( channel_bits == 16 ) {
+        return Imf::PixelType::HALF;
+    }else if( channel_bits == 32 ) {
+        return Imf::PixelType::FLOAT;
+    }else{
+        throw std::runtime_error("Unsupported OpenEXR Pixel Type.");
+    }
+}
+
+void SetOpenEXRChannels(Imf::ChannelList& ch, const pangolin::PixelFormat& fmt)
+{
+    const char* CHANNEL_NAMES[] = {"R","G","B","A"};
+    for(size_t c=0; c < fmt.channels; ++c) {
+        ch.insert( CHANNEL_NAMES[c], Imf::Channel(OpenEXRPixelType(fmt.channel_bits[c])) );
+    }
+}
+
+class StdIStream: public Imf::IStream
+{
+  public:
+    StdIStream (std::istream &is):
+        Imf::IStream ("stream"),
+        _is (&is)
+    {
+    }
+
+    virtual bool read (char c[/*n*/], int n)
+    {
+        if (!*_is)
+            throw std::runtime_error("Unexpected end of file.");
+        _is->read (c, n);
+        if (_is->gcount() < n)
+        {
+            throw std::runtime_error("Early end of file");
+            return false;
+        }
+        return true;
+    }
+
+    virtual Imf::Int64 tellg ()
+    {
+        return std::streamoff (_is->tellg());
+    }
+
+    virtual void seekg (Imf::Int64 pos)
+    {
+        _is->seekg (pos);
+    }
+
+    virtual void clear ()
+    {
+        _is->clear();
+    }
+
+  private:
+    std::istream *	_is;
+};
+
+PixelFormat GetPixelFormat(const Imf::Header& header)
+{
+    const Imf::ChannelList &channels = header.channels();
+    size_t count = 0;
+
+    std::stringstream pixelFormat;
+    size_t depth = 0;
+    for (Imf::ChannelList::ConstIterator i = channels.begin(); i != channels.end(); ++i){
+        const Imf::Channel& channel = i.channel();
+        if(depth == 0)
+        {
+          switch(channel.type)
+          {
+            case Imf::FLOAT: depth = 32; break;
+            case Imf::HALF: depth = 16; break;
+            default:
+              throw std::invalid_argument("Currently, only floating-point OpenEXR files are supported.");
+          }
+        }
+        count += 1;
+        pixelFormat << i.name();
+    }
+
+    std::string colors = pixelFormat.str();
+    if (colors == "Y" || colors == "R") {
+      colors = "GRAY";
+    }
+
+    if ((count == 1 && colors != "GRAY")
+        || (count == 3 && colors != "RGB" && colors != "BGR")
+        || (count == 4 && colors != "RGBA" && colors != "ABGR")) {
+      throw std::runtime_error("bad color format");
+    }
+    if (count != 1 && count != 3 && count != 4) {
+      throw std::invalid_argument("Currently, only 1, 3 or 4-channel OpenEXR files are supported.");
+    }
+
+    return PixelFormatFromString(colors + std::to_string(depth*count) + "F");
+}
+
+#endif //HAVE_OPENEXR
+
+TypedImage LoadExr(std::istream& source)
+{
+#ifdef HAVE_OPENEXR
+    StdIStream istream(source);
+    Imf::InputFile file(istream);
+    PANGO_WARNING(file.isComplete());
+
+    Imath::Box2i dw = file.header().dataWindow();
+    int width = dw.max.x - dw.min.x + 1;
+    int height = dw.max.y - dw.min.y + 1;
+
+    PixelFormat format = GetPixelFormat(file.header());
+    TypedImage img(width, height, format);
+
+    char *imgBase = (char *) img.ptr - (dw.min.x + dw.min.y * width) * sizeof(float) * format.channels;
+    Imf::FrameBuffer fb;
+
+    const Imf::ChannelList &channels = file.header().channels();
+    size_t c = 0;
+    unsigned int d = format.channel_bit_depth;
+    Imf::PixelType pixeltype;
+    switch(d)
+    {
+      case 16: pixeltype = Imf::HALF; break;
+      case 32: pixeltype = Imf::FLOAT; break;
+      throw std::invalid_argument("Currently, only floating-point OpenEXR files are supported.");
+    }
+    unsigned int pixelsize = d/8;
+
+    auto writeChannel = [&](Imf::ChannelList::ConstIterator& i, size_t j) {
+      fb.insert(i.name(), Imf::Slice(
+                      pixeltype, imgBase + pixelsize * j,
+                      pixelsize * format.channels,
+                      pixelsize * format.channels * size_t(width)));
+    };
+    if(format.format == "ABGR128F") {
+      format.format = "RGBA128F";
+      static std::map<std::string, size_t> channelOrder = {
+        {"R", 0}, {"G", 1}, {"B", 2}, {"A", 3}
+      };
+      for (Imf::ChannelList::ConstIterator i = channels.begin(); i != channels.end(); ++i) {
+        writeChannel(i, channelOrder[i.name()]);
+      }
+    }
+    else {
+      for (Imf::ChannelList::ConstIterator i = channels.begin(); i != channels.end(); ++i) {
+        writeChannel(i, c++);
+      }
+    }
+
+    file.setFrameBuffer(fb);
+    file.readPixels(dw.min.y, dw.max.y);
+
+    return img;
+#else
+    PANGOLIN_UNUSED(source);
+    throw std::runtime_error("Rebuild Pangolin for EXR support.");
+#endif //HAVE_OPENEXR
+}
+
+void SaveExr(const Image<unsigned char>& image_in, const pangolin::PixelFormat& fmt, const std::string& filename, bool top_line_first)
+{
+#ifdef HAVE_OPENEXR
+    ManagedImage<unsigned char> flip_image;
+    Image<unsigned char> image;
+
+    if(top_line_first) {
+        image = image_in;
+    }else{
+        flip_image.Reinitialise(image_in.w, image_in.h, image_in.pitch);
+        for(size_t y=0; y<image_in.h; ++y) {
+            std::memcpy(flip_image.RowPtr(y), image_in.RowPtr(image_in.h - 1 - y), image_in.pitch);
+        }
+        image = flip_image;
+    }
+
+
+    Imf::Header header (image.w, image.h);
+    SetOpenEXRChannels(header.channels(), fmt);
+
+    Imf::OutputFile file (filename.c_str(), header);
+    Imf::FrameBuffer frameBuffer;
+
+    size_t ch_bits = 0;
+    const char* CHANNEL_NAMES[] = {"R","G","B","A"};
+    for(unsigned int i=0; i<fmt.channels; i++)
+    {
+        const Imf::Channel *channel = header.channels().findChannel(CHANNEL_NAMES[i]);
+        frameBuffer.insert(
+            CHANNEL_NAMES[i],
+            Imf::Slice(
+                channel->type,
+                (char*)image.ptr + (ch_bits/8),
+                fmt.bpp/8,  // xstride
+                image.pitch // ystride
+            )
+        );
+
+        ch_bits += fmt.channel_bits[i];
+    }
+
+    file.setFrameBuffer(frameBuffer);
+    file.writePixels(image.h);
+
+#else
+    PANGOLIN_UNUSED(image_in);
+    PANGOLIN_UNUSED(fmt);
+    PANGOLIN_UNUSED(filename);
+    PANGOLIN_UNUSED(top_line_first);
+    throw std::runtime_error("EXR Support not enabled. Please rebuild Pangolin.");
+#endif // HAVE_OPENEXR
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/src/image_io_jpg.cpp

@@ -0,0 +1,319 @@
+#include <algorithm>
+#include <fstream>
+
+
+#include <pangolin/platform.h>
+
+#include <pangolin/image/typed_image.h>
+
+#ifdef HAVE_JPEG
+#  include <jpeglib.h>
+#  ifdef _WIN_
+//   Undef windows Macro polution from jpeglib.h
+#    undef LoadImage
+#  endif
+#endif // HAVE_JPEG
+
+
+// Inspired by https://cs.stanford.edu/~acoates/jpegAndIOS.txt
+
+namespace pangolin {
+
+#ifdef HAVE_JPEG
+
+void error_handler(j_common_ptr cinfo) {
+    char msg[JMSG_LENGTH_MAX];
+    (*(cinfo->err->format_message)) (cinfo, msg);
+    throw std::runtime_error(msg);
+}
+
+const static size_t PANGO_JPEG_BUF_SIZE = 16384;
+
+struct pango_jpeg_source_mgr {
+    struct jpeg_source_mgr pub;
+    std::istream* is;
+    JOCTET*       buffer;
+};
+
+static void pango_jpeg_init_source(j_decompress_ptr /*cinfo*/) {
+}
+// https://github.com/libjpeg-turbo/libjpeg-turbo/blob/main/jdatasrc.c#L69
+// ignore current state of src->pub.next_input_byte and src->pub.bytes_in_buffer
+static boolean pango_jpeg_fill_input_buffer(j_decompress_ptr cinfo) {
+    pango_jpeg_source_mgr* src = (pango_jpeg_source_mgr*)cinfo->src;
+    src->is->read((char*)src->buffer, PANGO_JPEG_BUF_SIZE);
+    size_t bytes = src->is->gcount();
+    if (bytes == 0) {
+        /* Insert a fake EOI marker */
+        src->buffer[0] = (JOCTET) 0xFF;
+        src->buffer[1] = (JOCTET) JPEG_EOI;
+        bytes = 2;
+    }
+    src->pub.next_input_byte = src->buffer;
+    src->pub.bytes_in_buffer = bytes;
+    return TRUE;
+}
+static void pango_jpeg_skip_input_data(j_decompress_ptr cinfo, long num_bytes) {
+    pango_jpeg_source_mgr* src = (pango_jpeg_source_mgr*)cinfo->src;
+    if (num_bytes > 0) {
+        while (num_bytes > (long)src->pub.bytes_in_buffer) {
+            num_bytes -= (long)src->pub.bytes_in_buffer;
+            pango_jpeg_fill_input_buffer(cinfo);
+        }
+        src->pub.next_input_byte += num_bytes;
+        src->pub.bytes_in_buffer -= num_bytes;
+    }
+}
+static void pango_jpeg_term_source(j_decompress_ptr cinfo) {
+    // must seek backward so that future reads will start at correct place.
+    pango_jpeg_source_mgr* src = (pango_jpeg_source_mgr*)cinfo->src;
+    src->is->clear();
+    src->is->seekg( src->is->tellg() - (std::streampos)src->pub.bytes_in_buffer );
+    src->pub.bytes_in_buffer = 0;
+    src->pub.next_input_byte = nullptr;
+}
+
+static void pango_jpeg_set_source_mgr(j_decompress_ptr cinfo, std::istream& is) {
+    pango_jpeg_source_mgr* src = nullptr;
+
+    if (cinfo->src == 0)
+    {
+        cinfo->src = (struct jpeg_source_mgr *)(*cinfo->mem->alloc_small)
+                ((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof(pango_jpeg_source_mgr));
+
+        src = (pango_jpeg_source_mgr*) cinfo->src;
+        src->buffer = (JOCTET *)(*cinfo->mem->alloc_small)
+                ((j_common_ptr) cinfo, JPOOL_PERMANENT, PANGO_JPEG_BUF_SIZE*sizeof(JOCTET));
+    }else{
+        src = (pango_jpeg_source_mgr*) cinfo->src;
+    }
+
+    src->is = &is;
+    src->pub.init_source = pango_jpeg_init_source;
+    src->pub.fill_input_buffer = pango_jpeg_fill_input_buffer;
+    src->pub.skip_input_data = pango_jpeg_skip_input_data;
+    src->pub.resync_to_restart = jpeg_resync_to_restart; /* use default method */
+    src->pub.term_source = pango_jpeg_term_source;
+    src->pub.bytes_in_buffer = 0;
+    src->pub.next_input_byte = nullptr;
+}
+
+struct pango_jpeg_destination_mgr {
+    struct jpeg_destination_mgr pub; /* public fields */
+    std::ostream* os; /* target stream */
+    JOCTET * buffer;	   /* start of buffer */
+};
+
+void pango_jpeg_init_destination (j_compress_ptr cinfo) {
+    pango_jpeg_destination_mgr* dest = (pango_jpeg_destination_mgr*) cinfo->dest;
+    dest->buffer = (JOCTET *)(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE,
+                                                         PANGO_JPEG_BUF_SIZE * sizeof(JOCTET));
+    dest->pub.next_output_byte = dest->buffer;
+    dest->pub.free_in_buffer = PANGO_JPEG_BUF_SIZE;
+}
+
+boolean pango_jpeg_empty_output_buffer(j_compress_ptr cinfo) {
+    pango_jpeg_destination_mgr* dest = (pango_jpeg_destination_mgr*)cinfo->dest;
+
+    dest->os->write((const char*)dest->buffer, PANGO_JPEG_BUF_SIZE);
+
+    if (dest->os->fail()) {
+        throw std::runtime_error("Couldn't write entire jpeg buffer to stream.");
+    }
+
+    dest->pub.next_output_byte = dest->buffer;
+    dest->pub.free_in_buffer = PANGO_JPEG_BUF_SIZE;
+    return TRUE;
+}
+
+void pango_jpeg_term_destination (j_compress_ptr cinfo) {
+    pango_jpeg_destination_mgr* dest = (pango_jpeg_destination_mgr*) cinfo->dest;
+    size_t datacount = PANGO_JPEG_BUF_SIZE - dest->pub.free_in_buffer;
+
+    /* Write any data remaining in the buffer */
+    if (datacount > 0) {
+        dest->os->write((const char*)dest->buffer, datacount);
+        if (dest->os->fail()) {
+            throw std::runtime_error("Couldn't write remaining jpeg data to stream.");
+        }
+    }
+    dest->os->flush();
+}
+
+void pango_jpeg_set_dest_mgr(j_compress_ptr cinfo, std::ostream& os) {
+    pango_jpeg_destination_mgr* dest;
+
+    if (cinfo->dest == NULL) {	/* first time for this JPEG object? */
+        cinfo->dest = (struct jpeg_destination_mgr *)
+                (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT,
+                                            sizeof(pango_jpeg_destination_mgr));
+    }
+
+    dest = (pango_jpeg_destination_mgr*)cinfo->dest;
+    dest->pub.init_destination = pango_jpeg_init_destination;
+    dest->pub.empty_output_buffer = pango_jpeg_empty_output_buffer;
+    dest->pub.term_destination = pango_jpeg_term_destination;
+    dest->os = &os;
+}
+
+#endif // HAVE_JPEG
+
+TypedImage LoadJpg(std::istream& is) {
+#ifdef HAVE_JPEG
+    TypedImage image;
+
+    struct jpeg_decompress_struct cinfo;
+    struct jpeg_error_mgr jerr;
+
+    // Setup decompression structure
+    cinfo.err = jpeg_std_error(&jerr);
+    jerr.error_exit = error_handler;
+    jpeg_create_decompress(&cinfo);
+    pango_jpeg_set_source_mgr(&cinfo, is);
+
+    // read info from header.
+    int r = jpeg_read_header(&cinfo, TRUE);
+    if (r != JPEG_HEADER_OK) {
+        throw std::runtime_error("Failed to read JPEG header.");
+    } else if (cinfo.num_components != 3 && cinfo.num_components != 1) {
+        throw std::runtime_error("Unsupported number of color components");
+    } else {
+        jpeg_start_decompress(&cinfo);
+        // resize storage if necessary
+        PixelFormat fmt = PixelFormatFromString(cinfo.output_components == 3 ? "RGB24" : "GRAY8");
+        image.Reinitialise(cinfo.output_width, cinfo.output_height, fmt);
+        JSAMPARRAY imageBuffer = (*cinfo.mem->alloc_sarray)((j_common_ptr)&cinfo, JPOOL_IMAGE,
+                                                            cinfo.output_width*cinfo.output_components, 1);
+        for (size_t y = 0; y < cinfo.output_height; y++) {
+            jpeg_read_scanlines(&cinfo, imageBuffer, 1);
+            uint8_t* dstRow = (uint8_t*)image.RowPtr(y);
+            memcpy(dstRow, imageBuffer[0], cinfo.output_width*cinfo.output_components);
+        }
+        jpeg_finish_decompress(&cinfo);
+    }
+
+    // clean up.
+    jpeg_destroy_decompress(&cinfo);
+
+    return image;
+#else
+    PANGOLIN_UNUSED(is);
+    throw std::runtime_error("Rebuild Pangolin for JPEG support.");
+#endif // HAVE_JPEG
+
+}
+
+std::vector<std::streampos> GetMJpegOffsets(std::ifstream& is) {
+    std::vector<std::streampos> offsets;
+
+#ifdef HAVE_JPEG
+    struct jpeg_decompress_struct cinfo;
+    struct jpeg_error_mgr jerr;
+    cinfo.err = jpeg_std_error(&jerr);
+    jerr.error_exit = error_handler;
+    jpeg_create_decompress(&cinfo);
+    pango_jpeg_set_source_mgr(&cinfo, is);
+
+    try {
+        while(true) {
+            // read info from header.
+            std::streampos jpeg_start_pos = is.tellg();
+            int r = jpeg_read_header(&cinfo, TRUE);
+            if (r != JPEG_HEADER_OK) {
+                throw std::runtime_error("Failed to read JPEG header.");
+            } else if (cinfo.num_components != 3 && cinfo.num_components != 1) {
+                throw std::runtime_error("Unsupported number of color components");
+            } else {
+                jpeg_start_decompress(&cinfo);
+
+                // resize storage if necessary
+                JSAMPARRAY imageBuffer = (*cinfo.mem->alloc_sarray)((j_common_ptr)&cinfo, JPOOL_IMAGE,
+                                                                    cinfo.output_width*cinfo.output_components, 1);
+                // TODO: Is there a better way to truly skip ANY decoding?
+#ifdef LIBJPEG_TURBO_VERSION
+                // bug in libjpeg-turbo prevents us from skipping to end, so skip to end-1
+                jpeg_skip_scanlines(&cinfo, cinfo.output_height-1);
+                jpeg_read_scanlines(&cinfo, imageBuffer, 1);
+#else
+                for (size_t y = 0; y < cinfo.output_height; y++) {
+                    jpeg_read_scanlines(&cinfo, imageBuffer, 1);
+                }
+#endif
+                jpeg_finish_decompress(&cinfo);
+                offsets.push_back(jpeg_start_pos);
+                cinfo.src->term_source(&cinfo);
+            }
+        }
+    }  catch (const std::runtime_error&) {
+    }
+
+    jpeg_destroy_decompress(&cinfo);
+
+    if(offsets.size() > 0) {
+        is.clear(); // clear eof marker
+        is.seekg(offsets[0]);
+    }
+#endif
+    return offsets;
+}
+
+TypedImage LoadJpg(const std::string& filename) {
+    std::ifstream f(filename);
+    return LoadJpg(f);
+}
+
+void SaveJpg(const Image<unsigned char>& img, const PixelFormat& fmt, std::ostream& os, float quality) {
+#ifdef HAVE_JPEG
+    const int iquality = (int)std::max(std::min(quality, 100.0f),0.0f);
+
+    struct jpeg_compress_struct cinfo;
+    struct jpeg_error_mgr       jerr;
+
+    if (fmt.channels != 1 && fmt.channels != 3) {
+        throw std::runtime_error("Unsupported number of image channels.");
+    }
+    if (fmt.bpp != 8 &&  fmt.bpp != 24) {
+        throw std::runtime_error("Unsupported image depth.");
+    }
+
+    // set up compression structure
+    cinfo.err = jpeg_std_error(&jerr);
+    jpeg_create_compress(&cinfo);
+    pango_jpeg_set_dest_mgr(&cinfo, os);
+
+    cinfo.image_width      = (JDIMENSION)img.w;
+    cinfo.image_height     = (JDIMENSION)img.h;
+    cinfo.input_components = fmt.channels;
+    if (fmt.channels == 3) {
+        cinfo.in_color_space   = JCS_RGB;
+    } else {
+        cinfo.in_color_space   = JCS_GRAYSCALE;
+    }
+
+    jpeg_set_defaults(&cinfo);
+    jpeg_set_quality(&cinfo, iquality, (boolean)true);
+    jpeg_start_compress(&cinfo, (boolean)true);
+
+    JSAMPROW row;
+    while (cinfo.next_scanline < cinfo.image_height) {
+        row = (JSAMPROW)((char*)img.RowPtr(cinfo.next_scanline));
+        jpeg_write_scanlines(&cinfo, &row, 1);
+    }
+
+    jpeg_finish_compress(&cinfo);
+    jpeg_destroy_compress(&cinfo);
+#else
+    PANGOLIN_UNUSED(img);
+    PANGOLIN_UNUSED(fmt);
+    PANGOLIN_UNUSED(os);
+    PANGOLIN_UNUSED(quality);
+    throw std::runtime_error("Rebuild Pangolin for JPEG support.");
+#endif // HAVE_JPEG
+}
+
+void SaveJpg(const Image<unsigned char>& img, const PixelFormat& fmt, const std::string& filename, float quality) {
+    std::ofstream f(filename);
+    SaveJpg(img, fmt, f, quality);
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/src/image_io_libraw.cpp

@@ -0,0 +1,48 @@
+#include <fstream>
+#include <pangolin/image/typed_image.h>
+
+#ifdef HAVE_LIBRAW
+#  include <libraw/libraw.h>
+#endif
+
+namespace pangolin {
+
+TypedImage LoadLibRaw(
+    const std::string& filename
+) {
+#ifdef HAVE_LIBRAW
+    static LibRaw RawProcessor;
+
+    int ret;
+
+    if ((ret = RawProcessor.open_file(filename.c_str())) != LIBRAW_SUCCESS)
+    {
+        throw std::runtime_error(libraw_strerror(ret));
+    }
+
+    if ((ret = RawProcessor.unpack()) != LIBRAW_SUCCESS)
+    {
+        throw std::runtime_error(libraw_strerror(ret));
+    }
+
+    const auto& S = RawProcessor.imgdata.sizes;
+    TypedImage image(S.width, S.height, PixelFormatFromString("GRAY16LE"), sizeof(uint16_t) * S.raw_width);
+    PitchedCopy((char*)image.ptr, image.pitch, (char*)RawProcessor.imgdata.rawdata.raw_image, sizeof(uint16_t) * S.raw_width, sizeof(uint16_t) * image.w, image.h);
+
+    // TODO: Support image metadata so that we can extract these fields.
+    // RawProcessor.imgdata.other.iso_speed
+    // RawProcessor.imgdata.other.aperture
+    // RawProcessor.imgdata.other.focal_len
+    // RawProcessor.imgdata.other.shutter
+    // RawProcessor.imgdata.other.timestamp
+    // RawProcessor.imgdata.makernotes.common.exifCameraElevationAngle
+    // RawProcessor.imgdata.makernotes.sony.SonyDateTime
+
+    return image;
+#else
+    PANGOLIN_UNUSED(filename);
+    throw std::runtime_error("Rebuild Pangolin for libraw support.");
+#endif
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/src/image_io_lz4.cpp

@@ -0,0 +1,86 @@
+#include <fstream>
+#include <memory>
+
+#include <pangolin/image/typed_image.h>
+
+#ifdef HAVE_LZ4
+#  include <lz4.h>
+#endif
+
+namespace pangolin {
+
+#pragma pack(push, 1)
+struct lz4_image_header
+{
+    char magic[3];
+    char fmt[16];
+    size_t w, h;
+    int64_t compressed_size;
+};
+#pragma pack(pop)
+
+void SaveLz4(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, std::ostream& out, int compression_level)
+{
+#ifdef HAVE_LZ4
+    const int64_t src_size = image.SizeBytes();
+    const int64_t max_dst_size = LZ4_compressBound(src_size);
+    std::unique_ptr<char[]> output_buffer(new char[max_dst_size]);
+
+    // Same as LZ4_compress_default(), but allows to select an "acceleration" factor. 
+    // The larger the acceleration value, the faster the algorithm, but also the lesser the compression.
+    // It's a trade-off. It can be fine tuned, with each successive value providing roughly +~3% to speed.
+    // An acceleration value of "1" is the same as regular LZ4_compress_default()
+    // Values <= 0 will be replaced by ACCELERATION_DEFAULT (see lz4.c), which is 1. 
+    const int64_t compressed_data_size = LZ4_compress_fast((char*)image.ptr, output_buffer.get(), src_size, max_dst_size, compression_level);
+
+    if (compressed_data_size < 0)
+        throw std::runtime_error("A negative result from LZ4_compress_default indicates a failure trying to compress the data.");
+    if (compressed_data_size == 0)
+        throw std::runtime_error("A result of 0 for LZ4 means compression worked, but was stopped because the destination buffer couldn't hold all the information.");
+
+    lz4_image_header header;
+    memcpy(header.magic,"LZ4",3);
+    strncpy(header.fmt, fmt.format.c_str(), sizeof(header.fmt));
+    header.w = image.w;
+    header.h = image.h;
+    header.compressed_size = compressed_data_size;
+    out.write((char*)&header, sizeof(header));
+
+    out.write(output_buffer.get(), compressed_data_size);
+
+#else
+    PANGOLIN_UNUSED(image);
+    PANGOLIN_UNUSED(fmt);
+    PANGOLIN_UNUSED(out);
+    PANGOLIN_UNUSED(compression_level);
+    throw std::runtime_error("Rebuild Pangolin for LZ4 support.");
+#endif // HAVE_LZ4
+}
+
+TypedImage LoadLz4(std::istream& in)
+{
+#ifdef HAVE_LZ4
+    // Read in header, uncompressed
+    lz4_image_header header;
+    in.read( (char*)&header, sizeof(header));
+
+    TypedImage img(header.w, header.h, PixelFormatFromString(header.fmt));
+    std::unique_ptr<char[]> input_buffer(new char[header.compressed_size]);
+
+    in.read(input_buffer.get(), header.compressed_size);
+    const int decompressed_size = LZ4_decompress_safe(input_buffer.get(), (char*)img.ptr, header.compressed_size, img.SizeBytes());
+    if (decompressed_size < 0)
+        throw std::runtime_error(FormatString("A negative result from LZ4_decompress_safe indicates a failure trying to decompress the data.  See exit code (%) for value returned.", decompressed_size));
+    if (decompressed_size == 0)
+        throw std::runtime_error("I'm not sure this function can ever return 0.  Documentation in lz4.h doesn't indicate so.");
+    if (decompressed_size != (int)img.SizeBytes())
+        throw std::runtime_error(FormatString("decompressed size % is not equal to predicted size %", decompressed_size, img.SizeBytes()));
+
+    return img;
+#else
+    PANGOLIN_UNUSED(in);
+    throw std::runtime_error("Rebuild Pangolin for LZ4 support.");
+#endif // HAVE_LZ4
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/src/image_io_packed12bit.cpp

@@ -0,0 +1,87 @@
+#include <fstream>
+#include <memory>
+
+#include <pangolin/image/typed_image.h>
+
+namespace pangolin {
+
+#pragma pack(push, 1)
+struct packed12bit_image_header
+{
+    char magic[4];
+    char fmt[16];
+    size_t w, h;
+};
+#pragma pack(pop)
+
+void SavePacked12bit(const Image<uint8_t>& image, const pangolin::PixelFormat& fmt, std::ostream& out)
+{
+
+  if (fmt.bpp != 16) {
+    throw std::runtime_error("packed12bit currently only supported with 16bit input image");
+  }
+
+  const size_t dest_pitch = (image.w*12)/ 8 + ((image.w*12) % 8 > 0? 1 : 0);
+  const size_t dest_size = image.h*dest_pitch;
+  std::unique_ptr<uint8_t[]> output_buffer(new uint8_t[dest_size]);
+
+    for(size_t r=0; r<image.h; ++r) {
+        uint8_t* pout = output_buffer.get() + r*dest_pitch;
+        uint16_t* pin = (uint16_t*)(image.ptr + r*image.pitch);
+        const uint16_t* pin_end = (uint16_t*)(image.ptr + (r+1)*image.pitch);
+        while(pin < pin_end) {
+            uint32_t val = (*(pin++) & 0x00000FFF);
+            val |= uint32_t(*(pin++) & 0x00000FFF) << 12;
+            *(pout++) = uint8_t( val & 0x000000FF);
+            *(pout++) = uint8_t((val & 0x0000FF00) >> 8);
+            *(pout++) = uint8_t((val & 0x00FF0000) >> 16);
+        }
+    }
+
+  packed12bit_image_header header;
+  static_assert (sizeof(header.magic) ==  4, "[bug]");
+  memcpy(header.magic, "P12B", 4);
+  memset(header.fmt, '\0', sizeof(header.fmt));
+  memcpy(header.fmt, fmt.format.c_str(), std::min(sizeof(header.fmt), fmt.format.size()) );
+  header.w = image.w;
+  header.h = image.h;
+  out.write((char*)&header, sizeof(header));
+  out.write((char*)output_buffer.get(), dest_size);
+
+}
+
+TypedImage LoadPacked12bit(std::istream& in)
+{
+    // Read in header, uncompressed
+    packed12bit_image_header header;
+    in.read((char*)&header, sizeof(header));
+
+    TypedImage img(header.w, header.h, PixelFormatFromString(header.fmt));
+
+  if (img.fmt.bpp != 16) {
+    throw std::runtime_error("packed12bit currently only supported with 16bit input image");
+  }
+
+  const size_t input_pitch = (img.w*12)/ 8 + ((img.w*12) % 8 > 0? 1 : 0);
+  const size_t input_size = img.h*input_pitch;
+    std::unique_ptr<uint8_t[]> input_buffer(new uint8_t[input_size]);
+
+    in.read((char*)input_buffer.get(), input_size);
+
+    for(size_t r=0; r<img.h; ++r) {
+        uint16_t* pout = (uint16_t*)(img.ptr + r*img.pitch);
+        uint8_t* pin = input_buffer.get() + r*input_pitch;
+        const uint8_t* pin_end = input_buffer.get() + (r+1)*input_pitch;
+        while(pin < pin_end) {
+            uint32_t val = *(pin++);
+            val |= uint32_t(*(pin++)) << 8;
+            val |= uint32_t(*(pin++)) << 16;
+            *(pout++) = uint16_t( val & 0x000FFF);
+            *(pout++) = uint16_t((val & 0xFFF000) >> 12);
+        }
+    }
+
+    return img;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/src/image_io_pango.cpp

@@ -0,0 +1,62 @@
+#include <pangolin/platform.h>
+
+#include <pangolin/image/typed_image.h>
+
+#ifdef BUILD_PANGOLIN_VIDEO
+#  include <pangolin/video/drivers/pango.h>
+#  include <pangolin/video/drivers/pango_video_output.h>
+#endif
+
+namespace pangolin {
+
+TypedImage LoadPango(const std::string& uri)
+{
+    PANGOLIN_UNUSED(uri);
+
+#ifdef BUILD_PANGOLIN_VIDEO
+    std::unique_ptr<VideoInterface> video = OpenVideo(uri);
+    if(!video || video->Streams().size() != 1) {
+        throw pangolin::VideoException("Wrong number of streams: exactly one expected.");
+    }
+
+    std::unique_ptr<uint8_t[]> buffer( new uint8_t[video->SizeBytes()] );
+    const StreamInfo& stream_info = video->Streams()[0];
+
+    // Grab first image from video
+    if(!video->GrabNext(buffer.get(), true)) {
+        throw pangolin::VideoException("Failed to grab image from stream");
+    }
+
+    // Allocate storage for user image to return
+    TypedImage image(stream_info.Width(), stream_info.Height(), stream_info.PixFormat());
+
+    // Copy image data into user buffer.
+    const Image<unsigned char> img = stream_info.StreamImage(buffer.get());
+    PANGO_ENSURE(image.pitch <= img.pitch);
+    for(size_t y=0; y < image.h; ++y) {
+        std::memcpy(image.RowPtr(y), img.RowPtr(y), image.pitch);
+    }
+
+    return image;
+#else
+    throw std::runtime_error("Video Support not enabled. Please rebuild Pangolin.");
+#endif
+}
+
+void SavePango(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, const std::string& uri, bool /*top_line_first*/)
+{
+    PANGOLIN_UNUSED(image);
+    PANGOLIN_UNUSED(fmt);
+    PANGOLIN_UNUSED(uri);
+
+#ifdef BUILD_PANGOLIN_VIDEO
+    std::unique_ptr<VideoOutputInterface> video = OpenVideoOutput(uri);
+    StreamInfo stream(fmt, image.w, image.h, image.pitch);
+    video->SetStreams({stream});
+    video->WriteStreams(image.ptr);
+#else
+    throw std::runtime_error("Video Support not enabled. Please rebuild Pangolin.");
+#endif
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/src/image_io_png.cpp

@@ -0,0 +1,234 @@
+#include <pangolin/platform.h>
+
+#include <fstream>
+#include <pangolin/image/image_io.h>
+#include <vector>
+
+#ifdef HAVE_PNG
+#  include <png.h>
+#endif // HAVE_PNG
+
+namespace pangolin {
+
+#ifdef HAVE_PNG
+
+PixelFormat PngFormat(png_structp png_ptr, png_infop info_ptr )
+{
+    const png_byte colour = png_get_color_type(png_ptr, info_ptr);
+    const png_byte depth  = png_get_bit_depth(png_ptr, info_ptr);
+
+    if( depth == 8 ) {
+        if( colour == PNG_COLOR_MASK_COLOR ) {
+            return PixelFormatFromString("RGB24");
+        } else if( colour == (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA) ) {
+            return PixelFormatFromString("RGBA32");
+        } else if( colour == PNG_COLOR_MASK_ALPHA ) {
+            return PixelFormatFromString("Y400A");
+        } else {
+            return PixelFormatFromString("GRAY8");
+        }
+    }else if( depth == 16 ) {
+        if( colour == 0 ) {
+            return PixelFormatFromString("GRAY16LE");
+        }
+    }
+
+    throw std::runtime_error("Unsupported PNG format");
+}
+
+void PNGAPI PngWarningsCallback(png_structp /*png_ptr*/, png_const_charp /*warning_message*/)
+{
+    // Override default behaviour - don't do anything.
+}
+
+#define PNGSIGSIZE 8
+bool pango_png_validate(std::istream& source)
+{
+    png_byte pngsig[PNGSIGSIZE];
+    source.read((char*)pngsig, PNGSIGSIZE);
+    return source.good() && png_sig_cmp(pngsig, 0, PNGSIGSIZE) == 0;
+}
+
+void pango_png_stream_read(png_structp pngPtr, png_bytep data, png_size_t length) {
+    std::istream* s = (std::istream*)png_get_io_ptr(pngPtr);
+    PANGO_ASSERT(s);
+    s->read((char*)data, length);
+}
+
+void pango_png_stream_write(png_structp pngPtr, png_bytep data, png_size_t length) {
+    std::ostream* s = (std::ostream*)png_get_io_ptr(pngPtr);
+    PANGO_ASSERT(s);
+    s->write((char*)data, length);
+}
+
+void pango_png_stream_write_flush(png_structp pngPtr)
+{
+    std::ostream* s = (std::ostream*)png_get_io_ptr(pngPtr);
+    PANGO_ASSERT(s);
+    s->flush();
+}
+
+#endif // HAVE_PNG
+
+
+TypedImage LoadPng(std::istream& source)
+{
+#ifdef HAVE_PNG
+    //so First, we validate our stream with the validate function I just mentioned
+    if (!pango_png_validate(source)) {
+        throw std::runtime_error("Not valid PNG header");
+    }
+
+    //set up initial png structs
+    png_structp png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING, (png_voidp)NULL, NULL, &PngWarningsCallback);
+    if (!png_ptr) {
+        throw std::runtime_error( "PNG Init error 1" );
+    }
+
+    png_infop info_ptr = png_create_info_struct(png_ptr);
+    if (!info_ptr)  {
+        png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL);
+        throw std::runtime_error( "PNG Init error 2" );
+    }
+
+    png_infop end_info = png_create_info_struct(png_ptr);
+    if (!end_info) {
+        png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
+        throw std::runtime_error( "PNG Init error 3" );
+    }
+
+    png_set_read_fn(png_ptr,(png_voidp)&source, pango_png_stream_read);
+
+    png_set_sig_bytes(png_ptr, PNGSIGSIZE);
+
+    // Setup transformation options
+    if( png_get_bit_depth(png_ptr, info_ptr) == 1)  {
+        //Unpack bools to bytes to ease loading.
+        png_set_packing(png_ptr);
+    } else if( png_get_bit_depth(png_ptr, info_ptr) < 8) {
+        //Expand nonbool colour depths up to 8bpp
+        png_set_expand_gray_1_2_4_to_8(png_ptr);
+    }
+
+    //Get rid of palette, by transforming it to RGB
+    if(png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE) {
+        png_set_palette_to_rgb(png_ptr);
+    }
+
+    //read the file
+    png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_SWAP_ENDIAN, NULL);
+
+    if( png_get_interlace_type(png_ptr,info_ptr) != PNG_INTERLACE_NONE) {
+        throw std::runtime_error( "Interlace not yet supported" );
+    }
+
+    const size_t w = png_get_image_width(png_ptr,info_ptr);
+    const size_t h = png_get_image_height(png_ptr,info_ptr);
+    const size_t pitch = png_get_rowbytes(png_ptr, info_ptr);
+
+    TypedImage img(w, h, PngFormat(png_ptr, info_ptr), pitch);
+
+    png_bytepp rows = png_get_rows(png_ptr, info_ptr);
+    for( unsigned int r = 0; r < h; r++) {
+        memcpy( img.ptr + pitch*r, rows[r], pitch );
+    }
+    png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
+
+    return img;
+#else
+    PANGOLIN_UNUSED(source);
+    throw std::runtime_error("Rebuild Pangolin for PNG support.");
+#endif // HAVE_PNG
+}
+
+TypedImage LoadPng(const std::string& filename)
+{
+    std::ifstream f(filename);
+    return LoadPng(f);
+}
+
+void SavePng(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, std::ostream& stream, bool top_line_first, int zlib_compression_level)
+{
+#ifdef HAVE_PNG
+    // Check image has supported bit depth
+    for(unsigned int i=1; i < fmt.channels; ++i) {
+        if( fmt.channel_bits[i] != fmt.channel_bits[0] ) {
+            throw std::runtime_error("PNG Saving only supported for images where each channel has the same bit depth.");
+        }
+    }
+
+    png_structp png_ptr;
+    png_infop info_ptr;
+
+    // Initialize write structure
+    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
+    if (png_ptr == NULL) {
+        throw std::runtime_error( "PNG Error: Could not allocate write struct." );
+    }
+
+    // Initialize info structure
+    info_ptr = png_create_info_struct(png_ptr);
+    if (info_ptr == NULL) {
+        png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
+        throw std::runtime_error( "PNG Error: Could not allocate info struct." );
+    }
+
+    // Setup Exception handling
+    if (setjmp(png_jmpbuf(png_ptr))) {
+        png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
+        png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
+        throw std::runtime_error( "PNG Error: Error during png creation." );
+    }
+
+    png_set_compression_level(png_ptr, zlib_compression_level);
+
+    png_set_write_fn(png_ptr,(png_voidp)&stream, pango_png_stream_write, pango_png_stream_write_flush);
+
+    const int bit_depth = fmt.channel_bits[0];
+
+    int colour_type;
+    switch (fmt.channels) {
+    case 1: colour_type = PNG_COLOR_TYPE_GRAY; break;
+    case 2: colour_type = PNG_COLOR_TYPE_GRAY_ALPHA; break;
+    case 3: colour_type = PNG_COLOR_TYPE_RGB; break;
+    case 4: colour_type = PNG_COLOR_TYPE_RGBA; break;
+    default:
+        throw std::runtime_error( "PNG Error: unexpected image channel number");
+    }
+
+    // Write header
+    png_set_IHDR(
+        png_ptr, info_ptr, (png_uint_32)image.w, (png_uint_32)image.h, bit_depth, colour_type,
+        PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT
+    );
+
+    // Setup rows to write:
+    std::vector<png_bytep> rows(image.h);
+    if(top_line_first) {
+        for (unsigned int y = 0; y< image.h; y++) {
+            rows[y] = image.ptr + y*image.pitch;
+        }
+    }else{
+        for (unsigned int y = 0; y< image.h; y++) {
+            rows[y] = image.ptr + (image.h-1-y)*image.pitch;
+        }
+    }
+    png_set_rows(png_ptr,info_ptr, &rows[0]);
+
+    // Write image data: switch to little-endian byte order, to match host.
+    png_write_png(png_ptr,info_ptr, PNG_TRANSFORM_SWAP_ENDIAN, 0);
+
+    // Free resources
+    png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
+    png_destroy_write_struct(&png_ptr, &info_ptr);
+#else
+    PANGOLIN_UNUSED(image);
+    PANGOLIN_UNUSED(fmt);
+    PANGOLIN_UNUSED(stream);
+    PANGOLIN_UNUSED(top_line_first);
+    PANGOLIN_UNUSED(zlib_compression_level);
+    throw std::runtime_error("Rebuild Pangolin for PNG support.");
+#endif // HAVE_PNG
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/src/image_io_ppm.cpp

@@ -0,0 +1,104 @@
+#include <fstream>
+#include <pangolin/image/typed_image.h>
+
+namespace pangolin {
+
+PixelFormat PpmFormat(const std::string& strType, int num_colours)
+{
+    if(strType == "P5") {
+        if(num_colours < 256) {
+            return PixelFormatFromString("GRAY8");
+        } else {
+            return PixelFormatFromString("GRAY16LE");
+        }
+    }else if(strType == "P6") {
+        return PixelFormatFromString("RGB24");
+    }else{
+        throw std::runtime_error("Unsupported PPM/PGM format");
+    }
+}
+
+void PpmConsumeWhitespaceAndComments(std::istream& in)
+{
+    // TODO: Make a little more general / more efficient
+    while( in.peek() == ' ' )  in.get();
+    while( in.peek() == '\n' ) in.get();
+    while( in.peek() == '#' )  in.ignore(4096, '\n');
+}
+
+TypedImage LoadPpm(std::istream& in)
+{
+    // Parse header
+    std::string ppm_type = "";
+    int num_colors = 0;
+    int w = 0;
+    int h = 0;
+
+    in >> ppm_type;
+    PpmConsumeWhitespaceAndComments(in);
+    in >> w;
+    PpmConsumeWhitespaceAndComments(in);
+    in >> h;
+    PpmConsumeWhitespaceAndComments(in);
+    in >> num_colors;
+    in.ignore(1,'\n');
+
+    if(!in.fail() && w > 0 && h > 0) {
+        TypedImage img(w, h, PpmFormat(ppm_type, num_colors) );
+
+        // Read in data
+        for(size_t r=0; r<img.h; ++r) {
+            in.read( (char*)img.ptr + r*img.pitch, img.pitch );
+        }
+        if(!in.fail()) {
+            return img;
+        }
+    }
+
+    throw std::runtime_error("Unable to load PPM file.");
+}
+
+void SavePpm(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, std::ostream& out, bool top_line_first)
+{
+    // Setup header variables
+    std::string ppm_type = "";
+    int num_colors = 0;
+    int w = (int)image.w;
+    int h = (int)image.h;
+
+    if(fmt.format == "GRAY8") {
+        ppm_type = "P5";
+        num_colors = 255;
+    }else if(fmt.format == "GRAY16LE") {
+        ppm_type = "P5";
+        num_colors = 65535;
+    }else if(fmt.format == "RGB24") {
+        ppm_type = "P6";
+        num_colors = 255;
+    }else{
+        throw std::runtime_error("Unsupported pixel format");
+    }
+
+    // Write header
+    out << ppm_type;
+    out << " ";
+    out << w;
+    out << " ";
+    out << h;
+    out << " ";
+    out << num_colors;
+    out << "\n";
+
+    // Write out data
+    if(top_line_first) {
+        for(size_t r=0; r<image.h; ++r) {
+            out.write( (char*)image.ptr + r*image.pitch, image.pitch );
+        }
+    }else{
+        for(size_t r=0; r<image.h; ++r) {
+            out.write( (char*)image.ptr + (image.h-1-r)*image.pitch, image.pitch );
+        }
+    }
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/src/image_io_raw.cpp

@@ -0,0 +1,25 @@
+#include <fstream>
+#include <pangolin/image/typed_image.h>
+
+namespace pangolin {
+
+TypedImage LoadImage(
+    const std::string& filename,
+    const PixelFormat& raw_fmt,
+    size_t raw_width, size_t raw_height, size_t raw_pitch
+) {
+    TypedImage img(raw_width, raw_height, raw_fmt, raw_pitch);
+
+    // Read from file, row at a time.
+    std::ifstream bFile( filename.c_str(), std::ios::in | std::ios::binary );
+    for(size_t r=0; r<img.h; ++r) {
+        bFile.read( (char*)img.ptr + r*img.pitch, img.pitch );
+        if(bFile.fail()) {
+            pango_print_warn("Unable to read raw image file to completion.");
+            break;
+        }
+    }
+    return img;
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/src/image_io_tga.cpp

@@ -0,0 +1,53 @@
+#include <pangolin/platform.h>
+
+#include <pangolin/image/image_io.h>
+
+namespace pangolin {
+
+PixelFormat TgaFormat(int depth, int color_type, int color_map)
+{
+    if(color_map == 0) {
+        if(color_type == 2) {
+            // Colour
+            if(depth == 24) {
+                return PixelFormatFromString("RGB24");
+            }else if(depth == 32) {
+                return PixelFormatFromString("RGBA32");
+            }
+        }else if(color_type == 3){
+            // Greyscale
+            if(depth == 8) {
+                return PixelFormatFromString("GRAY8");
+            }else if(depth == 16) {
+                return PixelFormatFromString("Y400A");
+            }
+        }
+    }
+    throw std::runtime_error("Unsupported TGA format");
+}
+
+TypedImage LoadTga(std::istream& in)
+{
+    unsigned char type[4];
+    unsigned char info[6];
+
+    in.read((char*)type, 3*sizeof(char));
+    in.seekg(12);
+    in.read((char*)info,6*sizeof(char));
+
+    const int width  = info[0] + (info[1] * 256);
+    const int height = info[2] + (info[3] * 256);
+
+    if(in.good()) {
+        TypedImage img(width, height, TgaFormat(info[4], type[2], type[1]) );
+
+        //read in image data
+        const size_t data_size = img.h * img.pitch;
+        in.read((char*)img.ptr, sizeof(char)*data_size);
+        return img;
+    }
+
+    throw std::runtime_error("Unable to load TGA file");
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/src/image_io_tiff.cpp

@@ -0,0 +1,79 @@
+#include <cassert>
+#include <pangolin/image/typed_image.h>
+
+#ifdef HAVE_LIBTIFF
+#  include <tiffio.h>
+#endif
+
+namespace pangolin {
+
+#ifdef HAVE_LIBTIFF
+template<typename T>
+T GetOrThrow(TIFF* tif, uint32_t tag)
+{
+    T r;
+    if (TIFFGetField(tif, tag, &r) != 1) {
+        throw std::runtime_error("Expected tag missing when reading tiff (" + std::to_string(tag) + ")");
+    }
+    return r;
+}
+
+template<typename T>
+T GetOrDefault(TIFF* tif, uint32_t tag, T default_val)
+{
+    T r = default_val;
+    TIFFGetField(tif, tag, &r);
+    return r;
+}
+#endif
+
+TypedImage LoadTiff(
+    const std::string& filename
+) {
+#ifdef HAVE_LIBTIFF
+    TIFF* tif = TIFFOpen(filename.c_str(),"r");
+    if (!tif) {
+        throw std::runtime_error("libtiff failed to open " + filename);
+    }
+
+    const auto width = GetOrThrow<uint32_t>(tif, TIFFTAG_IMAGEWIDTH);
+    const auto height = GetOrThrow<uint32_t>(tif, TIFFTAG_IMAGELENGTH);
+    const auto channels = GetOrThrow<uint16_t>(tif, TIFFTAG_SAMPLESPERPIXEL);
+    const auto bits_per_channel = GetOrThrow<uint16_t>(tif, TIFFTAG_BITSPERSAMPLE);
+    const auto sample_format = GetOrDefault<uint16_t>(tif, TIFFTAG_SAMPLEFORMAT, SAMPLEFORMAT_UINT);
+    const auto planar = GetOrThrow<uint16_t>(tif, TIFFTAG_PLANARCONFIG);
+//    const auto photom = GetOrThrow<uint16_t>(tif, TIFFTAG_PHOTOMETRIC);
+
+    // comparison of unsigned with >= 0 is always true!
+    //assert(width >= 0 && height >= 0 && channels >= 0 && bits_per_channel > 0);
+
+    if(planar != PLANARCONFIG_CONTIG /*|| photom != PHOTOMETRIC_RGB*/ || bits_per_channel % 8 != 0 || !(channels == 1 || channels == 3))
+        throw std::runtime_error("TIFF support is currently limited. Consider contributing to image_io_tiff.cpp.");
+
+    std::string sfmt;
+    switch(sample_format) {
+    case SAMPLEFORMAT_UINT: sfmt = (channels == 3) ? "RGB24" : "GRAY8"; break;
+    case SAMPLEFORMAT_IEEEFP: sfmt = (channels == 3) ? "RGB96F" : "GRAY32F"; break;
+    default: throw std::runtime_error("TIFF support is currently limited. Consider contributing to image_io_tiff.cpp.");
+    }
+
+    TypedImage image(width, height, PixelFormatFromString(sfmt));
+    const tsize_t scanlength_bytes = TIFFScanlineSize(tif);
+    if(scanlength_bytes != tsize_t(image.pitch))
+        throw std::runtime_error("TIFF: unexpected scanline length");
+
+    for (size_t row = 0; row < height; ++row) {
+        TIFFReadScanline(tif, image.RowPtr(row), row);
+    }
+
+    TIFFClose(tif);
+
+    return image;
+#else
+    PANGOLIN_UNUSED(filename);
+    throw std::runtime_error("Rebuild Pangolin for libtiff support.");
+#endif
+}
+
+}
+

third-party/DPVO/Pangolin/components/pango_image/src/image_io_zstd.cpp

@@ -0,0 +1,128 @@
+
+#include <fstream>
+#include <memory>
+
+#include <pangolin/image/typed_image.h>
+
+#ifdef HAVE_ZSTD
+#  include <zstd.h>
+#endif
+
+namespace pangolin {
+
+#pragma pack(push, 1)
+struct zstd_image_header
+{
+    char magic[4];
+    char fmt[16];
+    size_t w, h;
+};
+#pragma pack(pop)
+
+void SaveZstd(const Image<unsigned char>& image, const pangolin::PixelFormat& fmt, std::ostream& out, int compression_level)
+{
+#ifdef HAVE_ZSTD
+    // Write out header, uncompressed
+    zstd_image_header header;
+    memcpy(header.magic,"ZSTD",4);
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstringop-truncation"
+    strncpy(header.fmt, fmt.format.c_str(), sizeof(header.fmt));
+#pragma GCC diagnostic pop
+    header.w = image.w;
+    header.h = image.h;
+    out.write((char*)&header, sizeof(header));
+
+    // Write out image data
+    const size_t output_buffer_size = ZSTD_CStreamOutSize();
+    std::unique_ptr<char[]> output_buffer(new char[output_buffer_size]);
+
+    ZSTD_CStream* const cstream = ZSTD_createCStream();
+    if (cstream==nullptr) {
+        throw std::runtime_error("ZSTD_createCStream() error");
+    }
+
+    size_t const initResult = ZSTD_initCStream(cstream, compression_level);
+    if (ZSTD_isError(initResult)) {
+        throw std::runtime_error(FormatString("ZSTD_initCStream() error : %", ZSTD_getErrorName(initResult)));
+    }
+
+    const size_t row_size_bytes = (fmt.bpp * image.w)/8;
+
+    for(size_t y=0; y < image.h; ++y) {
+        ZSTD_inBuffer input = { image.RowPtr(y), row_size_bytes, 0 };
+
+        while (input.pos < input.size) {
+            ZSTD_outBuffer output = { output_buffer.get(), output_buffer_size, 0 };
+            size_t left_to_read = ZSTD_compressStream(cstream, &output , &input);
+            if (ZSTD_isError(left_to_read)) {
+                throw std::runtime_error(FormatString("ZSTD_compressStream() error : %", ZSTD_getErrorName(left_to_read)));
+            }
+            out.write(output_buffer.get(), output.pos);
+        }
+    }
+
+    ZSTD_outBuffer output = { output_buffer.get(), output_buffer_size, 0 };
+    size_t const remainingToFlush = ZSTD_endStream(cstream, &output);   /* close frame */
+    if (remainingToFlush) {
+        throw std::runtime_error("not fully flushed");
+    }
+    out.write(output_buffer.get(), output.pos);
+
+    ZSTD_freeCStream(cstream);
+#else
+    PANGOLIN_UNUSED(image);
+    PANGOLIN_UNUSED(fmt);
+    PANGOLIN_UNUSED(out);
+    PANGOLIN_UNUSED(compression_level);
+    throw std::runtime_error("Rebuild Pangolin for ZSTD support.");
+#endif // HAVE_ZSTD
+}
+
+TypedImage LoadZstd(std::istream& in)
+{
+#ifdef HAVE_ZSTD
+    // Read in header, uncompressed
+    zstd_image_header header;
+    in.read( (char*)&header, sizeof(header));
+
+    TypedImage img(header.w, header.h, PixelFormatFromString(header.fmt));
+
+    const size_t input_buffer_size = ZSTD_DStreamInSize();
+    std::unique_ptr<char[]> input_buffer(new char[input_buffer_size]);
+
+    ZSTD_DStream* dstream = ZSTD_createDStream();
+    if(!dstream) {
+        throw std::runtime_error("ZSTD_createDStream() error");
+    }
+
+    size_t read_size_hint = ZSTD_initDStream(dstream);
+    if (ZSTD_isError(read_size_hint)) {
+        throw std::runtime_error(FormatString("ZSTD_initDStream() error : % \n", ZSTD_getErrorName(read_size_hint)));
+    }
+
+    // Image represents our fixed buffer.
+    ZSTD_outBuffer output = { img.ptr, img.SizeBytes(), 0 };
+
+    while(read_size_hint)
+    {
+        in.read(input_buffer.get(), read_size_hint);
+        ZSTD_inBuffer input = { input_buffer.get(), read_size_hint, 0 };
+        while (input.pos < input.size) {
+            read_size_hint = ZSTD_decompressStream(dstream, &output , &input);
+            if (ZSTD_isError(read_size_hint)) {
+                throw std::runtime_error(FormatString("ZSTD_decompressStream() error : %", ZSTD_getErrorName(read_size_hint)));
+            }
+        }
+    }
+
+    ZSTD_freeDStream(dstream);
+
+    return img;
+#else
+    PANGOLIN_UNUSED(in);
+    throw std::runtime_error("Rebuild Pangolin for ZSTD support.");
+#endif // HAVE_ZSTD
+}
+
+}

third-party/DPVO/Pangolin/components/pango_image/src/pixel_format.cpp

@@ -0,0 +1,87 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <pangolin/image/pixel_format.h>
+
+#include <vector>
+#include <stdexcept>
+
+namespace pangolin
+{
+
+// Not to exceed 8 byte Format code.
+const PixelFormat SupportedPixelFormats[] =
+{
+    {"GRAY8", 1, {8}, 8, 8, false},
+    {"GRAY10", 1, {10}, 10, 10, false},
+    {"GRAY12", 1, {12}, 12, 12, false},
+    {"GRAY16LE", 1, {16}, 16, 16, false},
+    {"GRAY32", 1, {32}, 32, 32, false},
+    {"Y400A", 2, {8,8}, 16, 8, false},
+    {"RGB24", 3, {8,8,8}, 24, 8, false},
+    {"BGR24", 3, {8,8,8}, 24, 8, false},
+    {"RGB48", 3, {16,16,16}, 48, 16, false},
+    {"BGR48", 3, {16,16,16}, 48, 16, false},
+    {"YUYV422", 3, {4,2,2}, 16, 8, false},
+    {"UYVY422", 3, {4,2,2}, 16, 8, false},
+    {"RGBA32",  4, {8,8,8,8}, 32, 8, false},
+    {"BGRA32",  4, {8,8,8,8}, 32, 8, false},
+    {"RGBA64",  4, {16,16,16,16}, 64, 16, false},
+    {"BGRA64",  4, {16,16,16,16}, 64, 16, false},
+    {"GRAY32F", 1, {32}, 32, 32, false},
+    {"GRAY64F", 1, {64}, 64, 64, false},
+    {"RGB48F",  3, {16,16,16}, 48, 16, false},
+    {"BGR48F",  3, {16,16,16}, 48, 16, false},
+    {"RGBA64F",  4, {16,16,16,16}, 64, 16, false},
+    {"BGRA64F",  4, {16,16,16,16}, 64, 16, false},
+    {"RGB96F",  3, {32,32,32}, 96, 32, false},
+    {"BGR96F",  3, {32,32,32}, 96, 32, false},
+    {"RGBA128F",  4, {32,32,32,32}, 128, 32, false},
+    {"ABGR128F",  4, {32,32,32,32}, 128, 32, false},
+    {"",0,{0,0,0,0},0,0,0}
+};
+
+PixelFormat PixelFormatFromString(const std::string& format)
+{
+    for(int i=0; !SupportedPixelFormats[i].format.empty(); ++i)
+        if(!format.compare(SupportedPixelFormats[i].format))
+            return SupportedPixelFormats[i];
+    throw std::runtime_error( std::string("Unknown Format: ") + format);
+}
+
+std::vector<PixelFormat> GetSupportedPixelFormats()
+{
+    std::vector<PixelFormat> result;
+    const PixelFormat* pixelFormat = SupportedPixelFormats;
+    while( pixelFormat->format.length() > 0 ){
+        result.push_back( *pixelFormat );
+        pixelFormat++;
+    }
+    return result;
+}
+
+}

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

@@ -0,0 +1,50 @@
+get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME)
+
+file(GLOB BINARY_FILES_TO_EMBED "${CMAKE_CURRENT_LIST_DIR}/src/fonts/*.ttf")
+include(EmbedBinaryFiles)
+embed_binary_files_rule(fonts.cpp ${BINARY_FILES_TO_EMBED})
+
+target_sources( ${COMPONENT}
+PRIVATE
+    ${CMAKE_CURRENT_LIST_DIR}/src/glchar.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/gldraw.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/glfont.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/gltext.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/glpangoglu.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/gltexturecache.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/viewport.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/opengl_render_state.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/stb_truetype.h
+    ${CMAKE_CURRENT_BINARY_DIR}/fonts.cpp
+)
+
+find_package (Eigen3 REQUIRED QUIET)
+message(STATUS "Found Eigen: '${EIGEN3_INCLUDE_DIRS}'")
+target_compile_definitions(${COMPONENT} PUBLIC HAVE_EIGEN HAVE_GLEW)
+
+target_link_libraries(${COMPONENT} PUBLIC pango_core pango_image Eigen3::Eigen)
+target_include_directories(${COMPONENT} PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
+install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/include"
+  DESTINATION ${CMAKE_INSTALL_PREFIX}
+)
+
+if(EMSCRIPTEN)
+    target_compile_definitions(${COMPONENT} PUBLIC HAVE_GLES HAVE_GLES_2)
+    target_sources( ${COMPONENT} PRIVATE ${CMAKE_CURRENT_LIST_DIR}/src/compat/gl2engine.cpp)
+else()
+    if(_LINUX_)
+        set(OpenGL_GL_PREFERENCE "GLVND")
+    endif()
+    find_package(OpenGL REQUIRED QUIET)
+    find_package(GLEW REQUIRED QUIET)
+    target_include_directories( ${COMPONENT} PUBLIC
+        $<BUILD_INTERFACE:${OPENGL_INCLUDE_DIR}>
+        $<BUILD_INTERFACE:${GLEW_INCLUDE_DIR}>
+    )
+    target_link_libraries( ${COMPONENT} PUBLIC
+        ${GLEW_LIBRARY} ${OPENGL_LIBRARIES}
+    )
+endif()

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

@@ -0,0 +1,283 @@
+/* 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 <sstream>
+#include <algorithm>
+
+// Cg includes
+#include <Cg/cg.h>
+#include <Cg/cgGL.h>
+
+#include "gl.h"
+
+#ifdef HAVE_TOON
+#include <TooN/TooN.h>
+#endif // HAVE_TOON
+
+namespace pangolin
+{
+
+////////////////////////////////////////////////
+// Interface
+////////////////////////////////////////////////
+
+/// Lightweight object wrapper for NVidia Cg Shader program objects.
+class CgProgram
+{
+    friend class CgLoader;
+public:
+    void SetUniform(const std::string& name, GlTexture& tex);
+    void SetUniform(const std::string& name, float f);
+    void SetUniform(const std::string& name, float v0, float v1);
+    void SetUniform(const std::string& name, float v0, float v1, float v2, float v3);
+    
+#ifdef HAVE_TOON
+    void SetUniform(const std::string& name, const TooN::Vector<2>& v );
+    void SetUniform(const std::string& name, const TooN::Vector<3>& v );
+    
+    template <int R, int C>
+    void SetUniform(const std::string& name, const TooN::Matrix<R,C>& M );
+#endif
+    
+    void UpdateParams();
+    
+protected:
+    CGprogram mProg;
+    CGcontext mContext;
+    CGprofile mProfile;
+};
+
+class CgLoader
+{
+public:
+    CgLoader();
+    ~CgLoader();
+    
+    // Call AFTER glewInit (or similar)
+    void Initialise();
+    
+    CgProgram LoadProgramFromFile(const std::string& file, const std::string& function, bool isVertexShader );
+    
+    void EnableProgram(CgProgram program);
+    void DisablePrograms();
+    
+    void RenderDummyQuad();
+    void RenderDummyQuadWithTexCoords(int w, int h);
+    
+protected:
+    CGcontext mContext;
+    CGprofile mFragmentProfile;
+    CGprofile mVertexProfile;
+};
+
+
+
+
+////////////////////////////////////////////////
+// Implementation
+////////////////////////////////////////////////
+
+inline bool cgOkay()
+{
+    CGerror error;
+    const char *string = cgGetLastErrorString(&error);
+    
+    if (error != CG_NO_ERROR) {
+        std::cout << "CG Error: " << string << std::endl;
+        //    assert(0);
+        return false;
+    }
+    return true;
+}
+
+inline CgLoader::CgLoader()
+    :mContext(0)
+{
+}
+
+inline CgLoader::~CgLoader()
+{
+    if(mContext)
+    {
+        // Destroying context destroys all programs associated with it
+        cgDestroyContext(mContext);
+    }
+}
+
+
+inline void CgLoader::Initialise()
+{
+    mContext = cgCreateContext();
+    cgSetParameterSettingMode(mContext, CG_DEFERRED_PARAMETER_SETTING);
+    cgOkay();
+    
+    mFragmentProfile = cgGLGetLatestProfile(CG_GL_FRAGMENT);
+    cgGLSetOptimalOptions(mFragmentProfile);
+    cgOkay();
+    
+    mVertexProfile = cgGLGetLatestProfile(CG_GL_VERTEX);
+    cgGLSetOptimalOptions(mVertexProfile);
+    cgOkay();
+}
+
+inline CgProgram CgLoader::LoadProgramFromFile(const std::string& file, const std::string& function, bool isVertexShader )
+{
+    if( !mContext ) {
+        Initialise();
+    }
+    
+    CgProgram prog;
+    
+    prog.mContext = mContext;
+    prog.mProfile = isVertexShader ? mVertexProfile : mFragmentProfile;
+    prog.mProg = cgCreateProgramFromFile( prog.mContext, CG_SOURCE, file.c_str(), prog.mProfile, function.c_str(), NULL);
+    
+    if( !cgOkay() )
+    {
+        std::cout << cgGetLastListing(mContext) << std::endl;
+        assert(0);
+    }
+    
+    cgGLLoadProgram(prog.mProg);
+    if( !cgOkay() )
+    {
+        const char* err = cgGetProgramString( prog.mProg, CG_COMPILED_PROGRAM );
+        int pos;
+        glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
+        std::cout << err << std::endl;
+        std::cout << "@ " << pos << std::endl;
+        assert(0);
+    }
+    return prog;
+}
+
+inline void CgLoader::EnableProgram(CgProgram program)
+{
+    cgGLBindProgram(program.mProg);
+    cgGLEnableProfile(program.mProfile);
+    cgOkay();
+}
+
+inline void CgLoader::DisablePrograms()
+{
+    cgGLDisableProfile(mFragmentProfile);
+    cgGLDisableProfile(mVertexProfile);
+}
+
+inline void CgLoader::RenderDummyQuad()
+{
+    glBegin(GL_QUADS);
+    glVertex2d(-1,1);
+    glVertex2d(1,1);
+    glVertex2d(1,-1);
+    glVertex2d(-1,-1);
+    glEnd();
+}
+
+inline void CgLoader::RenderDummyQuadWithTexCoords(int w, int h)
+{
+    glBegin(GL_QUADS);
+    glTexCoord2f(0, 0);
+    glVertex2d(-1,-1);
+    glTexCoord2f(w, 0);
+    glVertex2d(1,-1);
+    glTexCoord2f(w, h);
+    glVertex2d(1,1);
+    glTexCoord2f(0, h);
+    glVertex2d(-1,1);
+    glEnd();
+}
+
+void CgProgram::SetUniform(const std::string& name, float f)
+{
+    CGparameter p = cgGetNamedParameter( mProg, name.c_str());
+    cgSetParameter1f( p, f );
+    cgUpdateProgramParameters(mProg);
+}
+
+void CgProgram::SetUniform(const std::string& name, GlTexture& tex)
+{
+    CGparameter p = cgGetNamedParameter( mProg, name.c_str());
+    cgGLSetTextureParameter(p, tex.tid );
+    cgGLEnableTextureParameter(p);
+    cgUpdateProgramParameters(mProg);
+}
+
+void CgProgram::SetUniform(const std::string& name, float v0, float v1, float v2, float v3)
+{
+    CGparameter p = cgGetNamedParameter( mProg, name.c_str());
+    cgGLSetParameter4f(p, v0,v1,v2,v3);
+    cgUpdateProgramParameters(mProg);
+}
+
+void CgProgram::SetUniform(const std::string& name, float v0, float v1)
+{
+    CGparameter p = cgGetNamedParameter( mProg, name.c_str());
+    cgGLSetParameter2f(p, v0,v1);
+    cgUpdateProgramParameters(mProg);
+}
+
+#ifdef HAVE_TOON
+void CgProgram::SetUniform(const std::string& name, const TooN::Vector<2>& v )
+{
+    CGparameter p = cgGetNamedParameter( mProg, name.c_str());
+    cgGLSetParameter2f(p, v[0],v[1] );
+    cgUpdateProgramParameters(mProg);
+}
+
+void CgProgram::SetUniform(const std::string& name, const TooN::Vector<3>& v )
+{
+    CGparameter p = cgGetNamedParameter( mProg, name.c_str());
+    cgGLSetParameter3f(p, v[0],v[1],v[2] );
+    cgUpdateProgramParameters(mProg);
+}
+
+template <int R, int C>
+void CgProgram::SetUniform(const std::string& name, const TooN::Matrix<R,C>& M )
+{
+    CGparameter p = cgGetNamedParameter( mProg, name.c_str());
+    float Mdata[R*C];
+    
+    int i=0;
+    for( int r=0; r<R; ++r )
+        for( int c=0; c<C; ++c )
+            Mdata[i++] = (float)(M[r][c]);
+    
+    cgGLSetMatrixParameterfr(p, Mdata );
+    cgUpdateProgramParameters(mProg);
+}
+#endif
+
+void CgProgram::UpdateParams()
+{
+    cgUpdateProgramParameters(mProg);
+}
+
+
+}

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

@@ -0,0 +1,178 @@
+/* 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 <cmath>
+#include <limits>
+#include <stdexcept>
+
+namespace pangolin
+{
+
+/// Represent OpenGL floating point colour: Red, Green and Blue with alpha.
+struct Colour
+{
+    inline static Colour White() {
+        return Colour(1.0f,1.0f,1.0f,1.0f);
+    }
+    inline static Colour Black() {
+        return Colour(0.0f,0.0f,0.0f,1.0f);
+    }
+    inline static Colour Red() {
+        return Colour(1.0f,0.0f,0.0f,1.0f);
+    }
+    inline static Colour Green() {
+        return Colour(0.0f,1.0f,0.0f,1.0f);
+    }
+    inline static Colour Blue() {
+        return Colour(0.0f,0.0f,1.0f,1.0f);
+    }
+    inline static Colour Unspecified() {
+        return Colour(
+            std::numeric_limits<float>::quiet_NaN(), std::numeric_limits<float>::quiet_NaN(),
+            std::numeric_limits<float>::quiet_NaN(), std::numeric_limits<float>::quiet_NaN()
+        );
+    }
+
+    /// Default constructs white.
+    inline Colour()
+        : red(1.0f), green(1.0f), blue(1.0f), alpha(1.0f)
+    {
+    }
+
+    /// Construct from component values
+    inline Colour(const float red, const float green, const float blue, const float alpha = 1.0f)
+        : red(red), green(green), blue(blue), alpha(alpha)
+    {
+    }
+
+    /// Construct from rgba array.
+    inline Colour(const float rgba[4])
+    {
+        r = rgba[0];
+        g = rgba[1];
+        b = rgba[2];
+        a = rgba[3];
+    }
+
+    /// Return pointer to OpenGL compatible RGBA array.
+    inline float* Get()
+    {
+        return c;
+    }
+
+    /// Return this colour with alpha adjusted.
+    inline Colour WithAlpha(const float alpha)
+    {
+        return Colour(r,g,b,alpha);
+    }
+
+    /// Construct from HSV Colour
+    /// @param hue Colour hue in range [0,1]
+    /// @param sat Saturation in range [0,1]
+    /// @param val Value / Brightness in range [0,1].
+    static inline Colour Hsv(const float hue, const float sat = 1.0f, const float val = 1.0f, const float alpha = 1.0f)
+    {
+          const float h = 6.0f * hue;
+          const int i = (int)floor(h);
+          const float f = (i%2 == 0) ? 1-(h-i) : h-i;
+          const float m = val * (1-sat);
+          const float n = val * (1-sat*f);
+
+          switch(i)
+          {
+          case 0: return Colour(val,n,m,alpha);
+          case 1: return Colour(n,val,m,alpha);
+          case 2: return Colour(m,val,n,alpha);
+          case 3: return Colour(m,n,val,alpha);
+          case 4: return Colour(n,m,val,alpha);
+          case 5: return Colour(val,m,n,alpha);
+          default:
+              throw std::runtime_error("Found extra colour in rainbow.");
+          }
+    }
+
+    union {
+        struct {
+            float red;
+            float green;
+            float blue;
+            float alpha;
+        };
+        struct {
+            float r;
+            float g;
+            float b;
+            float a;
+        };
+        float c[4];
+    };
+
+};
+
+/// A ColourWheel is like a continuous colour palate that can be sampled.
+/// In the future, different ColourWheels will be supported, but this one
+/// is based on sampling hues in HSV colourspace. An indefinite number of
+/// unique colours are sampled using the golden angle.
+class ColourWheel
+{
+public:
+    /// Construct ColourWheel with Saturation, Value and Alpha constant.
+    inline ColourWheel(float saturation = 0.5f, float value = 1.0f, float alpha = 1.0f)
+        : unique_colours(0), sat(saturation), val(value), alpha(alpha)
+    {
+
+    }
+
+    /// Use Golden ratio (/angle) to pick well spaced colours.
+    inline Colour GetColourBin(int i) const
+    {
+        float hue = i * 0.5f * (3.0f - sqrt(5.0f));
+        hue -= (int)hue;
+        return Colour::Hsv(hue,sat,val,alpha);
+    }
+
+    /// Return next unique colour from ColourWheel.
+    inline Colour GetUniqueColour()
+    {
+        return GetColourBin(unique_colours++);
+    }
+
+    /// Reset colour wheel counter to initial state
+    inline void Reset() {
+      unique_colours = 0;
+    }
+
+protected:
+    int unique_colours;
+    float sat;
+    float val;
+    float alpha;
+};
+
+}

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

@@ -0,0 +1,316 @@
+/* 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 <stack>
+
+#include <pangolin/gl/opengl_render_state.h>
+#include <pangolin/gl/glsl.h>
+
+namespace pangolin {
+
+class GlEngine
+{
+public:
+    const char* vert =
+            "attribute vec4 a_position;\n"
+            "attribute vec4 a_color;\n"
+            "attribute vec3 a_normal;\n"
+            "attribute vec2 a_texcoord;\n"
+            "uniform vec4 u_color;\n"
+            "uniform mat4 u_modelViewProjectionMatrix;\n"
+            "varying vec4 v_frontColor;\n"
+            "varying vec2 v_texcoord;\n"
+            "void main() {\n"
+            "    gl_Position = u_modelViewProjectionMatrix * a_position;\n"
+            "    v_frontColor = u_color;\n"
+            "    v_texcoord = a_texcoord;\n"
+            "}\n";
+
+    const char* frag =
+        #ifdef HAVE_GLES_2
+            "precision mediump float;\n"
+        #endif // HAVE_GLES_2
+            "varying vec4 v_frontColor;\n"
+            "varying vec2 v_texcoord;\n"
+            "uniform sampler2D u_texture;\n"
+            "uniform bool u_textureEnable;\n"
+            "void main() {\n"
+            "  gl_FragColor = v_frontColor;\n"
+            "  if(u_textureEnable) {\n"
+            "    gl_FragColor *= texture2D(u_texture, v_texcoord);\n"
+            "  }\n"
+            "}\n";
+
+    GlEngine()
+    {
+        // Initialise default state
+        projection.push(IdentityMatrix());
+        modelview.push(IdentityMatrix());
+        currentmatrix = &modelview;
+
+        // Set GL_TEXTURE0 as default active texture
+        glActiveTexture(GL_TEXTURE0);
+
+        // Compile and link shaders
+        prog_fixed.AddShader(GlSlVertexShader, vert);
+        prog_fixed.AddShader(GlSlFragmentShader, frag);
+        prog_fixed.BindPangolinDefaultAttribLocationsAndLink();
+
+        // Save locations of uniforms
+        u_color = prog_fixed.GetUniformHandle("u_color");
+        u_modelViewProjectionMatrix = prog_fixed.GetUniformHandle("u_modelViewProjectionMatrix");
+        u_texture = prog_fixed.GetUniformHandle("u_texture");
+        u_textureEnable = prog_fixed.GetUniformHandle("u_textureEnable");
+
+        // Initialise default uniform values
+        UpdateMatrices();
+        SetColor(1.0,1.0,1.0,1.0);
+    }
+
+    void UpdateMatrices()
+    {
+        OpenGlMatrix pmv = projection.top() * modelview.top();
+        prog_fixed.SaveBind();
+        glUniformMatrix4fv( u_modelViewProjectionMatrix, 1, false, pmv.m );
+        prog_fixed.Unbind();
+    }
+
+    void SetColor(float r, float g, float b, float a)
+    {
+        prog_fixed.SaveBind();
+        glUniform4f( u_color, r, g, b, a);
+        prog_fixed.Unbind();
+    }
+
+    void EnableTexturing(GLboolean v)
+    {
+        prog_fixed.SaveBind();
+        glUniform1i( u_textureEnable, v);
+        prog_fixed.Unbind();
+    }
+
+//protected:
+    std::stack<OpenGlMatrix> projection;
+    std::stack<OpenGlMatrix> modelview;
+    std::stack<OpenGlMatrix>* currentmatrix;
+
+    GLenum matrixmode;
+
+    float color[4];
+
+    GlSlProgram  prog_fixed;
+
+    GLint u_color;
+    GLint u_modelViewProjectionMatrix;
+    GLint u_texture;
+    GLint u_textureEnable;
+};
+
+GlEngine& glEngine();
+
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// OpenGL 1.0 compatibility - Emulate fixed pipeline
+///////////////////////////////////////////////////////////////////////////////
+
+// Missing defines that we'll be using
+#define GL_MODELVIEW                      0x1700
+#define GL_PROJECTION                     0x1701
+#define GL_SHADE_MODEL                    0x0B54
+#define GL_POINT_SIZE                     0x0B11
+
+#define GL_MULTISAMPLE                    0x809D
+
+#define GL_LIGHTING                       0x0B50
+#define GL_POINT_SMOOTH                   0x0B10
+#define GL_LINE_SMOOTH                    0x0B20
+#define GL_SCISSOR_TEST                   0x0C11
+#define GL_COLOR_MATERIAL                 0x0B57
+
+#define GL_FLAT                           0x1D00
+#define GL_SMOOTH                         0x1D01
+
+#define GL_MODULATE                       0x2100
+#define GL_DECAL                          0x2101
+#define GL_ADD                            0x0104
+#define GL_TEXTURE_ENV_MODE               0x2200
+#define GL_TEXTURE_ENV_COLOR              0x2201
+#define GL_TEXTURE_ENV                    0x2300
+
+#define GL_PERSPECTIVE_CORRECTION_HINT    0x0C50
+#define GL_POINT_SMOOTH_HINT              0x0C51
+#define GL_LINE_SMOOTH_HINT               0x0C52
+
+#define GL_VERTEX_ARRAY                   0x8074
+#define GL_NORMAL_ARRAY                   0x8075
+#define GL_COLOR_ARRAY                    0x8076
+#define GL_TEXTURE_COORD_ARRAY            0x8078
+
+inline void glEnableClientState(GLenum cap)
+{
+    pangolin::GlEngine& gl = pangolin::glEngine();
+    if(cap == GL_VERTEX_ARRAY) {
+        glEnableVertexAttribArray(pangolin::DEFAULT_LOCATION_POSITION);
+    }else if(cap == GL_COLOR_ARRAY) {
+        glEnableVertexAttribArray(pangolin::DEFAULT_LOCATION_COLOUR);
+    }else if(cap == GL_NORMAL_ARRAY) {
+        glEnableVertexAttribArray(pangolin::DEFAULT_LOCATION_NORMAL);
+    }else if(cap == GL_TEXTURE_COORD_ARRAY) {
+        glEnableVertexAttribArray(pangolin::DEFAULT_LOCATION_TEXCOORD);
+        gl.EnableTexturing(true);
+    }else{
+        pango_print_error("Not Implemented: %s, %s, %d", __FUNCTION__, __FILE__, __LINE__);
+    }
+}
+
+inline void glDisableClientState(GLenum cap)
+{
+    pangolin::GlEngine& gl = pangolin::glEngine();
+    if(cap == GL_VERTEX_ARRAY) {
+        glDisableVertexAttribArray(pangolin::DEFAULT_LOCATION_POSITION);
+    }else if(cap == GL_COLOR_ARRAY) {
+        glDisableVertexAttribArray(pangolin::DEFAULT_LOCATION_COLOUR);
+    }else if(cap == GL_NORMAL_ARRAY) {
+        glDisableVertexAttribArray(pangolin::DEFAULT_LOCATION_NORMAL);
+    }else if(cap == GL_TEXTURE_COORD_ARRAY) {
+        glDisableVertexAttribArray(pangolin::DEFAULT_LOCATION_TEXCOORD);
+        gl.EnableTexturing(false);
+    }else{
+        pango_print_error("Not Implemented: %s, %s, %d", __FUNCTION__, __FILE__, __LINE__);
+    }
+}
+
+inline void glVertexPointer( GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
+{
+    glVertexAttribPointer(pangolin::DEFAULT_LOCATION_POSITION, size, type, GL_FALSE, stride, pointer);
+}
+
+inline void glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
+{
+    glVertexAttribPointer(pangolin::DEFAULT_LOCATION_TEXCOORD, size, type, GL_FALSE, stride, pointer);
+}
+
+inline void glMatrixMode(GLenum mode)
+{
+    pangolin::GlEngine& gl = pangolin::glEngine();
+    gl.currentmatrix = (mode == pangolin::GlProjectionStack) ? &gl.projection : &gl.modelview;
+}
+
+inline void glLoadIdentity()
+{
+    pangolin::GlEngine& gl = pangolin::glEngine();
+    gl.currentmatrix->top() = pangolin::IdentityMatrix();
+    gl.UpdateMatrices();
+}
+
+inline void glLoadMatrixf(const GLfloat* m)
+{
+    pangolin::GlEngine& gl = pangolin::glEngine();
+    pangolin::GLprecision* cm = gl.currentmatrix->top().m;
+    for(int i=0; i<16; ++i) cm[i] = (pangolin::GLprecision)m[i];
+    gl.UpdateMatrices();
+}
+
+inline void glLoadMatrixd(const GLdouble* m)
+{
+    pangolin::GlEngine& gl = pangolin::glEngine();
+    pangolin::GLprecision* cm = gl.currentmatrix->top().m;
+    for(int i=0; i<16; ++i) cm[i] = (pangolin::GLprecision)m[i];
+    gl.UpdateMatrices();
+}
+
+inline void glMultMatrixf(const GLfloat* m)
+{
+//    pangolin::GlEngine& gl = pangolin::glEngine();
+//    float res[16];
+//    pangolin::MatMul<4,4,4,float>(res, m, gl.currentmatrix->m );
+//    std::memcpy(gl.currentmatrix->m, res, sizeof(float) * 16 );
+    pango_print_error("Not Implemented: %s, %s, %d", __FUNCTION__, __FILE__, __LINE__);
+}
+
+inline void glMultMatrixd(const GLdouble* m)
+{
+    pango_print_error("Not Implemented: %s, %s, %d", __FUNCTION__, __FILE__, __LINE__);
+}
+
+inline void glPushMatrix(void)
+{
+    pangolin::GlEngine& gl = pangolin::glEngine();
+    gl.currentmatrix->push(gl.currentmatrix->top());
+}
+
+inline void glPopMatrix(void)
+{
+    pangolin::GlEngine& gl = pangolin::glEngine();
+    gl.currentmatrix->pop();
+    gl.UpdateMatrices();
+}
+
+inline void glTranslatef(GLfloat x, GLfloat y, GLfloat z )
+{
+    pangolin::GlEngine& gl = pangolin::glEngine();
+    pangolin::GLprecision* cm = gl.currentmatrix->top().m;
+    cm[12] += x;
+    cm[13] += y;
+    cm[14] += z;
+    gl.UpdateMatrices();
+}
+
+inline void glOrtho(
+    GLdouble l, GLdouble r,
+    GLdouble b, GLdouble t,
+    GLdouble n, GLdouble f)
+{
+    pangolin::GlEngine& gl = pangolin::glEngine();
+    gl.currentmatrix->top() = pangolin::ProjectionMatrixOrthographic(l,r,b,t,n,f);
+    gl.UpdateMatrices();
+}
+
+inline void glColor4f(	GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+{
+    pangolin::glEngine().SetColor(red,green,blue,alpha);
+}
+
+inline void glShadeModel( GLenum mode)
+{
+    pango_print_error("Not Implemented: %s, %s, %d", __FUNCTION__, __FILE__, __LINE__);
+}
+
+inline void glPointSize(GLfloat size)
+{
+    pango_print_error("Not Implemented: %s, %s, %d", __FUNCTION__, __FILE__, __LINE__);
+}
+
+inline void glTexEnvf(	GLenum target,
+    GLenum pname,
+    GLfloat param)
+{
+    pango_print_error("Not Implemented: %s, %s, %d", __FUNCTION__, __FILE__, __LINE__);
+}

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

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <pangolin/platform.h>
+
+#define GLdouble     GLfloat
+#define glClearDepth glClearDepthf
+#define glFrustum    glFrustumf
+
+#define glColor4fv(a)       glColor4f(a[0], a[1], a[2], a[3])
+#define glColor3fv(a)       glColor4f(a[0], a[1], a[2], 1.0f)
+#define glColor3f(a,b,c)    glColor4f(a, b, c, 1.0f)
+
+#define glGenFramebuffersEXT        glGenFramebuffers
+#define glDeleteFramebuffersEXT     glDeleteFramebuffers
+#define glBindFramebufferEXT        glBindFramebuffer
+#define glFramebufferTexture2DEXT   glFramebufferTexture2D
+
+#define glGetDoublev                glGetFloatv
+
+#include <pangolin/gl/compat/gl2engine.h>
+
+inline void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
+{
+    GLfloat verts[] = { x1,y1,  x2,y1,  x2,y2,  x1,y2 };    
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glVertexPointer(2, GL_FLOAT, 0, verts);
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+    glDisableClientState(GL_VERTEX_ARRAY);
+}
+
+inline void glRecti(int x1, int y1, int x2, int y2)
+{
+    GLfloat verts[] = { (float)x1,(float)y1,  (float)x2,(float)y1,
+                        (float)x2,(float)y2,  (float)x1,(float)y2 };    
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glVertexPointer(2, GL_FLOAT, 0, verts);
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+    glDisableClientState(GL_VERTEX_ARRAY);
+}

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

@@ -0,0 +1,296 @@
+/* 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/viewport.h>
+#include <pangolin/gl/glinclude.h>
+#include <pangolin/image/image_io.h>
+
+#if defined(HAVE_EIGEN) && !defined(__CUDACC__) //prevent including Eigen in cuda files
+#define USE_EIGEN
+#endif
+
+#ifdef USE_EIGEN
+#include <Eigen/Core>
+#endif
+
+#include <cstdlib>
+#include <iostream>
+#include <math.h>
+
+namespace pangolin
+{
+
+////////////////////////////////////////////////
+// Interface
+////////////////////////////////////////////////
+
+class PANGOLIN_EXPORT GlTexture
+{
+public:
+    //! internal_format normally one of GL_RGBA8, GL_LUMINANCE8, GL_INTENSITY16
+    GlTexture(GLint width, GLint height, GLint internal_format = GL_RGBA8, bool sampling_linear = true, int border = 0, GLenum glformat = GL_RGBA, GLenum gltype = GL_UNSIGNED_BYTE, GLvoid* data = NULL  );
+
+    // Construct this texture from a CPU image
+    GlTexture(const TypedImage& img, bool sampling_linear=true);
+    
+    //! Move Constructor / asignment
+    GlTexture(GlTexture&& tex);
+    GlTexture& operator=(GlTexture&& tex);
+    
+    //! Default constructor represents 'no texture'
+    GlTexture();
+    virtual ~GlTexture();
+
+    bool IsValid() const;
+
+    //! Delete OpenGL resources and fall back to representing 'no texture'
+    void Delete();
+    
+    //! Reinitialise teture width / height / format
+    virtual void Reinitialise(GLsizei width, GLsizei height, GLint internal_format = GL_RGBA8, bool sampling_linear = true, int border = 0, GLenum glformat = GL_RGBA, GLenum gltype = GL_UNSIGNED_BYTE, GLvoid* data = NULL );
+    
+    void Bind() const;
+    void Unbind() const;
+    
+    //! data_layout normally one of GL_LUMINANCE, GL_RGB, ...
+    //! data_type normally one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, GL_FLOAT
+    void Upload(const void* image, GLenum data_format = GL_LUMINANCE, GLenum data_type = GL_FLOAT);
+    
+    //! Upload data to texture, overwriting a sub-region of it.
+    //! data ptr contains packed data_w x data_h of pixel data.
+    void Upload(const void* data,
+        GLsizei tex_x_offset, GLsizei tex_y_offset,
+        GLsizei data_w, GLsizei data_h,
+        GLenum data_format, GLenum data_type
+    );
+
+    void Load(const TypedImage& image, bool sampling_linear = true);
+
+    void LoadFromFile(const std::string& filename, bool sampling_linear = true);
+
+    void Download(void* image, GLenum data_layout = GL_LUMINANCE, GLenum data_type = GL_FLOAT) const;
+
+    void Download(TypedImage& image) const;
+
+    void CopyFrom(const GlTexture& tex);
+
+    void Save(const std::string& filename, bool top_line_first = true);
+
+    void SetLinear();
+    void SetNearestNeighbour();
+    
+    void RenderToViewport(const bool flip) const;
+    void RenderToViewport() const;
+    void RenderToViewport(Viewport tex_vp, bool flipx=false, bool flipy=false) const;
+    void RenderToViewportFlipY() const;
+    void RenderToViewportFlipXFlipY() const;
+    
+    GLint internal_format;
+    GLuint tid;
+    GLint width;
+    GLint height;
+    
+private:
+    // Private copy constructor
+    GlTexture(const GlTexture&) {}
+};
+
+struct PANGOLIN_EXPORT GlRenderBuffer
+{
+    GlRenderBuffer();
+    GlRenderBuffer(GLint width, GLint height, GLint internal_format = GL_DEPTH_COMPONENT24);
+
+    void Reinitialise(GLint width, GLint height, GLint internal_format = GL_DEPTH_COMPONENT24);
+
+    //! Move Constructor
+    GlRenderBuffer(GlRenderBuffer&& tex);
+
+    ~GlRenderBuffer();
+    
+    GLint width;
+    GLint height;
+    GLuint rbid;
+
+private:
+    // Private copy constructor
+    GlRenderBuffer(const GlRenderBuffer&) {}
+};
+
+struct PANGOLIN_EXPORT GlFramebuffer
+{
+    GlFramebuffer();
+    ~GlFramebuffer();
+    
+    GlFramebuffer(GlTexture& colour);
+    GlFramebuffer(GlTexture& colour, GlRenderBuffer& depth);
+    GlFramebuffer(GlTexture& colour0, GlTexture& colour1, GlRenderBuffer& depth);
+    GlFramebuffer(GlTexture& colour0, GlTexture& colour1, GlTexture& colour2, GlRenderBuffer& depth);
+    GlFramebuffer(GlTexture& colour0, GlTexture& colour1, GlTexture& colour2, GlTexture& colour3, GlRenderBuffer& depth);
+
+    void Bind() const;
+    void Unbind() const;
+
+    void Reinitialise();
+    
+    // Attach Colour texture to frame buffer
+    // Return attachment texture is bound to (e.g. GL_COLOR_ATTACHMENT0_EXT)
+    GLenum AttachColour(GlTexture& tex);
+    
+    // Attach Depth render buffer to frame buffer
+    void AttachDepth(GlRenderBuffer& rb);
+    
+    GLuint fbid;
+    unsigned attachments;
+};
+
+enum GlBufferType
+{
+    GlUndefined = 0,
+    GlArrayBuffer = GL_ARRAY_BUFFER,                    // VBO's, CBO's, NBO's
+    GlElementArrayBuffer = GL_ELEMENT_ARRAY_BUFFER,     // IBO's
+#ifndef HAVE_GLES
+    GlPixelPackBuffer = GL_PIXEL_PACK_BUFFER,           // PBO's
+    GlPixelUnpackBuffer = GL_PIXEL_UNPACK_BUFFER,
+    GlShaderStorageBuffer = GL_SHADER_STORAGE_BUFFER
+#endif
+};
+
+// This encapsulates a GL Buffer object.
+struct PANGOLIN_EXPORT GlBufferData
+{
+    //! Default constructor represents 'no buffer'
+    GlBufferData();
+
+    GlBufferData(GlBufferType buffer_type, GLsizeiptr size_bytes, GLenum gluse = GL_DYNAMIC_DRAW, const void *data = 0 );
+
+    template<typename T>
+    GlBufferData(GlBufferType buffer_type, const std::vector<T>& data, GLenum gluse = GL_STATIC_DRAW);
+
+    virtual ~GlBufferData();
+
+    void Free();
+
+    //! Move Constructor
+    GlBufferData(GlBufferData&& tex);
+    GlBufferData& operator=(GlBufferData&& tex);
+
+    bool IsValid() const;
+
+    GLsizeiptr SizeBytes() const;
+    
+    void Reinitialise(GlBufferType buffer_type, GLsizeiptr size_bytes, GLenum gluse = GL_DYNAMIC_DRAW, const void *data = 0 );
+    
+    void Bind() const;
+    void Unbind() const;
+    void Upload(const GLvoid* data, GLsizeiptr size_bytes, GLintptr offset = 0);
+    void Download(GLvoid* ptr, GLsizeiptr size_bytes, GLintptr offset = 0) const;
+    
+
+    template<typename T>
+    void Upload(const std::vector<T>& data, GLintptr offset = 0);
+
+#ifdef USE_EIGEN
+    template<typename Derived>
+    void Upload(const Eigen::DenseBase<Derived>& data, GLintptr offset = 0);
+#endif
+
+    GLuint bo;
+    GlBufferType buffer_type;
+    GLenum gluse;
+    GLsizeiptr size_bytes;
+
+private:
+    GlBufferData(const GlBufferData&) {}
+};
+
+// This encapsulates a GL Buffer object, also storing information about its contents.
+// You should try to use GlBufferData instead.
+struct PANGOLIN_EXPORT GlBuffer : public GlBufferData
+{
+    //! Default constructor represents 'no buffer'
+    GlBuffer();
+    GlBuffer(GlBufferType buffer_type, GLuint num_elements, GLenum datatype, GLuint count_per_element, GLenum gluse = GL_DYNAMIC_DRAW );
+    GlBuffer(const GlBuffer&) = delete;
+    
+    //! Move Constructor
+    GlBuffer(GlBuffer&& tex);
+    GlBuffer& operator=(GlBuffer&& tex);
+    
+    void Reinitialise(GlBufferType buffer_type, GLuint num_elements, GLenum datatype, GLuint count_per_element, GLenum gluse, const void* data = nullptr );
+    void Reinitialise(GlBuffer const& other );
+    void Resize(GLuint num_elements);
+
+#ifdef USE_EIGEN
+    template<typename Scalar, int R, int C>
+    GlBuffer(GlBufferType buffer_type, const std::vector<Eigen::Matrix<Scalar, R,C>>& data, GLenum gluse = GL_STATIC_DRAW);
+#endif
+            
+    GLenum datatype;
+    GLuint num_elements;
+    GLuint count_per_element;
+};
+
+class PANGOLIN_EXPORT GlSizeableBuffer
+        : public pangolin::GlBuffer
+{
+public:
+    GlSizeableBuffer(pangolin::GlBufferType buffer_type, GLuint initial_num_elements, GLenum datatype, GLuint count_per_element, GLenum gluse = GL_DYNAMIC_DRAW );
+    
+    void Clear();
+    
+#ifdef USE_EIGEN
+    template<typename Derived>
+    void Add(const Eigen::DenseBase<Derived>& vec);
+    
+    template<typename Derived>
+    void Update(const Eigen::DenseBase<Derived>& vec, size_t position = 0);
+#endif
+    
+    size_t start() const;
+    
+    size_t size() const;
+    
+protected:  
+    void CheckResize(size_t num_verts);
+    
+    size_t NextSize(size_t min_size) const;
+    
+    size_t  m_num_verts;    
+};
+
+size_t GlFormatChannels(GLenum data_layout);
+
+size_t GlDataTypeBytes(GLenum type);
+
+TypedImage ReadFramebuffer(const Viewport& v, const std::string& pixel_format = "RGBA32");
+
+}
+
+// Include implementation
+#include <pangolin/gl/gl.hpp>

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

@@ -0,0 +1,956 @@
+/* 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>
+#include <pangolin/gl/glpixformat.h>
+#include <pangolin/image/image_io.h>
+#include <pangolin/utils/type_convert.h>
+#include <algorithm>
+#include <stdexcept>
+#include <assert.h>
+
+namespace pangolin
+{
+
+////////////////////////////////////////////////
+// Implementation of gl.h
+////////////////////////////////////////////////
+
+#ifndef HAVE_GLES
+const int MAX_ATTACHMENTS = 8;
+const static GLuint attachment_buffers[] = {
+    GL_COLOR_ATTACHMENT0_EXT,
+    GL_COLOR_ATTACHMENT1_EXT,
+    GL_COLOR_ATTACHMENT2_EXT,
+    GL_COLOR_ATTACHMENT3_EXT,
+    GL_COLOR_ATTACHMENT4_EXT,
+    GL_COLOR_ATTACHMENT5_EXT,
+    GL_COLOR_ATTACHMENT6_EXT,
+    GL_COLOR_ATTACHMENT7_EXT
+};
+#else // HAVE_GLES
+const int MAX_ATTACHMENTS = 1;
+const static GLuint attachment_buffers[] = {
+    GL_COLOR_ATTACHMENT0_EXT
+};
+#endif // HAVE_GLES
+
+const static size_t datatype_bytes[] = {
+    1, //  #define GL_BYTE 0x1400
+    1, //  #define GL_UNSIGNED_BYTE 0x1401
+    2, //  #define GL_SHORT 0x1402
+    2, //  #define GL_UNSIGNED_SHORT 0x1403
+    4, //  #define GL_INT 0x1404
+    4, //  #define GL_UNSIGNED_INT 0x1405
+    4, //  #define GL_FLOAT 0x1406
+    2, //  #define GL_2_BYTES 0x1407
+    3, //  #define GL_3_BYTES 0x1408
+    4, //  #define GL_4_BYTES 0x1409
+    8  //  #define GL_DOUBLE 0x140A
+};
+
+const static size_t format_channels[] = {
+    1, //  #define GL_RED 0x1903
+    1, //  #define GL_GREEN 0x1904
+    1, //  #define GL_BLUE 0x1905
+    1, //  #define GL_ALPHA 0x1906
+    3, //  #define GL_RGB 0x1907
+    4, //  #define GL_RGBA 0x1908
+    1, //  #define GL_LUMINANCE 0x1909
+    2  //  #define GL_LUMINANCE_ALPHA 0x190A
+};
+
+inline size_t GlDataTypeBytes(GLenum type)
+{
+    return datatype_bytes[type - GL_BYTE];
+}
+
+inline size_t GlFormatChannels(GLenum data_layout)
+{
+    if (data_layout == GL_BGR) return 3;
+    if (data_layout == GL_BGRA) return 4;
+    return format_channels[data_layout - GL_RED];
+}
+
+//template<typename T>
+//struct GlDataTypeTrait {};
+//template<> struct GlDataTypeTrait<float>{ static const GLenum type = GL_FLOAT; };
+//template<> struct GlDataTypeTrait<int>{ static const GLenum type = GL_INT; };
+//template<> struct GlDataTypeTrait<unsigned char>{ static const GLenum type = GL_UNSIGNED_BYTE; };
+
+inline GlTexture::GlTexture()
+    : internal_format(0), tid(0), width(0), height(0)
+{
+    // Not a texture constructor
+}
+
+inline GlTexture::GlTexture(GLint width, GLint height, GLint internal_format, bool sampling_linear, int border, GLenum glformat, GLenum gltype, GLvoid* data )
+    : internal_format(0), tid(0)
+{
+    Reinitialise(width,height,internal_format,sampling_linear,border,glformat,gltype,data);
+}
+
+inline GlTexture::GlTexture(const TypedImage& img, bool sampling_linear)
+{
+    this->Load(img, sampling_linear);
+}
+
+inline GlTexture::GlTexture(GlTexture&& tex)
+{
+    *this = std::move(tex);
+}
+
+inline GlTexture& GlTexture::operator=(GlTexture&& tex)
+{
+    if (&tex != this) {
+        internal_format = tex.internal_format;
+        tid = tex.tid;
+        width = tex.width;
+        height = tex.height;
+        
+        tex.internal_format = 0;
+        tex.tid = 0;
+    }
+    return *this;
+}
+
+inline bool GlTexture::IsValid() const
+{
+    return tid != 0;
+}
+
+inline void GlTexture::Delete()
+{
+    if(internal_format!=0 ) {
+        glDeleteTextures(1,&tid);
+        internal_format = 0;
+        tid = 0;
+        width = 0;
+        height = 0;
+    }
+}
+
+inline GlTexture::~GlTexture()
+{
+    Delete();
+}
+
+inline void GlTexture::Bind() const
+{
+    glBindTexture(GL_TEXTURE_2D, tid);
+}
+
+inline void GlTexture::Unbind() const
+{
+    glBindTexture(GL_TEXTURE_2D, 0);
+}
+
+inline void GlTexture::Reinitialise(GLsizei w, GLsizei h, GLint int_format, bool sampling_linear, int border, GLenum glformat, GLenum gltype, GLvoid* data )
+{
+    if(tid!=0) {
+        glDeleteTextures(1,&tid);
+    }
+
+    internal_format = int_format;
+    width = w;
+    height = h;
+
+    glGenTextures(1,&tid);
+    Bind();
+
+    // GL_LUMINANCE and GL_FLOAT don't seem to actually affect buffer, but some values are required
+    // for call to succeed.
+    glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, border, glformat, gltype, data);
+
+    if(sampling_linear) {
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    }else{
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    }
+
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+    CheckGlDieOnError();
+}
+
+inline void GlTexture::Upload(
+    const void* data,
+    GLenum data_format, GLenum data_type
+) {
+    Bind();
+    glTexSubImage2D(GL_TEXTURE_2D,0,0,0,width,height,data_format,data_type,data);
+    CheckGlDieOnError();
+}
+
+inline void GlTexture::Upload(
+    const void* data,
+    GLsizei tex_x_offset, GLsizei tex_y_offset,
+    GLsizei data_w, GLsizei data_h,
+    GLenum data_format, GLenum data_type )
+{
+    Bind();
+    glTexSubImage2D(GL_TEXTURE_2D,0,tex_x_offset,tex_y_offset,data_w,data_h,data_format,data_type,data);
+    CheckGlDieOnError();
+}
+
+inline void GlTexture::Load(const TypedImage& image, bool sampling_linear)
+{
+    GlPixFormat fmt(image.fmt);
+    Reinitialise((GLint)image.w, (GLint)image.h, GL_RGBA32F, sampling_linear, 0, fmt.glformat, fmt.gltype, image.ptr );
+}
+
+inline void GlTexture::LoadFromFile(const std::string& filename, bool sampling_linear)
+{
+    TypedImage image = LoadImage(filename);
+    Load(image, sampling_linear);
+}
+
+inline void GlTexture::Download(void* image, GLenum data_layout, GLenum data_type) const
+{
+    Bind();
+#ifndef HAVE_GLES
+    glGetTexImage(GL_TEXTURE_2D, 0, data_layout, data_type, image);
+#else
+    throw std::runtime_error("glGetTexImage not implemented on this platform.");
+#endif // HAVE_GLES
+    Unbind();
+}
+
+inline void GlTexture::Download(TypedImage& image) const
+{
+    switch (internal_format)
+    {
+    case GL_LUMINANCE8:
+        image.Reinitialise(width, height, PixelFormatFromString("GRAY8") );
+        Download(image.ptr, GL_LUMINANCE, GL_UNSIGNED_BYTE);
+        break;
+    case GL_LUMINANCE16:
+        image.Reinitialise(width, height, PixelFormatFromString("GRAY16LE") );
+        Download(image.ptr, GL_LUMINANCE, GL_UNSIGNED_SHORT);
+        break;
+    case GL_RGB8:
+        image.Reinitialise(width, height, PixelFormatFromString("RGB24"));
+        Download(image.ptr, GL_RGB, GL_UNSIGNED_BYTE);
+        break;
+    case GL_RGBA8:
+        image.Reinitialise(width, height, PixelFormatFromString("RGBA32"));
+        Download(image.ptr, GL_RGBA, GL_UNSIGNED_BYTE);
+        break;
+    case GL_RED_INTEGER:
+        image.Reinitialise(width, height, PixelFormatFromString("GRAY32") );
+        Download(image.ptr, GL_RED, GL_UNSIGNED_INT);
+        break;
+    case GL_LUMINANCE:
+    case GL_LUMINANCE32F_ARB:
+    case GL_R32F:
+        image.Reinitialise(width, height, PixelFormatFromString("GRAY32F"));
+        Download(image.ptr, GL_LUMINANCE, GL_FLOAT);
+        break;
+    case GL_RGB16:
+        image.Reinitialise(width, height, PixelFormatFromString("RGB48"));
+        Download(image.ptr, GL_RGB, GL_UNSIGNED_SHORT);
+        break;
+    case GL_RGBA16:
+        image.Reinitialise(width, height, PixelFormatFromString("RGBA64"));
+        Download(image.ptr, GL_RGBA, GL_UNSIGNED_SHORT);
+        break;
+    case GL_RGB16F:
+        image.Reinitialise(width, height, PixelFormatFromString("RGB48F"));
+        Download(image.ptr, GL_RGB, GL_HALF_FLOAT);
+        break;
+    case GL_RGBA16F:
+        image.Reinitialise(width, height, PixelFormatFromString("RGBA64F"));
+        Download(image.ptr, GL_RGBA, GL_HALF_FLOAT);
+        break;
+    case GL_RGB:
+    case GL_RGB32F:
+        image.Reinitialise(width, height, PixelFormatFromString("RGB96F"));
+        Download(image.ptr, GL_RGB, GL_FLOAT);
+        break;
+    case GL_RGBA:
+    case GL_RGBA32F:
+        image.Reinitialise(width, height, PixelFormatFromString("RGBA128F"));
+        Download(image.ptr, GL_RGBA, GL_FLOAT);
+        break;
+    case GL_DEPTH_COMPONENT16:
+        image.Reinitialise(width, height, PixelFormatFromString("GRAY16LE"));
+        Download(image.ptr, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT);
+        break;
+    case GL_DEPTH_COMPONENT24:
+        image.Reinitialise(width, height, PixelFormatFromString("GRAY32"));
+        Download(image.ptr, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT);
+        break;
+    case GL_DEPTH_COMPONENT32F:
+        image.Reinitialise(width, height, PixelFormatFromString("GRAY32F"));
+        Download(image.ptr, GL_DEPTH_COMPONENT, GL_FLOAT);
+        break;
+    default:
+        throw std::runtime_error(
+            "GlTexture::Download - Unknown internal format (" +
+            pangolin::Convert<std::string,GLint>::Do(internal_format) +
+            ")"
+        );
+    }
+
+}
+
+inline void GlTexture::CopyFrom(const GlTexture& tex)
+{
+#ifndef HAVE_GLES
+    if(!tid || width != tex.width || height != tex.height ||
+       internal_format != tex.internal_format)
+    {
+        Reinitialise(tex.width, tex.height, tex.internal_format, true);
+    }
+
+    glCopyImageSubDataNV(tex.tid, GL_TEXTURE_2D, 0, 0, 0, 0,
+                       tid, GL_TEXTURE_2D, 0, 0, 0, 0,
+                       width, height, 1);
+    CheckGlDieOnError();
+#else
+    throw std::runtime_error("glCopyImageSubDataNV not implemented on this platform.");
+#endif
+}
+
+inline void GlTexture::Save(const std::string& filename, bool top_line_first)
+{
+    TypedImage image;
+    Download(image);
+    pangolin::SaveImage(image, filename, top_line_first);
+}
+
+inline void GlTexture::SetLinear()
+{
+    Bind();
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    Unbind();
+}
+
+inline void GlTexture::SetNearestNeighbour()
+{
+    Bind();
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    Unbind();
+}
+
+inline void GlTexture::RenderToViewport(const bool flip) const
+{
+    if(flip) {
+        RenderToViewportFlipY();
+    }else{
+        RenderToViewport();
+    }
+}
+
+inline void GlTexture::RenderToViewport() const
+{
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+
+    GLfloat sq_vert[] = { -1,-1,  1,-1,  1, 1,  -1, 1 };
+    glVertexPointer(2, GL_FLOAT, 0, sq_vert);
+    glEnableClientState(GL_VERTEX_ARRAY);
+
+    GLfloat sq_tex[]  = { 0,0,  1,0,  1,1,  0,1  };
+    glTexCoordPointer(2, GL_FLOAT, 0, sq_tex);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+
+#ifndef HAVE_GLES
+    glEnable(GL_TEXTURE_2D);
+#endif
+    Bind();
+
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
+#ifndef HAVE_GLES
+    glDisable(GL_TEXTURE_2D);
+#endif
+}
+
+inline void GlTexture::RenderToViewport(Viewport tex_vp, bool flipx, bool flipy) const
+{
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+
+    GLfloat sq_vert[] = { -1,-1,  1,-1,  1, 1,  -1, 1 };
+    glVertexPointer(2, GL_FLOAT, 0, sq_vert);
+    glEnableClientState(GL_VERTEX_ARRAY);
+
+    GLfloat l = tex_vp.l / (float)(width);
+    GLfloat b = tex_vp.b / (float)(height);
+    GLfloat r = (tex_vp.l+tex_vp.w) / (float)(width);
+    GLfloat t = (tex_vp.b+tex_vp.h) / (float)(height);
+
+    if(flipx) std::swap(l,r);
+    if(flipy) std::swap(b,t);
+
+    GLfloat sq_tex[]  = { l,b,  r,b,  r,t,  l,t };
+    glTexCoordPointer(2, GL_FLOAT, 0, sq_tex);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    glEnable(GL_TEXTURE_2D);
+    Bind();
+
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    glDisable(GL_TEXTURE_2D);
+}
+
+inline void GlTexture::RenderToViewportFlipY() const
+{
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+
+    GLfloat sq_vert[] = { -1,-1,  1,-1,  1, 1,  -1, 1 };
+    glVertexPointer(2, GL_FLOAT, 0, sq_vert);
+    glEnableClientState(GL_VERTEX_ARRAY);
+
+    GLfloat sq_tex[]  = { 0,1,  1,1,  1,0,  0,0  };
+    glTexCoordPointer(2, GL_FLOAT, 0, sq_tex);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    glEnable(GL_TEXTURE_2D);
+    Bind();
+
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    glDisable(GL_TEXTURE_2D);
+}
+
+inline void GlTexture::RenderToViewportFlipXFlipY() const
+{
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+
+    GLfloat sq_vert[] = { 1,1,  -1,1,  -1,-1,  1,-1 };
+    glVertexPointer(2, GL_FLOAT, 0, sq_vert);
+    glEnableClientState(GL_VERTEX_ARRAY);
+
+    GLfloat sq_tex[]  = { 0,0,  1,0,  1,1,  0,1  };
+    glTexCoordPointer(2, GL_FLOAT, 0, sq_tex);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    glEnable(GL_TEXTURE_2D);
+    Bind();
+
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    glDisable(GL_TEXTURE_2D);
+}
+
+////////////////////////////////////////////////////////////////////////////
+
+inline GlRenderBuffer::GlRenderBuffer()
+    : width(0), height(0), rbid(0)
+{
+}
+
+inline GlRenderBuffer::GlRenderBuffer(GLint width, GLint height, GLint internal_format )
+    : width(0), height(0), rbid(0)
+{
+    Reinitialise(width,height,internal_format);
+}
+
+#ifndef HAVE_GLES
+inline void GlRenderBuffer::Reinitialise(GLint width, GLint height, GLint internal_format)
+{
+    if( this->width != 0 ) {
+        glDeleteRenderbuffersEXT(1, &rbid);
+    }
+
+    this->width = width;
+    this->height = height;
+    glGenRenderbuffersEXT(1, &rbid);
+    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rbid);
+    glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, internal_format, width, height);
+    glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
+}
+
+inline GlRenderBuffer::~GlRenderBuffer()
+{
+    if( width!=0 ) {
+        glDeleteRenderbuffersEXT(1, &rbid);
+    }
+}
+#else
+inline void GlRenderBuffer::Reinitialise(GLint width, GLint height, GLint internal_format)
+{
+    if( width!=0 ) {
+        glDeleteTextures(1, &rbid);
+    }
+
+    // Use a texture instead...
+    glGenTextures(1, &rbid);
+    glBindTexture(GL_TEXTURE_2D, rbid);
+
+    glTexImage2D(GL_TEXTURE_2D, 0, internal_format,
+            width, height,
+            0, internal_format, GL_UNSIGNED_SHORT, NULL);
+
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+}
+
+inline GlRenderBuffer::~GlRenderBuffer()
+{
+    // We have no GL context whilst exiting.
+    if( width!=0 ) {
+        glDeleteTextures(1, &rbid);
+    }
+}
+#endif // HAVE_GLES
+
+inline GlRenderBuffer::GlRenderBuffer(GlRenderBuffer&& tex)
+    : width(tex.width), height(tex.height), rbid(tex.rbid)
+{
+    tex.rbid = tex.width = tex.height = 0;
+}
+
+////////////////////////////////////////////////////////////////////////////
+
+inline GlFramebuffer::GlFramebuffer()
+    : fbid(0), attachments(0)
+{
+}
+
+inline GlFramebuffer::~GlFramebuffer()
+{
+    if(fbid) {
+        glDeleteFramebuffersEXT(1, &fbid);
+    }
+}
+
+inline GlFramebuffer::GlFramebuffer(GlTexture& colour)
+    : attachments(0)
+{
+    glGenFramebuffersEXT(1, &fbid);
+    AttachColour(colour);
+    CheckGlDieOnError();
+}
+
+inline GlFramebuffer::GlFramebuffer(GlTexture& colour, GlRenderBuffer& depth)
+    : attachments(0)
+{
+    glGenFramebuffersEXT(1, &fbid);
+    AttachColour(colour);
+    AttachDepth(depth);
+    CheckGlDieOnError();
+}
+
+inline GlFramebuffer::GlFramebuffer(GlTexture& colour0, GlTexture& colour1, GlRenderBuffer& depth)
+    : attachments(0)
+{
+    glGenFramebuffersEXT(1, &fbid);
+    AttachColour(colour0);
+    AttachColour(colour1);
+    AttachDepth(depth);
+    CheckGlDieOnError();
+}
+
+inline GlFramebuffer::GlFramebuffer(GlTexture& colour0, GlTexture& colour1, GlTexture& colour2, GlRenderBuffer& depth)
+    : attachments(0)
+{
+    glGenFramebuffersEXT(1, &fbid);
+    AttachColour(colour0);
+    AttachColour(colour1);
+    AttachColour(colour2);
+    AttachDepth(depth);
+    CheckGlDieOnError();
+}
+
+inline GlFramebuffer::GlFramebuffer(GlTexture& colour0, GlTexture& colour1, GlTexture& colour2, GlTexture& colour3, GlRenderBuffer& depth)
+    : attachments(0)
+{
+    glGenFramebuffersEXT(1, &fbid);
+    AttachColour(colour0);
+    AttachColour(colour1);
+    AttachColour(colour2);
+    AttachColour(colour3);
+    AttachDepth(depth);
+    CheckGlDieOnError();
+}
+
+inline void GlFramebuffer::Bind() const
+{
+    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbid);
+    glDrawBuffers( attachments, attachment_buffers );
+}
+
+inline void GlFramebuffer::Reinitialise()
+{
+    if(fbid) {
+        glDeleteFramebuffersEXT(1, &fbid);
+    }
+    glGenFramebuffersEXT(1, &fbid);
+}
+
+inline void GlFramebuffer::Unbind() const
+{
+    glDrawBuffers( 1, attachment_buffers );
+    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+}
+
+inline GLenum GlFramebuffer::AttachColour(GlTexture& tex )
+{
+    if(!fbid) Reinitialise();
+
+    const GLenum color_attachment = GL_COLOR_ATTACHMENT0_EXT + attachments;
+    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbid);
+    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, color_attachment, GL_TEXTURE_2D, tex.tid, 0);
+    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+    attachments++;
+    CheckGlDieOnError();
+    return color_attachment;
+}
+
+inline void GlFramebuffer::AttachDepth(GlRenderBuffer& rb )
+{
+    if(!fbid) Reinitialise();
+
+    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbid);
+#if !defined(HAVE_GLES)
+    glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rb.rbid);
+#elif defined(HAVE_GLES_2)
+    glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, rb.rbid, 0);
+#else
+    throw std::exception();
+#endif
+    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
+    CheckGlDieOnError();
+}
+
+////////////////////////////////////////////////////////////////////////////
+
+inline GlBufferData::GlBufferData()
+    : bo(0)
+{
+}
+
+inline GlBufferData::GlBufferData(GlBufferType buffer_type, GLsizeiptr size_bytes, GLenum gluse, const void* data )
+    : bo(0)
+{
+    Reinitialise(buffer_type, size_bytes, gluse, data );
+}
+
+template<typename T>
+GlBufferData::GlBufferData(GlBufferType buffer_type, const std::vector<T>& data, GLenum gluse)
+    : bo(0)
+{
+    Reinitialise(buffer_type, data.size()*sizeof(T), gluse, &data[0]);
+}
+
+//! Move Constructor
+inline GlBufferData::GlBufferData(GlBufferData&& tex)
+    : bo(0)
+{
+    *this = std::move(tex);
+}
+
+inline GlBufferData& GlBufferData::operator=(GlBufferData&& tex)
+{
+    Free();
+    this->bo = tex.bo;
+    this->buffer_type = tex.buffer_type;
+    this->gluse = tex.gluse;
+    this->size_bytes = tex.size_bytes;
+    tex.bo = 0;
+    return *this;
+}
+
+inline GlBufferData::~GlBufferData()
+{
+    Free();
+}
+
+inline void GlBufferData::Free()
+{
+    if(bo!=0) {
+        glDeleteBuffers(1, &bo);
+    }
+}
+
+inline bool GlBufferData::IsValid() const
+{
+    return bo != 0;
+}
+
+inline GLsizeiptr GlBufferData::SizeBytes() const
+{
+    return size_bytes;
+}
+
+inline void GlBufferData::Reinitialise(GlBufferType buffer_type, GLsizeiptr size_bytes, GLenum gluse, const void* data )
+{
+    if(!bo) {
+        glGenBuffers(1, &bo);
+    }
+
+    this->buffer_type = buffer_type;
+    this->gluse = gluse;
+    this->size_bytes = size_bytes;
+
+    Bind();
+    glBufferData(buffer_type, size_bytes, data, gluse);
+    Unbind();
+}
+
+inline void GlBufferData::Bind() const
+{
+    glBindBuffer(buffer_type, bo);
+}
+
+inline void GlBufferData::Unbind() const
+{
+    glBindBuffer(buffer_type, 0);
+}
+
+inline void GlBufferData::Upload(const GLvoid* data, GLsizeiptr size_bytes, GLintptr offset)
+{
+    if(offset + size_bytes > this->size_bytes) {
+        throw std::runtime_error("GlBufferData: Trying to upload past capacity.");
+    }
+
+    Bind();
+    glBufferSubData(buffer_type,offset,size_bytes,data);
+    Unbind();
+}
+
+inline void GlBufferData::Download(GLvoid* data, GLsizeiptr size_bytes, GLintptr offset) const
+{
+    Bind();
+    glGetBufferSubData(buffer_type, offset, size_bytes, data);
+    Unbind();
+}
+
+template<typename T>
+inline void GlBufferData::Upload(const std::vector<T>& data, GLintptr offset)
+{
+    const size_t total_bytes = data.size() * sizeof(T);
+    assert(offset + total_bytes <= size_bytes);
+    Upload(&data[0], total_bytes, offset);
+}
+
+#ifdef USE_EIGEN
+template<typename Derived>
+inline void GlBufferData::Upload(const Eigen::DenseBase<Derived>& data, GLintptr offset)
+{
+    const size_t num_elements = data.outerSize();
+    const size_t matrix_bytes = data.outerStride() * num_elements;
+    assert(offset + matrix_bytes <= size_bytes);
+    Upload(data.data(), matrix_bytes, offset);
+}
+#endif
+
+////////////////////////////////////////////////////////////////////////////
+
+inline GlBuffer::GlBuffer()
+    : GlBufferData(), datatype(0), num_elements(0), count_per_element(0)
+{
+}
+
+inline GlBuffer::GlBuffer(GlBufferType buffer_type, GLuint num_elements, GLenum datatype, GLuint count_per_element, GLenum gluse )
+    : GlBufferData(buffer_type, GLuint(num_elements * count_per_element * GlDataTypeBytes(datatype)), gluse),
+      datatype(datatype), num_elements(num_elements), count_per_element(count_per_element)
+{
+}
+
+
+inline GlBuffer::GlBuffer(GlBuffer&& o)
+    : GlBufferData()
+{
+    *this = std::move(o);
+}
+
+inline GlBuffer& GlBuffer::operator=(GlBuffer&& o)
+{
+    datatype = o.datatype;
+    num_elements = o.num_elements;
+    count_per_element = o.count_per_element;
+    GlBufferData::operator =(std::move(o));
+    return *this;
+}
+
+inline void GlBuffer::Reinitialise(GlBufferType buffer_type, GLuint num_elements, GLenum datatype, GLuint count_per_element, GLenum gluse, const void *data )
+{
+    this->datatype = datatype;
+    this->num_elements = num_elements;
+    this->count_per_element = count_per_element;
+    const GLuint size_bytes = GLuint(num_elements * count_per_element * GlDataTypeBytes(datatype));
+    GlBufferData::Reinitialise(buffer_type, size_bytes, gluse, data);
+}
+
+inline void GlBuffer::Reinitialise(GlBuffer const& other )
+{
+    Reinitialise(other.buffer_type, other.num_elements, other.datatype, other.count_per_element, other.gluse);
+}
+
+inline void GlBuffer::Resize(GLuint new_num_elements)
+{
+    if(bo!=0 && num_elements > 0) {
+#ifndef HAVE_GLES
+        // Backup current data, reinit memory, restore old data
+        const size_t backup_elements = std::min(new_num_elements,num_elements);
+        const size_t backup_size_bytes = backup_elements*GlDataTypeBytes(datatype)*count_per_element;
+        unsigned char* backup = new unsigned char[backup_size_bytes];
+        Bind();
+        glGetBufferSubData(buffer_type, 0, backup_size_bytes, backup);
+        glBufferData(buffer_type, new_num_elements*GlDataTypeBytes(datatype)*count_per_element, 0, gluse);
+        glBufferSubData(buffer_type, 0, backup_size_bytes, backup);
+        Unbind();
+        delete[] backup;
+#else
+        throw std::exception();
+#endif
+    }else{
+        Reinitialise(buffer_type, new_num_elements, datatype, count_per_element, gluse);
+    }
+    num_elements = new_num_elements;
+}
+
+#ifdef USE_EIGEN
+    template<typename Scalar, int R, int C>
+    GlBuffer::GlBuffer(GlBufferType buffer_type, const std::vector<Eigen::Matrix<Scalar, R,C>>& data, GLenum gluse)
+        : GlBufferData(buffer_type, data, gluse)
+    {
+        typedef typename Eigen::Matrix<Scalar, R,C> Element;
+        static_assert( Element::SizeAtCompileTime != Eigen::Dynamic, "No Dynamically sized elements.");
+        static_assert( Element::SizeAtCompileTime * sizeof(Scalar) == sizeof(Element), "No padded elements.");
+
+        datatype = pangolin::GlFormatTraits<Scalar>::gltype;
+        num_elements = data.size();
+        count_per_element = Element::SizeAtCompileTime;
+    }
+#endif
+
+////////////////////////////////////////////////////////////////////////////
+
+inline GlSizeableBuffer::GlSizeableBuffer(GlBufferType buffer_type, GLuint initial_num_elements, GLenum datatype, GLuint count_per_element, GLenum gluse )
+    : GlBuffer(buffer_type, initial_num_elements, datatype, count_per_element, gluse), m_num_verts(0)
+{
+
+}
+
+inline void GlSizeableBuffer::Clear()
+{
+    m_num_verts = 0;
+}
+
+#ifdef USE_EIGEN
+template<typename Derived> inline
+void GlSizeableBuffer::Add(const Eigen::DenseBase<Derived>& vec)
+{
+    typedef typename Eigen::DenseBase<Derived>::Scalar Scalar;
+    assert(vec.rows()==GlBuffer::count_per_element);
+    CheckResize(m_num_verts + 1);
+    // TODO: taking address of first element is really dodgey. Need to work out
+    // when this is okay!
+    Upload(&vec(0,0), sizeof(Scalar)*vec.rows()*vec.cols(), sizeof(Scalar)*vec.rows()*m_num_verts);
+    m_num_verts += vec.cols();
+}
+
+template<typename Derived> inline
+void GlSizeableBuffer::Update(const Eigen::DenseBase<Derived>& vec, size_t position )
+{
+    typedef typename Eigen::DenseBase<Derived>::Scalar Scalar;
+    assert(vec.rows()==GlBuffer::count_per_element);
+    CheckResize(position + vec.cols() );
+    // TODO: taking address of first element is really dodgey. Need to work out
+    // when this is okay!
+    Upload(&vec(0,0), sizeof(Scalar)*vec.rows()*vec.cols(), sizeof(Scalar)*vec.rows()*position );
+    m_num_verts = std::max(position+vec.cols(), m_num_verts);
+}
+#endif
+
+inline size_t GlSizeableBuffer::start() const {
+    return 0;
+}
+
+inline size_t GlSizeableBuffer::size() const {
+    return m_num_verts;
+}
+
+inline void GlSizeableBuffer::CheckResize(size_t num_verts)
+{
+    if( num_verts > GlBuffer::num_elements) {
+        const size_t new_size = NextSize(num_verts);
+        GlBuffer::Resize((GLuint)new_size);
+    }
+}
+
+inline size_t GlSizeableBuffer::NextSize(size_t min_size) const
+{
+    size_t new_size = std::max(GlBuffer::num_elements, 1u);
+    while(new_size < min_size) {
+        new_size *= 2;
+    }
+    return new_size;
+}
+
+////////////////////////////////////////////////////////////////////////////
+
+inline TypedImage ReadFramebuffer(const Viewport& v, const std::string& pixel_format)
+{
+    const PixelFormat fmt = PixelFormatFromString(pixel_format);
+    const GlPixFormat glfmt(fmt);
+
+    TypedImage buffer(v.w, v.h, fmt );
+    glReadBuffer(GL_BACK);
+    glPixelStorei(GL_PACK_ALIGNMENT, 1);
+    glReadPixels(v.l, v.b, v.w, v.h, glfmt.glformat, glfmt.gltype, buffer.ptr );
+    return buffer;
+}
+
+}

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

@@ -0,0 +1,78 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/gl/glplatform.h>
+#include <map>
+
+namespace pangolin {
+
+struct PANGOLIN_EXPORT XYUV
+{
+    XYUV() {}
+    XYUV(GLfloat x, GLfloat y, GLfloat tu, GLfloat tv)
+        : x(x), y(y), tu(tu), tv(tv) {}
+
+    XYUV operator+(float dx) const {
+        return XYUV(x+dx,y,tu,tv);
+    }
+    
+    GLfloat x, y, tu, tv;
+};
+
+class PANGOLIN_EXPORT GlChar
+{
+public:
+    GlChar();
+    GlChar(int tw, int th, int x, int y, int w, int h, GLfloat x_step, GLfloat ox, GLfloat oy);
+    
+    inline const XYUV& GetVert(size_t i) const {
+        return vs[i];
+    }    
+    
+    inline GLfloat StepX() const {
+        return x_step;
+    }
+
+    inline GLfloat YMin() const {
+        return y_min;
+    }
+
+    inline GLfloat YMax() const {
+        return y_max;
+    }
+
+    void Draw() const;
+        
+protected:
+    XYUV vs[4];
+    GLfloat x_step;
+    GLfloat y_min, y_max;
+};
+
+}

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

@@ -0,0 +1,259 @@
+/* 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 <algorithm>
+#include <cuda_runtime.h>
+
+#include "gl.h"
+// Must include glew.h before gl.h
+#include <cuda_gl_interop.h>
+
+namespace pangolin
+{
+
+////////////////////////////////////////////////
+// Interface
+////////////////////////////////////////////////
+
+struct GlBufferCudaPtr : public GlBuffer
+{
+    //! Default constructor represents 'no buffer'
+    GlBufferCudaPtr();
+    
+    GlBufferCudaPtr(GlBufferType buffer_type, GLuint size_bytes, unsigned int cudause /*= cudaGraphicsMapFlagsNone*/, GLenum gluse /*= GL_DYNAMIC_DRAW*/ );
+    GlBufferCudaPtr(GlBufferType buffer_type, GLuint num_elements, GLenum datatype, GLuint count_per_element, unsigned int cudause /*= cudaGraphicsMapFlagsNone*/, GLenum gluse /*= GL_DYNAMIC_DRAW*/ );
+    
+    PANGOLIN_DEPRECATED("Please use GlBufferCudaPtr(buffer_type, width*height, datatype,...) instead")
+    GlBufferCudaPtr(GlBufferType buffer_type, GLuint width, GLuint height, GLenum datatype, GLuint count_per_element, unsigned int cudause /*= cudaGraphicsMapFlagsNone*/, GLenum gluse /*= GL_DYNAMIC_DRAW*/ );
+    
+    ~GlBufferCudaPtr();
+    
+    void Reinitialise(GlBufferType buffer_type, GLuint size_bytes, unsigned int cudause /*= cudaGraphicsMapFlagsNone*/, GLenum gluse /*= GL_DYNAMIC_DRAW*/ );
+    void Reinitialise(GlBufferType buffer_type, GLuint num_elements, GLenum datatype, GLuint count_per_element, unsigned int cudause /*= cudaGraphicsMapFlagsNone*/, GLenum gluse /*= GL_DYNAMIC_DRAW*/ );
+
+    /**
+     * Use parameters from another @c GlBufferCudaPtr to initialize this buffer.
+     */
+    void Reinitialise(const GlBufferCudaPtr& other);
+    
+    unsigned int cuda_use;
+    cudaGraphicsResource* cuda_res;
+};
+
+struct GlTextureCudaArray : GlTexture
+{
+    GlTextureCudaArray();
+    // Some internal_formats aren't accepted. I have trouble with GL_RGB8
+    GlTextureCudaArray(int width, int height, GLint internal_format, bool sampling_linear = true, int border = 0, GLenum glformat = GL_RGBA, GLenum gltype = GL_UNSIGNED_BYTE, GLvoid* data = NULL);
+    ~GlTextureCudaArray();
+
+    void Reinitialise(int width, int height, GLint internal_format, bool sampling_linear = true, int border = 0, GLenum glformat = GL_RGBA, GLenum gltype = GL_UNSIGNED_BYTE, GLvoid* data = NULL) override;
+    cudaGraphicsResource* cuda_res;
+};
+
+struct CudaScopedMappedPtr
+{
+    CudaScopedMappedPtr(const GlBufferCudaPtr& buffer);
+    ~CudaScopedMappedPtr();
+    void* operator*();
+    cudaGraphicsResource* res;
+    
+private:
+    CudaScopedMappedPtr(const CudaScopedMappedPtr&) {}
+};
+
+struct CudaScopedMappedArray
+{
+    CudaScopedMappedArray(const GlTextureCudaArray& tex);
+    ~CudaScopedMappedArray();
+    cudaArray* operator*();
+    cudaGraphicsResource* res;
+    
+private:
+    CudaScopedMappedArray(const CudaScopedMappedArray&) {}
+};
+
+void CopyPboToTex(GlBufferCudaPtr& buffer, GlTexture& tex);
+
+void swap(GlBufferCudaPtr& a, GlBufferCudaPtr& b);
+
+////////////////////////////////////////////////
+// Implementation
+////////////////////////////////////////////////
+
+inline GlBufferCudaPtr::GlBufferCudaPtr()
+    : cuda_res(0)
+{
+}
+
+inline GlBufferCudaPtr::GlBufferCudaPtr(GlBufferType buffer_type, GLuint size_bytes, unsigned int cudause /*= cudaGraphicsMapFlagsNone*/, GLenum gluse /*= GL_DYNAMIC_DRAW*/ )
+    : cuda_res(0)
+{
+    Reinitialise(buffer_type, size_bytes, cudause, gluse);
+}
+
+inline GlBufferCudaPtr::GlBufferCudaPtr(GlBufferType buffer_type, GLuint num_elements, GLenum datatype, GLuint count_per_element, unsigned int cudause, GLenum gluse )
+    : cuda_res(0)
+{
+    Reinitialise(buffer_type, num_elements, datatype, count_per_element, cudause, gluse);
+}
+
+inline GlBufferCudaPtr::GlBufferCudaPtr(GlBufferType buffer_type, GLuint width, GLuint height, GLenum datatype, GLuint count_per_element, unsigned int cudause /*= cudaGraphicsMapFlagsNone*/, GLenum gluse /*= GL_DYNAMIC_DRAW*/ )
+    : cuda_res(0)
+{
+    Reinitialise(buffer_type, width*height, datatype, count_per_element, cudause, gluse);
+}
+
+inline GlBufferCudaPtr::~GlBufferCudaPtr()
+{
+    if(cuda_res) {    
+        cudaGraphicsUnregisterResource(cuda_res);
+    }
+}
+
+inline void GlBufferCudaPtr::Reinitialise(GlBufferType buffer_type, GLuint size_bytes, unsigned int cudause /*= cudaGraphicsMapFlagsNone*/, GLenum gluse /*= GL_DYNAMIC_DRAW*/ )
+{
+    GlBufferCudaPtr::Reinitialise(buffer_type, size_bytes, GL_BYTE, 1, cudause, gluse);
+}
+
+inline void GlBufferCudaPtr::Reinitialise(GlBufferType buffer_type, GLuint num_elements, GLenum datatype, GLuint count_per_element, unsigned int cudause /*= cudaGraphicsMapFlagsNone*/, GLenum gluse /*= GL_DYNAMIC_DRAW*/ )
+{
+    if(cuda_res) {
+        cudaGraphicsUnregisterResource(cuda_res);
+    }
+    GlBuffer::Reinitialise(buffer_type, num_elements, datatype, count_per_element, gluse);
+
+    cuda_use = cudause;
+    cudaGraphicsGLRegisterBuffer( &cuda_res, bo, cudause );    
+}
+
+inline void GlBufferCudaPtr::Reinitialise(const GlBufferCudaPtr& other)
+{
+  Reinitialise(other.buffer_type, other.num_elements, other.datatype, other.count_per_element, other.cuda_use, other.gluse);
+}
+
+inline GlTextureCudaArray::GlTextureCudaArray()
+    : GlTexture(), cuda_res(0)
+{
+    // Not a texture
+}
+
+inline GlTextureCudaArray::GlTextureCudaArray(int width, int height, GLint internal_format, bool sampling_linear, int border, GLenum glformat, GLenum gltype, GLvoid *data)
+    :GlTexture(width,height,internal_format, sampling_linear, border, glformat, gltype, data)
+{
+    // TODO: specify flags too
+    const cudaError_t err = cudaGraphicsGLRegisterImage(&cuda_res, tid, GL_TEXTURE_2D, cudaGraphicsMapFlagsNone);
+    if( err != cudaSuccess ) {
+        std::cout << "cudaGraphicsGLRegisterImage failed: " << err << std::endl;
+    }
+}
+
+inline GlTextureCudaArray::~GlTextureCudaArray()
+{
+    if(cuda_res) {
+        cudaGraphicsUnregisterResource(cuda_res);
+    }
+}
+
+inline void GlTextureCudaArray::Reinitialise(int width, int height, GLint internal_format, bool sampling_linear, int border, GLenum glformat, GLenum gltype, GLvoid* data)
+{
+    if(cuda_res) {
+        cudaGraphicsUnregisterResource(cuda_res);
+    }
+
+    GlTexture::Reinitialise(width, height, internal_format, sampling_linear, border, glformat, gltype, data);
+
+    const cudaError_t err = cudaGraphicsGLRegisterImage(&cuda_res, tid, GL_TEXTURE_2D, cudaGraphicsMapFlagsNone);
+    if( err != cudaSuccess ) {
+        std::cout << "cudaGraphicsGLRegisterImage failed: " << err << std::endl;
+    }
+}
+
+inline CudaScopedMappedPtr::CudaScopedMappedPtr(const GlBufferCudaPtr& buffer)
+    : res(buffer.cuda_res)
+{
+    cudaGraphicsMapResources(1, &res, 0);
+}
+
+inline CudaScopedMappedPtr::~CudaScopedMappedPtr()
+{
+    cudaGraphicsUnmapResources(1, &res, 0);
+}
+
+inline void* CudaScopedMappedPtr::operator*()
+{
+    size_t num_bytes;
+    void* d_ptr;
+    cudaGraphicsResourceGetMappedPointer(&d_ptr,&num_bytes,res);
+    return d_ptr;
+}
+
+inline CudaScopedMappedArray::CudaScopedMappedArray(const GlTextureCudaArray& tex)
+    : res(tex.cuda_res)
+{
+    cudaGraphicsMapResources(1, &res);
+}
+
+inline CudaScopedMappedArray::~CudaScopedMappedArray()
+{
+    cudaGraphicsUnmapResources(1, &res);
+}
+
+inline cudaArray* CudaScopedMappedArray::operator*()
+{
+    cudaArray* array;
+    cudaGraphicsSubResourceGetMappedArray(&array, res, 0, 0);
+    return array;
+}
+
+inline void CopyPboToTex(const GlBufferCudaPtr& buffer, GlTexture& tex, GLenum buffer_layout, GLenum buffer_data_type )
+{
+    buffer.Bind();
+    tex.Bind();
+    glTexImage2D(GL_TEXTURE_2D, 0, tex.internal_format, tex.width, tex.height, 0, buffer_layout, buffer_data_type, 0);
+    buffer.Unbind();
+    tex.Unbind();
+}
+
+template<typename T>
+inline void CopyDevMemtoTex(T* d_img, size_t pitch, GlTextureCudaArray& tex )
+{
+    CudaScopedMappedArray arr_tex(tex);
+    cudaMemcpy2DToArray(*arr_tex, 0, 0, d_img, pitch, tex.width*sizeof(T), tex.height, cudaMemcpyDeviceToDevice );
+}
+
+inline void swap(GlBufferCudaPtr& a, GlBufferCudaPtr& b)
+{
+    std::swap(a.bo, b.bo);
+    std::swap(a.cuda_res, b.cuda_res);
+    std::swap(a.buffer_type, b.buffer_type);
+}
+
+
+}

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

@@ -0,0 +1,518 @@
+/* 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>
+#include <pangolin/gl/glformattraits.h>
+#include <pangolin/gl/opengl_render_state.h>
+
+#include <vector>
+#include <math.h>
+
+#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 // USE_EIGEN
+
+namespace pangolin
+{
+
+// h [0,360)
+// s [0,1]
+// v [0,1]
+inline void glColorHSV( GLfloat hue, GLfloat s=1.0f, GLfloat v=1.0f )
+{
+    const GLfloat h = hue / 60.0f;
+    const int i = (int)floor(h);
+    const GLfloat f = (i%2 == 0) ? 1-(h-i) : h-i;
+    const GLfloat m = v * (1-s);
+    const GLfloat n = v * (1-s*f);
+    switch(i)
+    {
+    case 0: glColor4f(v,n,m,1); break;
+    case 1: glColor4f(n,v,m,1); break;
+    case 2: glColor4f(m,v,n,1); break;
+    case 3: glColor4f(m,n,v,1); break;
+    case 4: glColor4f(n,m,v,1); break;
+    case 5: glColor4f(v,m,n,1); break;
+    default:
+        break;
+    }
+}
+
+inline void glColorBin( int bin, int max_bins, GLfloat sat=1.0f, GLfloat val=1.0f )
+{
+    if( bin >= 0 ) {
+        const GLfloat hue = (GLfloat)(bin%max_bins) * 360.0f / (GLfloat)max_bins;
+        glColorHSV(hue,sat,val);
+    }else{
+        glColor4f(1,1,1,1);
+    }
+}
+
+template<typename T>
+inline void glDrawVertices(
+    size_t num_vertices, const T* const vertex_ptr, GLenum mode,
+    size_t elements_per_vertex = GlFormatTraits<T>::components,
+    size_t vertex_stride_bytes = 0 )
+{
+    if(num_vertices > 0)
+    {
+        PANGO_ENSURE(vertex_ptr != nullptr);
+        PANGO_ENSURE(mode != GL_LINES || num_vertices % 2 == 0, "number of vertices (%) must be even in GL_LINES mode", num_vertices );
+
+        glVertexPointer((GLint)elements_per_vertex, GlFormatTraits<T>::gltype, (GLsizei)vertex_stride_bytes, vertex_ptr);
+        glEnableClientState(GL_VERTEX_ARRAY);
+        glDrawArrays(mode, 0, (GLsizei)num_vertices);
+        glDisableClientState(GL_VERTEX_ARRAY);
+    }
+}
+
+template<typename TV, typename TC>
+inline void glDrawColoredVertices(
+    size_t num_vertices, const TV* const vertex_ptr, const TC* const color_ptr, GLenum mode,
+    size_t elements_per_vertex = GlFormatTraits<TV>::components,
+    size_t elements_per_color = GlFormatTraits<TC>::components,
+    size_t vertex_stride_bytes = 0,
+    size_t color_stride_bytes = 0
+) {
+    if(color_ptr) {
+        glColorPointer((GLint)elements_per_color, GlFormatTraits<TC>::gltype, (GLsizei)color_stride_bytes, color_ptr);
+        glEnableClientState(GL_COLOR_ARRAY);
+        glDrawVertices<TV>(num_vertices, vertex_ptr, mode, elements_per_vertex, vertex_stride_bytes);
+        glDisableClientState(GL_COLOR_ARRAY);
+    }else{
+        glDrawVertices<TV>(num_vertices, vertex_ptr, mode, elements_per_vertex, vertex_stride_bytes);
+    }
+}
+
+inline void glDrawLine( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
+{
+    const GLfloat verts[] = { x1,y1,  x2,y2 };
+    glDrawVertices<float>(2, verts, GL_LINES, 2);
+}
+
+inline void glDrawLine( GLfloat x1, GLfloat y1, GLfloat z1, GLfloat x2, GLfloat y2, GLfloat z2)
+{
+    const GLfloat verts[] = { x1,y1,z1,  x2,y2,z2 };
+    glDrawVertices<float>(2, verts, GL_LINES, 3);
+}
+
+inline void glDrawCross( GLfloat x, GLfloat y, GLfloat rad )
+{
+    const GLfloat verts[] = { x-rad,y, x+rad, y, x,y-rad, x, y+rad};
+    glDrawVertices<float>(4, verts, GL_LINES, 2);
+}
+
+inline void glDrawCross( GLfloat x, GLfloat y, GLfloat z, GLfloat rad )
+{
+    const GLfloat verts[] = { x-rad,y,z, x+rad,y,z, x,y-rad,z, x,y+rad,z, x,y,z-rad, x,y,z+rad };
+    glDrawVertices<float>(6, verts, GL_LINES, 3);
+}
+
+inline void glDrawAxis(float s)
+{
+    const GLfloat cols[]  = { 1,0,0, 1,0,0, 0,1,0, 0,1,0, 0,0,1, 0,0,1 };
+    const GLfloat verts[] = { 0,0,0, s,0,0, 0,0,0, 0,s,0, 0,0,0, 0,0,s };
+    glDrawColoredVertices<float,float>(6, verts, cols, GL_LINES, 3, 3);
+}
+
+inline void glDrawRect( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2, GLenum mode = GL_TRIANGLE_FAN )
+{
+    const GLfloat verts[] = { x1,y1,  x2,y1,  x2,y2,  x1,y2 };
+    glDrawVertices<float>(4, verts, mode, 2);
+}
+
+inline void glDrawRectPerimeter( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
+{
+    glDrawRect(x1,y1, x2,y2, GL_LINE_LOOP);
+}
+
+inline void glDrawCirclePerimeter( float x, float y, float rad )
+{
+    const int N = 50;
+    GLfloat verts[N*2];
+
+    const float TAU_DIV_N = 2*(float)M_PI/N;
+    for(int i = 0; i < N*2; i+=2) {
+        verts[i] =   x + rad * cos(i*TAU_DIV_N);
+        verts[i+1] = y + rad * sin(i*TAU_DIV_N);
+    }
+
+    glDrawVertices<float>(N, verts, GL_LINES, 2);
+}
+
+inline void glDrawCircle( GLfloat x, GLfloat y, GLfloat rad )
+{    
+    const int N = 50;
+    GLfloat verts[N*2];
+    
+    // Draw vertices anticlockwise for front face
+    const float TAU_DIV_N = 2*(float)M_PI/N;
+    for(int i = 0; i < N*2; i+=2) {
+        verts[i] =   x + rad * cos(-i*TAU_DIV_N);
+        verts[i+1] = y + rad * sin(-i*TAU_DIV_N);
+    }
+    
+    // Render filled shape and outline (to make it look smooth)
+    glVertexPointer(2, GL_FLOAT, 0, verts);
+    glEnableClientState(GL_VERTEX_ARRAY);
+    glDrawArrays(GL_TRIANGLE_FAN, 0, N);
+    glDrawArrays(GL_LINE_STRIP, 0, N);
+    glDisableClientState(GL_VERTEX_ARRAY);
+}
+
+inline void glDrawColouredCube(GLfloat axis_min=-0.5f, GLfloat axis_max = +0.5f)
+{
+    const GLfloat l = axis_min;
+    const GLfloat h = axis_max;
+    
+    const GLfloat verts[] = {
+        l,l,h,  h,l,h,  l,h,h,  h,h,h,  // FRONT
+        l,l,l,  l,h,l,  h,l,l,  h,h,l,  // BACK
+        l,l,h,  l,h,h,  l,l,l,  l,h,l,  // LEFT
+        h,l,l,  h,h,l,  h,l,h,  h,h,h,  // RIGHT
+        l,h,h,  h,h,h,  l,h,l,  h,h,l,  // TOP
+        l,l,h,  l,l,l,  h,l,h,  h,l,l   // BOTTOM
+    };
+    
+    glVertexPointer(3, GL_FLOAT, 0, verts);
+    glEnableClientState(GL_VERTEX_ARRAY);
+    
+    glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+    glDrawArrays(GL_TRIANGLE_STRIP, 4, 4);
+    
+    glColor4f(0.0f, 1.0f, 0.0f, 1.0f);
+    glDrawArrays(GL_TRIANGLE_STRIP, 8, 4);
+    glDrawArrays(GL_TRIANGLE_STRIP, 12, 4);
+    
+    glColor4f(0.0f, 0.0f, 1.0f, 1.0f);
+    glDrawArrays(GL_TRIANGLE_STRIP, 16, 4);
+    glDrawArrays(GL_TRIANGLE_STRIP, 20, 4);
+    
+    glDisableClientState(GL_VERTEX_ARRAY);
+}
+
+inline void glDraw_x0(GLfloat scale, int grid)
+{
+    const GLfloat maxord = grid*scale;
+    for (int i = -grid; i <= grid; ++i) {
+        glDrawLine(0.0, i*scale, -maxord, 0.0, i*scale, +maxord);
+        glDrawLine(0.0, -maxord, i*scale, 0.0, +maxord, i*scale);
+    }
+}
+
+inline void glDraw_y0(GLfloat scale, int grid)
+{
+    const GLfloat maxord = grid*scale;
+    for (int i = -grid; i <= grid; ++i) {
+        glDrawLine(i*scale, 0.0, -maxord, i*scale, 0.0, +maxord);
+        glDrawLine(-maxord, 0.0, i*scale, +maxord, 0.0, i*scale);
+    }
+}
+
+inline void glDraw_z0(GLfloat scale, int grid)
+{
+    const GLfloat maxord = grid*scale;
+    for(int i=-grid; i<=grid; ++i ) {
+        glDrawLine(i*scale,-maxord,   i*scale,+maxord);
+        glDrawLine(-maxord, i*scale,  +maxord, i*scale);
+    }
+}
+
+inline void glDrawFrustum( GLfloat u0, GLfloat v0, GLfloat fu, GLfloat fv, int w, int h, GLfloat scale )
+{
+    const GLfloat xl = scale * u0;
+    const GLfloat xh = scale * (w*fu + u0);
+    const GLfloat yl = scale * v0;
+    const GLfloat yh = scale * (h*fv + v0);
+
+    const GLfloat verts[] = {
+        xl,yl,scale,  xh,yl,scale,
+        xh,yh,scale,  xl,yh,scale,
+        xl,yl,scale,  0,0,0,
+        xh,yl,scale,  0,0,0,
+        xl,yh,scale,  0,0,0,
+        xh,yh,scale
+    };
+
+    glDrawVertices(11, verts, GL_LINE_STRIP, 3);
+}
+
+inline void glDrawTexture(GLenum target, GLuint texid)
+{
+    glBindTexture(target, texid);
+    glEnable(target);
+    
+    const GLfloat sq_vert[] = { -1,-1,  1,-1,  1, 1,  -1, 1 };
+    glVertexPointer(2, GL_FLOAT, 0, sq_vert);
+    glEnableClientState(GL_VERTEX_ARRAY);   
+
+    const GLfloat sq_tex[]  = { 0,0,  1,0,  1,1,  0,1  };
+    glTexCoordPointer(2, GL_FLOAT, 0, sq_tex);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+         
+    glColor4f(1,1,1,1);
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    glDisable(target);
+}
+
+inline void glDrawTextureFlipY(GLenum target, GLuint texid)
+{
+    glBindTexture(target, texid);
+    glEnable(target);
+    
+    const GLfloat sq_vert[] = { -1,-1,  1,-1,  1, 1,  -1, 1 };
+    glVertexPointer(2, GL_FLOAT, 0, sq_vert);
+    glEnableClientState(GL_VERTEX_ARRAY);   
+
+    const GLfloat sq_tex[]  = { 0,1,  1,1,  1,0,  0,0  };
+    glTexCoordPointer(2, GL_FLOAT, 0, sq_tex);
+    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+         
+    glColor4f(1,1,1,1);
+    glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+
+    glDisableClientState(GL_VERTEX_ARRAY);
+    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+
+    glDisable(target);
+}
+
+
+#ifdef USE_EIGEN
+
+#ifndef HAVE_GLES
+inline void glVertex( const Eigen::Vector3d& p )
+{
+    glVertex3dv(p.data());
+}
+#endif
+
+inline void glDrawLine( const Eigen::Vector2d& p1, const Eigen::Vector2d& p2 )
+{
+    glDrawLine((GLfloat)p1(0), (GLfloat)p1(1), (GLfloat)p2(0), (GLfloat)p2(1));
+}
+
+// Draws a vector of 2d or 3d vertices using provided ``mode``.
+//
+// Preconditions:
+//  - ``mode`` must be GL_POINTS, GL_LINES, GL_LINE_STRIP, GL_LINE_LOOP, etc
+//  - If ``mode == GL_LINES``, then ``vertices.size()`` must be a multiple of 2.
+//
+template<typename P, int N, class Allocator>
+void glDrawVertices(const std::vector<Eigen::Matrix<P, N, 1>, Allocator>& vertices, GLenum mode)
+{
+    glDrawVertices(vertices.size(), vertices.data(), mode);
+}
+
+// Draws a vector of 2d or 3d points.
+//
+template<typename P, int N, class Allocator>
+void glDrawPoints(const std::vector<Eigen::Matrix<P, N, 1>, Allocator>& vertices)
+{
+    glDrawVertices(vertices, GL_POINTS);
+}
+
+// Draws a vector of 2d or 3d lines.
+//
+//  Precondition: ``vertices.size()`` must be a multiple of 2.
+//
+template<typename P, int N, class Allocator>
+void glDrawLines(const std::vector<Eigen::Matrix<P, N, 1>, Allocator>& vertices)
+{
+    glDrawVertices(vertices, GL_LINES);
+}
+
+// Draws a 2d or 3d line strip.
+//
+template<typename P, int N, class Allocator>
+void glDrawLineStrip(const std::vector<Eigen::Matrix<P, N, 1>, Allocator>& vertices)
+{
+    glDrawVertices(vertices, GL_LINE_STRIP);
+}
+
+// Draws a 2d or 3d line loop.
+//
+template<typename P, int N, class Allocator>
+void glDrawLineLoop(const std::vector<Eigen::Matrix<P, N, 1>, Allocator>& vertices)
+{
+    glDrawVertices(vertices, GL_LINE_LOOP);
+}
+
+inline void glDrawCross( const Eigen::Vector2d& p, double r = 5.0 )
+{
+    glDrawCross((GLfloat)p(0), (GLfloat)p(1), (GLfloat)r);
+}
+
+inline void glDrawCross( const Eigen::Vector3d& p, double r = 5.0 )
+{
+    glDrawCross((GLfloat)p(0), (GLfloat)p(1), (GLfloat)p(2), (GLfloat)r);
+}
+
+inline void glDrawCircle( const Eigen::Vector2d& p, double radius = 5.0 )
+{
+    glDrawCircle((GLfloat)p(0), (GLfloat)p(1), (GLfloat)radius);
+}
+
+inline void glDrawCirclePerimeter( const Eigen::Vector2d& p, double radius = 5.0 )
+{
+    glDrawCirclePerimeter((GLfloat)p(0), (GLfloat)p(1), (GLfloat)radius);
+}
+
+inline void glSetFrameOfReference( const Eigen::Matrix4f& T_wf )
+{
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+    glMultMatrixf( T_wf.data() );
+}
+
+inline void glSetFrameOfReference( const Eigen::Matrix4d& T_wf )
+{
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+#ifndef HAVE_GLES
+    glMultMatrixd( T_wf.data() );
+#else
+    const Eigen::Matrix4f fT_wf = T_wf.cast<GLfloat>();
+    glMultMatrixf( fT_wf.data() );
+#endif
+}
+
+inline void glSetFrameOfReference( const pangolin::OpenGlMatrix& T_wf )
+{
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+    glMultMatrixd( T_wf.m );
+}
+
+inline void glUnsetFrameOfReference()
+{
+    glPopMatrix();
+}
+
+template<typename T, typename S>
+inline void glDrawAxis( const T& T_wf, S scale )
+{
+    glSetFrameOfReference(T_wf);
+    glDrawAxis(scale);
+    glUnsetFrameOfReference();
+}
+
+template<typename T>
+inline void glDrawFrustum( const Eigen::Matrix<T,3,3>& Kinv, int w, int h, GLfloat scale )
+{
+    glDrawFrustum((GLfloat)Kinv(0,2), (GLfloat)Kinv(1,2), (GLfloat)Kinv(0,0), (GLfloat)Kinv(1,1), w, h, scale);
+}
+
+template<typename T>
+inline void glDrawFrustum( const Eigen::Matrix<T,3,3>& Kinv, int w, int h, const Eigen::Matrix<T,4,4>& T_wf, T scale )
+{
+    glSetFrameOfReference(T_wf);
+    glDrawFrustum(Kinv,w,h,scale);
+    glUnsetFrameOfReference();
+}
+
+template<typename T>
+inline void glDrawAlignedBox( const Eigen::AlignedBox<T,2>& box, GLenum mode = GL_TRIANGLE_FAN )
+{
+    const Eigen::Matrix<float,2,1> l = box.min().template cast<float>();
+    const Eigen::Matrix<float,2,1> h = box.max().template cast<float>();
+
+    GLfloat verts[] = {
+        l[0], l[1],
+        h[0], l[1],
+        h[0], h[1],
+        l[0], h[1]
+    };
+
+    glDrawVertices(4, verts, mode, 2);
+}
+
+template<typename T>
+inline void glDrawAlignedBoxPerimeter( const Eigen::AlignedBox<T,2>& box)
+{
+    glDrawAlignedBox<T>(box, GL_LINE_LOOP);
+}
+
+template<typename T>
+inline void glDrawAlignedBox( const Eigen::AlignedBox<T,3>& box)
+{
+    const Eigen::Matrix<float,3,1> l = box.min().template cast<float>();
+    const Eigen::Matrix<float,3,1> h = box.max().template cast<float>();
+
+    GLfloat verts[] = {
+        l[0], l[1], l[2],
+        l[0], l[1], h[2],
+        h[0], l[1], h[2],
+        h[0], l[1], l[2],
+        l[0], l[1], l[2],
+        l[0], h[1], l[2],
+        h[0], h[1], l[2],
+        h[0], l[1], l[2],
+        h[0], h[1], l[2],
+        h[0], h[1], h[2],
+        l[0], h[1], h[2],
+        l[0], h[1], l[2],
+        l[0], h[1], h[2],
+        l[0], l[1], h[2],
+        h[0], l[1], h[2],
+        h[0], h[1], h[2]
+    };
+
+    glDrawVertices(16, verts, GL_LINE_STRIP, 3);
+}
+
+#endif // USE_EIGEN
+
+#ifndef HAVE_GLES
+inline void glPixelTransferScale( float r, float g, float b )
+{
+    glPixelTransferf(GL_RED_SCALE,r);
+    glPixelTransferf(GL_GREEN_SCALE,g);
+    glPixelTransferf(GL_BLUE_SCALE,b);
+}
+
+inline void glPixelTransferScale( float scale )
+{
+    glPixelTransferScale(scale,scale,scale);
+}
+#endif
+
+void glRecordGraphic(float x, float y, float radius);
+
+}

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

@@ -0,0 +1,80 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2015 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/gl/gltext.h>
+
+#include <cstdio>
+#include <cstdarg>
+
+namespace pangolin {
+
+class PANGOLIN_EXPORT GlFont
+{
+public:
+    // Load GL Font data. Delay uploading as texture until first use.
+    GlFont(const unsigned char* ttf_buffer, float pixel_height, int tex_w=512, int tex_h=512);
+    GlFont(const std::string& filename, float pixel_height, int tex_w=512, int tex_h=512);
+    GlFont(float pixel_height, int tex_w=512, int tex_h=512);
+
+    virtual ~GlFont();
+
+    // Generate renderable GlText object from this font.
+    GlText Text( const char* fmt, ... );
+
+    GlText Text( const std::string& str );
+
+    inline float Height() const {
+        return font_height_px;
+    }
+    inline float MaxWidth() const {
+        return font_max_width_px;
+    }
+
+protected:
+    void InitialiseFont(const unsigned char* ttf_buffer, float pixel_height, int tex_w, int tex_h);
+
+    // This can only be called once GL context is initialised
+    void InitialiseGlTexture();
+
+    const static int FIRST_CHAR = 32;
+    const static int NUM_CHARS = 96;
+
+    float font_height_px;
+    float font_max_width_px;
+
+    int tex_w;
+    int tex_h;
+    unsigned char* font_bitmap;
+    GlTexture mTex;
+
+    GlChar chardata[NUM_CHARS];
+    GLfloat kern_table[NUM_CHARS*NUM_CHARS];
+};
+
+}

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

@@ -0,0 +1,232 @@
+/* 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/glplatform.h>
+
+#ifdef HAVE_EIGEN
+#  include <Eigen/Core>
+#endif
+
+namespace pangolin
+{
+
+template<typename T>
+struct GlFormatTraits;
+//{
+//    static const GLint glinternalformat = 0;
+//    static const GLenum glformat = 0;
+//    static const GLenum gltype = 0;
+//    static const T glmin = 0;
+//    static const T glmax = 0;
+//};
+
+template<>
+struct GlFormatTraits<unsigned char>
+{
+    static const GLint glinternalformat = GL_LUMINANCE8;
+    static const GLenum glformat = GL_LUMINANCE;
+    static const GLenum gltype = GL_UNSIGNED_BYTE;
+    static const size_t components = 1;
+};
+
+template<>
+struct GlFormatTraits<unsigned short>
+{
+    static const GLint glinternalformat = GL_LUMINANCE16;
+    static const GLenum glformat = GL_LUMINANCE;
+    static const GLenum gltype = GL_UNSIGNED_SHORT;
+    static const size_t components = 1;
+};
+
+template<>
+struct GlFormatTraits<unsigned int>
+{
+    static const GLint glinternalformat = GL_LUMINANCE32UI_EXT;
+    static const GLenum glformat = GL_LUMINANCE_INTEGER_EXT;
+    static const GLenum gltype = GL_UNSIGNED_INT;
+    static const size_t components = 1;
+};
+
+template<>
+struct GlFormatTraits<int>
+{
+    static const GLint glinternalformat = GL_LUMINANCE32I_EXT;
+    static const GLenum glformat = GL_LUMINANCE_INTEGER_EXT;
+    static const GLenum gltype = GL_INT;
+    static const size_t components = 1;
+};
+
+template<>
+struct GlFormatTraits<float>
+{
+    static const GLint glinternalformat = GL_LUMINANCE32F_ARB;
+    static const GLenum glformat = GL_LUMINANCE;
+    static const GLenum gltype = GL_FLOAT;
+    static const size_t components = 1;
+};
+
+template<>
+struct GlFormatTraits<double>
+{
+    static const GLint glinternalformat = GL_LUMINANCE32F_ARB;
+    static const GLenum glformat = GL_LUMINANCE;
+    static const GLenum gltype = GL_DOUBLE;
+    static const size_t components = 1;
+};
+
+
+
+#ifdef HAVE_EIGEN
+
+//////////////////////////////////////////////////////////////////
+
+template <>
+struct GlFormatTraits<Eigen::Matrix<unsigned char,2,1>>
+{
+    static const GLint glinternalformat = GL_RG8;
+    static const GLenum glformat = GL_RG;
+    static const GLenum gltype = GL_UNSIGNED_BYTE;
+    static const size_t components = 2;
+};
+
+template <>
+struct GlFormatTraits<Eigen::Matrix<unsigned short,2,1>>
+{
+    static const GLint glinternalformat = GL_RG16;
+    static const GLenum glformat = GL_RG;
+    static const GLenum gltype = GL_UNSIGNED_SHORT;
+    static const size_t components = 2;
+};
+
+template <>
+struct GlFormatTraits<Eigen::Vector2i>
+{
+    static const GLint glinternalformat = GL_RG32I;
+    static const GLenum glformat = GL_RG;
+    static const GLenum gltype = GL_INT;
+    static const size_t components = 2;
+};
+
+template <>
+struct GlFormatTraits<Eigen::Vector2f>
+{
+    static const GLint glinternalformat = GL_RG32F;
+    static const GLenum glformat = GL_RG;
+    static const GLenum gltype = GL_FLOAT;
+    static const size_t components = 2;
+};
+
+template <>
+struct GlFormatTraits<Eigen::Vector2d>
+{
+    static const GLint glinternalformat = GL_RG32F;
+    static const GLenum glformat = GL_RG;
+    static const GLenum gltype = GL_DOUBLE;
+    static const size_t components = 2;
+};
+
+//////////////////////////////////////////////////////////////////
+
+template <>
+struct GlFormatTraits<Eigen::Matrix<unsigned char,3,1>>
+{
+    static const GLint glinternalformat = GL_RGB8;
+    static const GLenum glformat = GL_RGB;
+    static const GLenum gltype = GL_UNSIGNED_BYTE;
+    static const size_t components = 3;
+};
+
+template <>
+struct GlFormatTraits<Eigen::Matrix<unsigned short,3,1>>
+{
+    static const GLint glinternalformat = GL_RGBA16;
+    static const GLenum glformat = GL_RGB;
+    static const GLenum gltype = GL_UNSIGNED_SHORT;
+    static const size_t components = 3;
+};
+
+template <>
+struct GlFormatTraits<Eigen::Vector3f>
+{
+    static const GLint glinternalformat = GL_RGB32F;
+    static const GLenum glformat = GL_RGB;
+    static const GLenum gltype = GL_FLOAT;
+    static const size_t components = 3;
+};
+
+template <>
+struct GlFormatTraits<Eigen::Vector3d>
+{
+    static const GLint glinternalformat = GL_RGB32F;
+    static const GLenum glformat = GL_RGB;
+    static const GLenum gltype = GL_DOUBLE;
+    static const size_t components = 3;
+};
+
+//////////////////////////////////////////////////////////////////
+
+template <>
+struct GlFormatTraits<Eigen::Matrix<unsigned char,4,1>>
+{
+    static const GLint glinternalformat = GL_RGBA8;
+    static const GLenum glformat = GL_RGBA;
+    static const GLenum gltype = GL_UNSIGNED_BYTE;
+    static const size_t components = 4;
+};
+
+template <>
+struct GlFormatTraits<Eigen::Matrix<unsigned short,4,1>>
+{
+    static const GLint glinternalformat = GL_RGBA16;
+    static const GLenum glformat = GL_RGBA;
+    static const GLenum gltype = GL_UNSIGNED_SHORT;
+    static const size_t components = 4;
+};
+
+template <>
+struct GlFormatTraits<Eigen::Vector4f>
+{
+    static const GLint glinternalformat = GL_RGBA32F;
+    static const GLenum glformat = GL_RGBA;
+    static const GLenum gltype = GL_FLOAT;
+    static const size_t components = 4;
+};
+
+template <>
+struct GlFormatTraits<Eigen::Vector4d>
+{
+    static const GLint glinternalformat = GL_RGBA32F;
+    static const GLenum glformat = GL_RGBA;
+    static const GLenum gltype = GL_DOUBLE;
+    static const size_t components = 4;
+};
+
+#endif // HAVE_EIGEN
+
+}

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

@@ -0,0 +1,46 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2011 Steven Lovegrove, Richard Newcombe
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/gl/glplatform.h>
+
+#ifdef HAVE_GLES
+#include <pangolin/gl/compat/gl_es_compat.h>
+#endif
+
+#define CheckGlDieOnError() pangolin::_CheckGlDieOnError( __FILE__, __LINE__ );
+namespace pangolin {
+inline void _CheckGlDieOnError( const char *sFile, const int nLine )
+{
+    const GLenum glError = glGetError();
+    if( glError != GL_NO_ERROR ) {
+        pango_print_error( "OpenGL Error: %s (%d)\n", glErrorString(glError), glError );
+        pango_print_error("In: %s, line %d\n", sFile, nLine);
+    }
+}
+}

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

@@ -0,0 +1,80 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2014 Steven Lovegrove
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <pangolin/gl/glplatform.h>
+
+namespace pangolin {
+
+/// Clone of glErrorString
+PANGOLIN_EXPORT
+const GLubyte* glErrorString(GLenum error);
+
+/// Clone of gluProject
+PANGOLIN_EXPORT
+GLint glProject(
+    float objx, float objy, float objz,
+    const float* const modelMatrix/*[16]*/,
+    const float* const projMatrix/*[16]*/,
+    const GLint* const viewport/*[4]*/,
+    float* winx, float* winy, float* winz
+);
+
+
+/// Clone of gluUnProject
+PANGOLIN_EXPORT
+GLint glUnProject(
+    float winx, float winy, float winz,
+    const float* const modelMatrix/*[16]*/,
+    const float* const projMatrix/*[16]*/,
+    const GLint* const viewport/*[4]*/,
+    float* objx, float* objy, float* objz
+);
+
+/// Clone of gluProject
+PANGOLIN_EXPORT
+GLint glProject(
+    double objx, double objy, double objz,
+    const double* const modelMatrix/*[16]*/,
+    const double* const projMatrix/*[16]*/,
+    const GLint*  const viewport/*[4]*/,
+    double* winx, double* winy, double* winz
+);
+
+
+/// Clone of gluUnProject
+PANGOLIN_EXPORT
+GLint glUnProject(
+    double winx, double winy, double winz,
+    const double* const modelMatrix/*[16]*/,
+    const double* const projMatrix/*[16]*/,
+    const GLint*  const viewport/*[4]*/,
+    double* objx, double* objy, double* objz
+);
+
+}

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

@@ -0,0 +1,110 @@
+/* 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/glplatform.h>
+#include <pangolin/gl/glformattraits.h>
+#include <pangolin/image/pixel_format.h>
+#include <stdexcept>
+
+namespace pangolin {
+
+// This class may dissapear in the future
+struct GlPixFormat
+{
+    GlPixFormat() {}
+
+    GlPixFormat(const PixelFormat& fmt)
+    {
+        switch( fmt.channels) {
+        case 1: glformat = GL_LUMINANCE; break;
+        case 3: glformat = fmt.format.substr(0, 3) == "BGR"? GL_BGR  : GL_RGB;  break;
+        case 4: glformat = fmt.format.substr(0, 4) == "BGRA"? GL_BGRA : GL_RGBA; break;
+        default: throw std::runtime_error("Unable to form OpenGL format from video format: '" + fmt.format + "'.");
+        }
+
+        const bool is_integral = fmt.format.find('F') == std::string::npos;
+
+        switch (fmt.channel_bits[0]) {
+        case 8: gltype = GL_UNSIGNED_BYTE; break;
+        case 10: gltype = GL_UNSIGNED_SHORT; break;
+        case 12: gltype = GL_UNSIGNED_SHORT; break;
+        case 16: gltype = GL_UNSIGNED_SHORT; break;
+        case 32: gltype = (is_integral ? GL_UNSIGNED_INT : GL_FLOAT); break;
+        case 64: gltype = (is_integral ? GL_UNSIGNED_INT64_NV : GL_DOUBLE); break;
+        default: throw std::runtime_error("Unknown OpenGL data type for video format: '" + fmt.format + "'.");
+        }
+
+        if(glformat == GL_LUMINANCE) {
+            if(gltype == GL_UNSIGNED_BYTE) {
+                scalable_internal_format = GL_LUMINANCE8;
+            }else if(gltype == GL_UNSIGNED_SHORT){
+                if(fmt.channel_bits[0] == 12) {
+                    scalable_internal_format = GL_LUMINANCE12;
+                }
+                else if(fmt.channel_bits[0] == 10) {
+                    scalable_internal_format = GL_LUMINANCE12; // there is no GL_LUMINANCE10
+                } else {
+                    scalable_internal_format = GL_LUMINANCE16;
+                }
+            }else{
+                scalable_internal_format = GL_LUMINANCE32F_ARB;
+            }
+        }else{
+            if(gltype == GL_UNSIGNED_BYTE) {
+                scalable_internal_format = GL_RGBA8;
+            }else if(gltype == GL_UNSIGNED_SHORT) {
+                if(fmt.channel_bits[0] == 10) {
+                    scalable_internal_format = GL_RGB10;
+                } else if(fmt.channel_bits[0] == 12) {
+                    scalable_internal_format = GL_RGB12;
+                } else {
+                    scalable_internal_format = GL_RGBA16;
+                }
+            }else{
+                scalable_internal_format = GL_RGBA32F;
+            }
+        }
+    }
+
+    template<typename T>
+    static GlPixFormat FromType()
+    {
+        GlPixFormat fmt;
+        fmt.glformat = GlFormatTraits<T>::glformat;
+        fmt.gltype = GlFormatTraits<T>::gltype;
+        fmt.scalable_internal_format = GlFormatTraits<T>::glinternalformat;
+        return fmt;
+    }
+
+    GLint glformat;
+    GLenum gltype;
+    GLint scalable_internal_format;
+};
+
+}

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

@@ -0,0 +1,86 @@
+/* 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
+
+//////////////////////////////////////////////////////////
+// Attempt to portably include Necessary OpenGL headers
+//////////////////////////////////////////////////////////
+
+#include <pangolin/platform.h>
+
+#ifdef _WIN_
+    // Define maths quantities when using <cmath> to match posix systems
+    #ifndef _USE_MATH_DEFINES
+    #  define _USE_MATH_DEFINES
+    #endif
+
+    // Don't define min / max macros in windows.h or other unnecessary macros
+    #ifndef NOMINMAX
+    #  define NOMINMAX
+    #endif
+    #ifndef WIN32_LEAN_AND_MEAN
+    #  define WIN32_LEAN_AND_MEAN
+    #endif
+    #include <Windows.h>
+
+    // Undef nuisance Windows.h macros which interfere with our methods
+    #undef LoadImage
+    #undef near
+    #undef far
+    #undef ERROR
+#endif
+
+#ifdef HAVE_GLEW
+    #include <GL/glew.h>
+#endif
+
+#ifdef HAVE_GLES
+    #if defined(_ANDROID_)
+        #include <EGL/egl.h>
+        #ifdef HAVE_GLES_2
+            #include <GLES2/gl2.h>
+            #include <GLES2/gl2ext.h>
+        #else
+            #include <GLES/gl.h>
+            #define GL_GLEXT_PROTOTYPES
+            #include <GLES/glext.h>
+        #endif
+    #elif defined(_APPLE_IOS_)
+        #include <OpenGLES/ES2/gl.h>
+        #include <OpenGLES/ES2/glext.h>
+    #endif
+#else
+    #ifdef _OSX_
+        #define GL_SILENCE_DEPRECATION
+        #include <OpenGL/gl.h>
+    #else
+        #include <GL/gl.h>
+    #endif
+#endif // HAVE_GLES
+
+#include <pangolin/gl/glpangoglu.h>

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

@@ -0,0 +1,812 @@
+/* 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 <sstream>
+#include <fstream>
+#include <algorithm>
+#include <vector>
+#include <map>
+#include <cctype>
+
+#include <pangolin/gl/glplatform.h>
+#include <pangolin/gl/colour.h>
+#include <pangolin/gl/opengl_render_state.h>
+#include <pangolin/utils/file_utils.h>
+
+#ifdef HAVE_GLES
+    #define GLhandleARB GLuint
+#endif
+
+#if defined(HAVE_EIGEN) && !defined(__CUDACC__) //prevent including Eigen in cuda files
+#define USE_EIGEN
+#endif
+
+#ifdef USE_EIGEN
+#include <Eigen/Core>
+#endif // USE_EIGEN
+
+namespace pangolin
+{
+
+////////////////////////////////////////////////
+// Standard attribute locations
+////////////////////////////////////////////////
+
+const GLuint DEFAULT_LOCATION_POSITION = 0;
+const GLuint DEFAULT_LOCATION_COLOUR   = 1;
+const GLuint DEFAULT_LOCATION_NORMAL   = 2;
+const GLuint DEFAULT_LOCATION_TEXCOORD = 3;
+
+const char DEFAULT_NAME_POSITION[] = "a_position";
+const char DEFAULT_NAME_COLOUR[]   = "a_color";
+const char DEFAULT_NAME_NORMAL[]   = "a_normal";
+const char DEFAULT_NAME_TEXCOORD[] = "a_texcoord";
+
+////////////////////////////////////////////////
+// Interface
+////////////////////////////////////////////////
+
+enum GlSlShaderType
+{
+    GlSlAnnotatedShader = 0,
+    GlSlFragmentShader = GL_FRAGMENT_SHADER,
+    GlSlVertexShader = GL_VERTEX_SHADER,
+    GlSlGeometryShader = 0x8DD9 /*GL_GEOMETRY_SHADER*/,
+    GlSlComputeShader = 0x91B9 /*GL_COMPUTE_SHADER*/
+};
+
+class GlSlProgram
+{
+public:
+    GlSlProgram();
+
+    //! Move Constructor
+    GlSlProgram(GlSlProgram&& tex);
+
+    ~GlSlProgram();
+
+    bool AddShader(
+        GlSlShaderType shader_type,
+        const std::string& source_code,
+        const std::map<std::string,std::string>& program_defines = std::map<std::string,std::string>(),
+        const std::vector<std::string>& search_path = std::vector<std::string>()
+    );
+
+    bool AddShaderFromFile(
+        GlSlShaderType shader_type,
+        const std::string& filename,
+        const std::map<std::string,std::string>& program_defines = std::map<std::string,std::string>(),
+        const std::vector<std::string>& search_path = std::vector<std::string>()
+    );
+
+    bool Link();
+
+    // Remove all shaders from this program, and reload from files.
+    bool ReloadShaderFiles();
+
+    GLint GetAttributeHandle(const std::string& name);
+    GLint GetUniformHandle(const std::string& name);
+
+    // Before setting uniforms, be sure to Bind() the GlSl program first.
+    void SetUniform(const std::string& name, int x);
+    void SetUniform(const std::string& name, int x1, int x2);
+    void SetUniform(const std::string& name, int x1, int x2, int x3);
+    void SetUniform(const std::string& name, int x1, int x2, int x3, int x4);
+
+    void SetUniform(const std::string& name, float f);
+    void SetUniform(const std::string& name, float f1, float f2);
+    void SetUniform(const std::string& name, float f1, float f2, float f3);
+    void SetUniform(const std::string& name, float f1, float f2, float f3, float f4);
+
+    void SetUniform(const std::string& name, Colour c);
+
+    void SetUniform(const std::string& name, const OpenGlMatrix& m);
+
+#ifdef USE_EIGEN
+    void SetUniform(const std::string& name, const Eigen::Vector2f& v);
+    void SetUniform(const std::string& name, const Eigen::Vector3f& v);
+    void SetUniform(const std::string& name, const Eigen::Vector4f& v);
+    void SetUniform(const std::string& name, const Eigen::Matrix2f& m);
+    void SetUniform(const std::string& name, const Eigen::Matrix3f& m);
+    void SetUniform(const std::string& name, const Eigen::Matrix4f& m);
+
+    void SetUniform(const std::string& name, const Eigen::Vector2d& v);
+    void SetUniform(const std::string& name, const Eigen::Vector3d& v);
+    void SetUniform(const std::string& name, const Eigen::Vector4d& v);
+    void SetUniform(const std::string& name, const Eigen::Matrix2d& m);
+    void SetUniform(const std::string& name, const Eigen::Matrix3d& m);
+    void SetUniform(const std::string& name, const Eigen::Matrix4d& m);
+#endif
+
+#if GL_VERSION_4_3
+    GLint GetProgramResourceIndex(const std::string& name);
+    void SetShaderStorageBlock(const std::string& name, const int& bindingIndex);
+#endif
+
+    void Bind();
+    void SaveBind();
+    void Unbind();
+
+
+    void BindPangolinDefaultAttribLocationsAndLink();
+
+    // Unlink all shaders from program
+    void ClearShaders();
+
+    GLint ProgramId() const {
+        return prog;
+    }
+
+    bool Valid() const {
+        return ProgramId() != 0;
+    }
+
+protected:
+    struct ShaderFileOrCode
+    {
+        GlSlShaderType shader_type;
+        std::string filename;
+        std::string code;
+        std::map<std::string,std::string> program_defines;
+        std::vector<std::string> search_path;
+    };
+
+
+    // Convenience method to load shader description
+    bool AddShaderFile(const ShaderFileOrCode &shader_file);
+
+    std::string ParseIncludeFilename(
+        const std::string& location
+    );
+
+    std::string SearchIncludePath(
+        const std::string& filename,
+        const std::vector<std::string>& search_path,
+        const std::string& current_path
+    );
+
+    bool AddPreprocessedShader(
+        GlSlShaderType shader_type,
+        const std::string& source_code,
+        const std::string& name_for_errors
+    );
+
+    void PreprocessGLSL(
+        std::istream& input,
+        std::ostream& output,
+        const std::map<std::string,std::string>& program_defines,
+        const std::vector<std::string>& search_path,
+        const std::string& current_path
+    );
+
+    // Split 'code' into several code blocks per shader type
+    // shader blocks in 'code' must be annotated with:
+    // @start vertex, @start fragment, @start geometry or @start compute
+    static std::map<GlSlShaderType,std::string>
+    SplitAnnotatedShaders(const std::string& code);
+
+    bool linked;
+    std::vector<GLhandleARB> shaders;
+    GLenum prog;
+    GLint prev_prog;
+    std::vector<ShaderFileOrCode> shader_files;
+};
+
+class GlSlUtilities
+{
+public:
+    inline static GlSlProgram& OffsetAndScale(float offset, float scale) {
+        GlSlProgram& prog = Instance().prog_offsetscale;
+        prog.Bind();
+        prog.SetUniform("offset", offset);
+        prog.SetUniform("scale",  scale);
+        return prog;
+    }
+
+    inline static GlSlProgram& OffsetAndScaleGamma(float offset, float scale) {
+        GlSlProgram& prog = Instance().prog_offsetscalegamma;
+        prog.Bind();
+        prog.SetUniform("offset", offset);
+        prog.SetUniform("scale",  scale);
+        return prog;
+    }
+
+    inline static GlSlProgram& Scale(float scale, float bias = 0.0f) {
+        GlSlProgram& prog = Instance().prog_scale;
+        prog.Bind();
+        prog.SetUniform("scale", scale);
+        prog.SetUniform("bias",  bias);
+        return prog;
+    }
+
+    inline static void UseNone()
+    {
+        glUseProgram(0);
+    }
+
+protected:
+    static GlSlUtilities& Instance() {
+        // TODO: BUG: The GlSLUtilities instance needs to be tied
+        // to the OpenGL context, not the thread, or globally.
+#ifndef PANGO_NO_THREADLOCAL
+        thread_local
+#else
+        static
+#endif
+        GlSlUtilities instance;
+        return instance;
+    }
+
+    // protected constructor
+    GlSlUtilities() {
+        const char* source_scale =
+                "uniform float scale;"
+                "uniform float bias;"
+                "uniform sampler2D tex;"
+                "void main() {"
+                "  vec2 uv = gl_TexCoord[0].st;"
+                "  if(0.0 <= uv.x && uv.x <= 1.0 && 0.0 <= uv.y && uv.y <= 1.0) {"
+                "    gl_FragColor = texture2D(tex,uv);"
+                "    gl_FragColor.xyz *= scale;"
+                "    gl_FragColor.xyz += vec3(bias,bias,bias);"
+                "  }else{"
+                "    float v = 0.1;"
+                "    gl_FragColor.xyz = vec3(v,v,v);"
+                "  }"
+                "}";
+        prog_scale.AddShader(GlSlFragmentShader, source_scale);
+        prog_scale.Link();
+
+        // shader performs automatically gamma correction, assuming that image data is linear
+        // maps to (approximate) sRGB
+        const char* source_offsetscalegamma =
+                "uniform float offset;"
+                "uniform float scale;"
+                "uniform sampler2D tex;"
+                "void main() {"
+                "  vec2 uv = gl_TexCoord[0].st;"
+                "  if(0.0 <= uv.x && uv.x <= 1.0 && 0.0 <= uv.y && uv.y <= 1.0) {"
+                "    gl_FragColor = texture2D(tex,gl_TexCoord[0].st);"
+                "    gl_FragColor.xyz += vec3(offset,offset,offset);"
+                "    gl_FragColor.xyz *= scale;"
+                "    gl_FragColor.xyz = pow(gl_FragColor.xyz,vec3(0.45,0.45,0.45));"
+                "  }else{"
+                "    float v = 0.1;"
+                "    gl_FragColor.xyz = vec3(v,v,v);"
+                "  }"
+                "}";
+        prog_offsetscalegamma.AddShader(GlSlFragmentShader, source_offsetscalegamma);
+        prog_offsetscalegamma.Link();
+
+         const char* source_offsetscale =
+                "uniform float offset;"
+                "uniform float scale;"
+                "uniform sampler2D tex;"
+                "void main() {"
+                "  vec2 uv = gl_TexCoord[0].st;"
+                "  if(0.0 <= uv.x && uv.x <= 1.0 && 0.0 <= uv.y && uv.y <= 1.0) {"
+                "    gl_FragColor = texture2D(tex,gl_TexCoord[0].st);"
+                "    gl_FragColor.xyz += vec3(offset,offset,offset);"
+                "    gl_FragColor.xyz *= scale;"
+                "  }else{"
+                "    float v = 0.1;"
+                "    gl_FragColor.xyz = vec3(v,v,v);"
+                "  }"
+                "}";
+        prog_offsetscale.AddShader(GlSlFragmentShader, source_offsetscale);
+        prog_offsetscale.Link();
+    }
+
+    GlSlProgram prog_scale;
+    GlSlProgram prog_offsetscale;
+    GlSlProgram prog_offsetscalegamma;
+};
+
+
+////////////////////////////////////////////////
+// Implementation
+////////////////////////////////////////////////
+
+inline bool IsLinkSuccessPrintLog(GLhandleARB prog)
+{
+    GLint status;
+    glGetProgramiv(prog, GL_LINK_STATUS, &status);
+    if(status != GL_TRUE) {
+        pango_print_error("GLSL Program link failed: ");
+        const int PROGRAM_LOG_MAX_LEN = 10240;
+        char infolog[PROGRAM_LOG_MAX_LEN];
+        GLsizei len;
+        glGetProgramInfoLog(prog, PROGRAM_LOG_MAX_LEN, &len, infolog);
+        if(len) {
+            pango_print_error("%s\n",infolog);
+        }else{
+            pango_print_error("No details provided.\n");
+        }
+        return false;
+    }
+    return true;
+}
+
+inline bool IsCompileSuccessPrintLog(GLhandleARB shader, const std::string& name_for_errors, const std::string& source_code = {})
+{
+    GLint status;
+    glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
+    if(status != GL_TRUE) {
+        pango_print_error("GLSL Shader compilation failed: ");
+        const int SHADER_LOG_MAX_LEN = 10240;
+        char infolog[SHADER_LOG_MAX_LEN];
+        GLsizei len;
+        glGetShaderInfoLog(shader, SHADER_LOG_MAX_LEN, &len, infolog);
+        if(len) {
+            pango_print_error("%s:\n%s\n",name_for_errors.c_str(), infolog);
+        }else{
+            pango_print_error("%s:\nNo details provided.\n",name_for_errors.c_str());
+        }
+        if(!source_code.empty())
+        {
+            pango_print_error("In source code:\n%s\n",source_code.c_str());
+        }
+        return false;
+    }
+    return true;
+}
+
+inline GlSlProgram::GlSlProgram()
+    : linked(false), prog(0), prev_prog(0)
+{
+}
+
+//! Move Constructor
+inline GlSlProgram::GlSlProgram(GlSlProgram&& o)
+    : linked(o.linked), shaders(o.shaders), prog(o.prog), prev_prog(o.prev_prog)
+{
+    o.prog = 0;
+}
+
+inline GlSlProgram::~GlSlProgram()
+{
+    if(prog) {
+        ClearShaders();
+        glDeleteProgram(prog);
+    }
+}
+
+inline void PrintSourceCode(const std::string& src)
+{
+    std::stringstream ss(src);
+    std::string line;
+
+    for(int linenum=1; std::getline(ss,line,'\n'); ++linenum) {
+        std::cout << linenum << ":\t" << line << std::endl;
+    }
+}
+
+inline bool GlSlProgram::AddPreprocessedShader(
+    GlSlShaderType shader_type,
+    const std::string& source_code,
+    const std::string& name_for_errors
+) {
+    if(!prog) {
+        prog = glCreateProgram();
+    }
+
+    GLhandleARB shader = glCreateShader(shader_type);
+    const char* source = source_code.c_str();
+    glShaderSource(shader, 1, &source, NULL);
+    glCompileShader(shader);
+    bool success = IsCompileSuccessPrintLog(shader, name_for_errors, source_code);
+    if(success) {
+        glAttachShader(prog, shader);
+        shaders.push_back(shader);
+        linked = false;
+    }
+    return success;
+}
+
+inline std::string GlSlProgram::ParseIncludeFilename(const std::string& location)
+{
+    size_t start = location.find_first_of("\"<");
+    if(start != std::string::npos) {
+        size_t end = location.find_first_of("\">", start+1);
+        if(end != std::string::npos) {
+            return location.substr(start+1, end - start - 1);
+        }
+    }
+    throw std::runtime_error("GLSL Parser: Unable to parse include location " + location );
+}
+
+inline std::string GlSlProgram::SearchIncludePath(
+    const std::string& filename,
+    const std::vector<std::string>& search_path,
+    const std::string& current_path
+) {
+    if(FileExists(current_path + "/" + filename)) {
+        return current_path + "/" + filename;
+    }else{
+        for(size_t i=0; i < search_path.size(); ++i) {
+            const std::string hypoth = search_path[i] + "/" + filename;
+            if( FileExists(hypoth) ) {
+                return hypoth;
+            }
+        }
+    }
+    return "";
+}
+
+inline void GlSlProgram::PreprocessGLSL(
+        std::istream& input, std::ostream& output,
+        const std::map<std::string,std::string>& program_defines,
+        const std::vector<std::string> &search_path,
+        const std::string &current_path
+) {
+    const size_t MAXLINESIZE = 10240;
+    char line[MAXLINESIZE] = "";
+
+    while(!input.eof()) {
+        // Take like from source
+        input.getline(line,MAXLINESIZE);
+
+        // Transform
+        if( !strncmp(line, "#include", 8 ) ) {
+            // C++ / G3D style include directive
+            const std::string import_file = ParseIncludeFilename(line+8);
+            const std::string resolved_file = SearchIncludePath(import_file, search_path, current_path);
+
+            std::ifstream ifs(resolved_file.c_str());
+            if(ifs.good()) {
+                const std::string file_path = pangolin::PathParent(resolved_file);
+                PreprocessGLSL(ifs, output, program_defines, search_path, file_path);
+            }else{
+                throw std::runtime_error("GLSL Parser: Unable to open " + import_file );
+            }
+        }else if( !strncmp(line, "#expect", 7) ) {
+            // G3D style 'expect' directive, annotating expected preprocessor
+            // definition with document string
+
+            // Consume whitespace before token
+            size_t token_start = 7;
+            while( std::isspace(line[token_start]) ) ++token_start;
+
+            // Iterate over contigous charecters until \0 or whitespace
+            size_t token_end = token_start;
+            while( line[token_end] && !std::isspace(line[token_end]) ) ++token_end;
+
+            std::string token(line+token_start, line+token_end);
+            std::map<std::string,std::string>::const_iterator it = program_defines.find(token);
+            if( it == program_defines.end() ) {
+                pango_print_warn("Expected define missing (defaulting to 0): '%s'\n%s\n", token.c_str(), line + token_end );
+                output << "#define " << token << " 0" << std::endl;
+            }else{
+                output << "#define " << token << " " << it->second << std::endl;
+            }
+        }else{
+            // Output directly
+            output << line << std::endl;
+        }
+    }
+}
+
+inline void GlSlProgram::ClearShaders()
+{
+    // Remove and delete each shader
+    for(size_t i=0; i<shaders.size(); ++i ) {
+        glDetachShader(prog, shaders[i]);
+        glDeleteShader(shaders[i]);
+    }
+    shaders.clear();
+}
+
+inline bool GlSlProgram::AddShaderFile(const ShaderFileOrCode& shader_file)
+{
+    std::stringstream buffer;
+
+    if(shader_file.code.empty()) {
+        std::ifstream ifs(shader_file.filename.c_str());
+        if(ifs.is_open()) {
+            PreprocessGLSL(ifs, buffer, shader_file.program_defines, shader_file.search_path, ".");
+        }else{
+            throw std::runtime_error(FormatString("Unable to open shader file '%'", shader_file.filename));
+        }
+    }else{
+        std::istringstream iss(shader_file.code);
+        PreprocessGLSL(iss, buffer, shader_file.program_defines, shader_file.search_path, ".");
+    }
+
+    const std::string code = buffer.str();
+    const std::string input_name = !shader_file.filename.empty() ? shader_file.filename : "<string>";
+
+    if(shader_file.shader_type == GlSlAnnotatedShader) {
+        const std::map<GlSlShaderType,std::string> split_progs = SplitAnnotatedShaders(code);
+        for(const auto& type_code : split_progs) {
+            if(!AddPreprocessedShader(type_code.first, type_code.second, input_name )) {
+                return false;
+            }
+        }
+        return true;
+    }else{
+        return AddPreprocessedShader(shader_file.shader_type, code, input_name);
+    }
+}
+
+inline bool GlSlProgram::AddShaderFromFile(
+    GlSlShaderType shader_type,
+    const std::string& filename,
+    const std::map<std::string,std::string>& program_defines,
+    const std::vector<std::string>& search_path
+) {
+    ShaderFileOrCode shader_file = {
+        shader_type,
+        pangolin::PathExpand(filename),
+        std::string(),
+        program_defines,
+        search_path
+    };
+    shader_files.push_back(shader_file);
+    return AddShaderFile(shader_file);
+}
+
+inline bool GlSlProgram::AddShader(
+    GlSlShaderType shader_type,
+    const std::string& source_code,
+    const std::map<std::string,std::string>& program_defines,
+    const std::vector<std::string>& search_path
+) {
+    ShaderFileOrCode shader_file = {
+        shader_type,
+        std::string(),
+        source_code,
+        program_defines,
+        search_path
+    };
+    shader_files.push_back(shader_file);
+    return AddShaderFile(shader_file);
+}
+
+inline bool GlSlProgram::ReloadShaderFiles()
+{
+    ClearShaders();
+
+    for(const auto& sf : shader_files) {
+        if(!AddShaderFile(sf)) {
+            return false;
+        }
+    }
+
+    Link();
+    return true;
+}
+
+inline std::map<GlSlShaderType,std::string>
+GlSlProgram::SplitAnnotatedShaders(const std::string& code)
+{
+    std::map<GlSlShaderType,std::string> ret;
+
+    std::stringstream input(code);
+    std::stringstream output;
+
+    const size_t MAXLINESIZE = 10240;
+    char line[MAXLINESIZE];
+
+    GlSlShaderType current_type = GlSlAnnotatedShader;
+    auto finish_block = [&](GlSlShaderType type){
+        if(current_type != GlSlAnnotatedShader) {
+            ret[current_type] = output.str();
+        }
+        output.str(std::string());
+        current_type = type;
+    };
+
+    while(!input.eof()) {
+        // Take like from source
+        input.getline(line,MAXLINESIZE);
+
+        // Transform
+        if( !strncmp(line, "@start", 6 ) ) {
+            const std::string str_shader_type = pangolin::Trim(std::string(line).substr(6));
+            if(str_shader_type == "vertex") {
+                finish_block(GlSlVertexShader);
+            }else if(str_shader_type == "fragment") {
+                finish_block(GlSlFragmentShader);
+            }else if(str_shader_type == "geometry") {
+                finish_block(GlSlGeometryShader);
+            }else if(str_shader_type == "compute") {
+                finish_block(GlSlComputeShader);
+            }
+        }else{
+            output << line << std::endl;
+        }
+    }
+
+    finish_block(GlSlAnnotatedShader);
+
+    return ret;
+}
+
+inline bool GlSlProgram::Link()
+{
+    glLinkProgram(prog);
+    return IsLinkSuccessPrintLog(prog);
+}
+
+inline void GlSlProgram::Bind()
+{
+    prev_prog = 0;
+    glUseProgram(prog);
+}
+
+inline void GlSlProgram::SaveBind()
+{
+    glGetIntegerv(GL_CURRENT_PROGRAM, &prev_prog);
+    glUseProgram(prog);
+}
+
+inline void GlSlProgram::Unbind()
+{
+    glUseProgram(prev_prog);
+}
+
+inline GLint GlSlProgram::GetAttributeHandle(const std::string& name)
+{
+    return glGetAttribLocation(prog, name.c_str());
+}
+
+inline GLint GlSlProgram::GetUniformHandle(const std::string& name)
+{
+    return glGetUniformLocation(prog, name.c_str());
+}
+
+inline void GlSlProgram::SetUniform(const std::string& name, int x)
+{
+    glUniform1i( GetUniformHandle(name), x);
+}
+
+inline void GlSlProgram::SetUniform(const std::string& name, int x1, int x2)
+{
+    glUniform2i( GetUniformHandle(name), x1, x2);
+}
+
+inline void GlSlProgram::SetUniform(const std::string& name, int x1, int x2, int x3)
+{
+    glUniform3i( GetUniformHandle(name), x1, x2, x3);
+}
+
+inline void GlSlProgram::SetUniform(const std::string& name, int x1, int x2, int x3, int x4)
+{
+    glUniform4i( GetUniformHandle(name), x1, x2, x3, x4);
+}
+
+inline void GlSlProgram::SetUniform(const std::string& name, float f)
+{
+    glUniform1f( GetUniformHandle(name), f);
+}
+
+inline void GlSlProgram::SetUniform(const std::string& name, float f1, float f2)
+{
+    glUniform2f( GetUniformHandle(name), f1,f2);
+}
+
+inline void GlSlProgram::SetUniform(const std::string& name, float f1, float f2, float f3)
+{
+    glUniform3f( GetUniformHandle(name), f1,f2,f3);
+}
+
+inline void GlSlProgram::SetUniform(const std::string& name, float f1, float f2, float f3, float f4)
+{
+    glUniform4f( GetUniformHandle(name), f1,f2,f3,f4);
+}
+
+inline void GlSlProgram::SetUniform(const std::string& name, Colour c)
+{
+    glUniform4f( GetUniformHandle(name), c.r, c.g, c.b, c.a);
+}
+
+inline void GlSlProgram::SetUniform(const std::string& name, const OpenGlMatrix& mat)
+{
+    // glUniformMatrix4dv seems to be crashing...
+    float m[16];
+    for (int i = 0; i < 16; ++i) {
+        m[i] = (float)mat.m[i];
+    }
+    glUniformMatrix4fv( GetUniformHandle(name), 1, GL_FALSE, m);
+}
+
+#ifdef HAVE_EIGEN
+inline void GlSlProgram::SetUniform(const std::string& name, const Eigen::Vector2f& v)
+{
+    glUniform2f( GetUniformHandle(name), v[0], v[1]);
+}
+inline void GlSlProgram::SetUniform(const std::string& name, const Eigen::Vector3f& v)
+{
+    glUniform3f( GetUniformHandle(name), v[0], v[1], v[2]);
+}
+inline void GlSlProgram::SetUniform(const std::string& name, const Eigen::Vector4f& v)
+{
+    glUniform4f( GetUniformHandle(name), v[0], v[1], v[2], v[3]);
+}
+inline void GlSlProgram::SetUniform(const std::string& name, const Eigen::Matrix2f& m)
+{
+    glUniformMatrix2fv( GetUniformHandle(name), 1, GL_FALSE, m.data());
+}
+inline void GlSlProgram::SetUniform(const std::string& name, const Eigen::Matrix3f& m)
+{
+    glUniformMatrix3fv( GetUniformHandle(name), 1, GL_FALSE, m.data());
+}
+inline void GlSlProgram::SetUniform(const std::string& name, const Eigen::Matrix4f& m)
+{
+    glUniformMatrix4fv( GetUniformHandle(name), 1, GL_FALSE, m.data());
+}
+
+inline void GlSlProgram::SetUniform(const std::string& name, const Eigen::Vector2d& v)
+{
+    glUniform2d( GetUniformHandle(name), v[0], v[1]);
+}
+inline void GlSlProgram::SetUniform(const std::string& name, const Eigen::Vector3d& v)
+{
+    glUniform3d( GetUniformHandle(name), v[0], v[1], v[2]);
+}
+inline void GlSlProgram::SetUniform(const std::string& name, const Eigen::Vector4d& v)
+{
+    glUniform4d( GetUniformHandle(name), v[0], v[1], v[2], v[3]);
+}
+inline void GlSlProgram::SetUniform(const std::string& name, const Eigen::Matrix2d& m)
+{
+    glUniformMatrix2dv( GetUniformHandle(name), 1, GL_FALSE, m.data());
+}
+inline void GlSlProgram::SetUniform(const std::string& name, const Eigen::Matrix3d& m)
+{
+    glUniformMatrix3dv( GetUniformHandle(name), 1, GL_FALSE, m.data());
+}
+inline void GlSlProgram::SetUniform(const std::string& name, const Eigen::Matrix4d& m)
+{
+    glUniformMatrix4dv( GetUniformHandle(name), 1, GL_FALSE, m.data());
+}
+#endif
+
+inline void GlSlProgram::BindPangolinDefaultAttribLocationsAndLink()
+{
+    glBindAttribLocation(prog, DEFAULT_LOCATION_POSITION, DEFAULT_NAME_POSITION);
+    glBindAttribLocation(prog, DEFAULT_LOCATION_COLOUR,   DEFAULT_NAME_COLOUR);
+    glBindAttribLocation(prog, DEFAULT_LOCATION_NORMAL,   DEFAULT_NAME_NORMAL);
+    glBindAttribLocation(prog, DEFAULT_LOCATION_TEXCOORD, DEFAULT_NAME_TEXCOORD);
+    Link();
+}
+
+#if GL_VERSION_4_3
+inline GLint GlSlProgram::GetProgramResourceIndex(const std::string& name)
+{
+    return glGetProgramResourceIndex(prog, GL_SHADER_STORAGE_BLOCK, name.c_str());
+}
+
+inline void GlSlProgram::SetShaderStorageBlock(const std::string& name, const int& bindingIndex)
+{
+    glShaderStorageBlockBinding(prog, GetProgramResourceIndex(name), bindingIndex);
+}
+#endif
+
+}

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

@@ -0,0 +1,220 @@
+/* This file is part of the Pangolin Project.
+ * http://github.com/stevenlovegrove/Pangolin
+ *
+ * Copyright (c) 2013 Vincent Mamo, 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>
+#include <stack>
+
+namespace pangolin
+{
+
+class GlState {
+
+    class CapabilityState {
+    public:
+
+        CapabilityState(GLenum cap, GLboolean enable)
+            : m_cap(cap), m_enable(enable)
+        {
+
+        }
+
+        void Apply() {
+            if(m_enable) {
+                ::glEnable(m_cap);
+            }else{
+                ::glDisable(m_cap);
+            }
+        }
+
+        void UnApply() {
+            if(m_enable) {
+                ::glDisable(m_cap);
+            }else{
+                ::glEnable(m_cap);
+            }
+        }
+
+    protected:
+        GLenum m_cap;
+        GLboolean m_enable;
+    };
+
+public:
+    GlState()
+        : m_DepthMaskCalled(false),
+          m_ShadeModelCalled(false),
+          m_CullFaceCalled(false),
+          m_PointSizeCalled(false),
+          m_LineWidthCalled(false),
+          m_ColorMaskCalled(false),
+          m_ViewportCalled(false)
+    {
+    }
+
+    ~GlState() {
+        //  Restore original state
+        while (!m_history.empty()) {
+            m_history.top().UnApply();
+            m_history.pop();
+        }
+
+        if (m_DepthMaskCalled) {
+            ::glDepthMask(m_OriginalDepthMask);
+        }
+
+        if (m_ShadeModelCalled) {
+            ::glShadeModel(m_OriginalShadeModel);
+        }
+
+        if (m_CullFaceCalled) {
+            ::glCullFace(m_OriginalCullFace);
+        }
+        
+        if(m_PointSizeCalled) {
+            ::glPointSize(m_OriginalPointSize);
+        }
+        
+        if(m_LineWidthCalled) {
+            ::glLineWidth(m_OriginalLineWidth);
+        }        
+        
+        if (m_ColorMaskCalled) {
+            ::glColorMask(m_OriginalColorMask[0], m_OriginalColorMask[1], m_OriginalColorMask[2], m_OriginalColorMask[3]);
+        }
+
+        if (m_ViewportCalled) {
+            ::glViewport(m_OriginalViewport[0], m_OriginalViewport[1], m_OriginalViewport[2], m_OriginalViewport[3]);
+        }
+    }
+
+    static inline GLboolean IsEnabled(GLenum cap)
+    {
+        GLboolean curVal;
+        glGetBooleanv(cap, &curVal);
+        return curVal;
+    }
+
+    inline void glEnable(GLenum cap)
+    {
+        if(!IsEnabled(cap)) {
+            m_history.push(CapabilityState(cap,true));
+            ::glEnable(cap);
+        }
+    }
+
+    inline void glDisable(GLenum cap)
+    {
+        if(IsEnabled(cap)) {
+            m_history.push(CapabilityState(cap,false));
+           ::glDisable(cap);
+        }
+    }
+
+    bool m_DepthMaskCalled;
+    GLboolean m_OriginalDepthMask;
+    inline void glDepthMask(GLboolean flag)
+    {
+        if(!m_DepthMaskCalled) {
+            m_DepthMaskCalled = true;
+            glGetBooleanv(GL_DEPTH_WRITEMASK, &m_OriginalDepthMask);
+        }
+        ::glDepthMask(flag);
+    }
+
+    bool m_ShadeModelCalled;
+    GLint m_OriginalShadeModel;
+    inline void glShadeModel(GLint mode)
+    {
+        if(!m_ShadeModelCalled) {
+            m_ShadeModelCalled = true;
+            glGetIntegerv(GL_SHADE_MODEL, &m_OriginalShadeModel);
+        }
+        ::glShadeModel(mode);
+    }
+    
+    bool m_CullFaceCalled;
+    GLint m_OriginalCullFace;
+    void glCullFace(GLenum mode)
+    {
+        if(!m_ShadeModelCalled) {
+            m_ShadeModelCalled = true;
+            glGetIntegerv(GL_CULL_FACE_MODE, &m_OriginalCullFace);
+        }
+        ::glCullFace(mode);        
+    }
+    
+    bool m_PointSizeCalled;
+    GLfloat m_OriginalPointSize;
+    void glPointSize(GLfloat size)
+    {
+        if(!m_PointSizeCalled) {
+            m_PointSizeCalled = true;
+            glGetFloatv(GL_POINT_SIZE, &m_OriginalPointSize);
+        }
+        ::glPointSize(size);
+    }
+    
+    bool m_LineWidthCalled;
+    GLfloat m_OriginalLineWidth;
+    void glLineWidth(GLfloat width)
+    {
+        if(!m_LineWidthCalled) {
+            m_LineWidthCalled = true;
+            glGetFloatv(GL_LINE_WIDTH, &m_OriginalLineWidth);
+        }
+        ::glLineWidth(width);
+        
+    }
+
+    bool m_ColorMaskCalled;
+    GLboolean m_OriginalColorMask[4];
+    inline void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+    {
+        if(!m_ColorMaskCalled) {
+            m_ColorMaskCalled = true;
+            glGetBooleanv(GL_COLOR_WRITEMASK,  m_OriginalColorMask);
+        }
+        ::glColorMask(red, green, blue, alpha);
+    }
+
+    bool m_ViewportCalled;
+    GLint m_OriginalViewport[4];
+    inline void glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+    {
+        if(!m_ViewportCalled) {
+            m_ViewportCalled = true;
+            glGetIntegerv(GL_VIEWPORT, m_OriginalViewport);
+        }
+        ::glViewport(x, y, width, height);
+    }
+
+    std::stack<CapabilityState> m_history;
+};
+
+}