c9887c76edf8bc22d935c6d311b9bc08e1b7b0e1fc7c155f7fc2fc66524fb1e7

third-party/DPVO/Pangolin/LICENCE

@@ -0,0 +1,22 @@
+Copyright (c) 2011 Steven Lovegrove and 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.

third-party/DPVO/Pangolin/README.md

@@ -0,0 +1,235 @@
+What is Pangolin
+====================================
+
+Pangolin is a set of lightweight and portable utility libraries for prototyping 3D, numeric or video based programs and algorithms. It is used quite widely in the field of Computer Vision as a means to remove platform-specific boilerplate and make it easy to visualize data.
+
+The general ethos of Pangolin is to minimize boilerplate and maximize portability and flexibility through simple interfaces and factories over things like windowing and video. It also offers a suite of utilities for interactive debugging, such as 3D manipulation, plotters, tweak variables, and a drop-down Quake-like console for python scripting and live tweaking.
+
+
+
+## Main features
+
+* Cross Platform Windowing
+  * Build for **Windows**, **Linux**, **OSX** and the **Web** (with [Emscripten](https://emscripten.org/))
+  * Support different windowing implementations including off-screen buffers
+* Viewport Management and Interaction
+  * Simple and performant viewport management
+  * Intuitive 3D navigation and handlers
+  * Utilities to work with Computer Vision & Robotics camera and coordinate conventions
+* Video Input and Output
+  * Extensive video input/output wrappers for ordinary and machine-vision cameras and media formats
+  * Flexible filter interface for easily post-processing video channels and formats, etc.
+* Tweak Variables
+  * There are 101 widgeting libraries and several 'tweak' var libraries - Pangolin offers another implementation with a few pros and cons
+  * One-line definitions and extensible types
+* Drop-down Console
+  * Extensible for different shells, but currently supports Python live console
+  * Easy access to introspect tweak variables
+
+
+
+## Code ##
+
+Find the latest version on [Github](http://github.com/stevenlovegrove/Pangolin):
+
+```bash
+# Clone Pangolin along with it's submodules
+git clone --recursive https://github.com/stevenlovegrove/Pangolin.git
+```
+
+
+
+## Dependencies ##
+
+*Pangolin* is split into a few *components* so you can include just what you need. Most dependencies are *optional* so you can pick and mix for your needs. Rather than enforcing a particular package manager, you can use a simple [script](https://github.com/stevenlovegrove/Pangolin/blob/master/scripts/install_prerequisites.sh) to generate a list of (**required**, **recommended** or **all**) packages for installation for that manager (e.g. apt, port, brew, dnf, vcpkg):
+
+```bash
+# See what package manager and packages are recommended
+./scripts/install_prerequisites.sh --dry-run recommended
+
+# Override the package manager choice and install all packages
+./scripts/install_prerequisites.sh -m brew all
+```
+
+You'll see the dependencies are generally
+
+* Build system (cmake, **required**)
+* Windowing system (X11, Cocoa, Win, Web, ...)
+* Rendering (OpenGL, GLES)
+* Video and Image loading (DC1394, ffmpeg, jpeg, png, ...)
+* Wrappers / Cross Compilers (Python3, pybind, Emscripten, ...)
+
+Pangolin does it's best to build something with what it gets, so dependencies which are not found will be silently ignored. If you need a particular feature, check the output of the `cmake ..` stage and look for the *Found and Enabled* lines.
+
+
+
+## Building ##
+
+Pangolin uses the CMake portable pre-build tool. To checkout and build pangolin in the
+directory 'build', execute the following at a shell (or the equivalent using a GUI):
+
+```bash
+# Get Pangolin
+cd ~/your_fav_code_directory
+git clone --recursive https://github.com/stevenlovegrove/Pangolin.git
+cd Pangolin
+
+# Install dependencies (as described above, or your preferred method)
+./scripts/install_prerequisites.sh recommended
+
+# Configure and build
+cmake -B build
+cmake --build build
+
+# with Ninja for faster builds (sudo apt install ninja-build)
+cmake -B build -GNinja
+cmake --build build
+
+# GIVEME THE PYTHON STUFF!!!! (Check the output to verify selected python version)
+cmake --build build -t pypangolin_pip_install
+
+# Run me some tests! (Requires Catch2 which must be manually installed on Ubuntu.)
+ctest
+```
+
+![Master Build](https://github.com/stevenlovegrove/pangolin/actions/workflows/build.yml/badge.svg?branch=master) p.s. The *master* branch is a development branch. Choose a [stable tag](https://github.com/stevenlovegrove/Pangolin/tags) if you prefer.
+
+
+
+#### On Windows
+
+ I'd recommend building natively with the [Build Tools for Visual Studio 2019](https://visualstudio.microsoft.com/downloads/) toolchain (and not mingw or WSL etc which is unsupported). I recommend [gitbash](https://git-scm.com/downloads) for executing the bash snippets on this page and cloning Pangolin. You can work from within their provided console or the fancy new [Windows Terminal](https://devblogs.microsoft.com/commandline/introducing-windows-terminal/) which is a huge improvement to the developer experience on Windows.
+
+#### With Python
+
+You have to be careful about what python version Pangolin has found and is attempting to link against. It will tell you during the `cmake ..` step and you can change it by explicitly telling it the python executable with `cmake -DPYTHON_EXECUTABLE=/path/to/python ..`or ``cmake -DPYTHON_EXECUTABLE=`which python3` `` to use the python accessed through the `python3` alias.
+
+If python is found, the pypangolin module will be built with the default `all` target. A Python wheel can be built manually using the `pypangolin_wheel` target, and the wheel can be installed / uninstalled with `pypangolin_pip_install` and `pypangolin_pip_uninstall` targets.
+
+**NOTE** The python wheel and install targets are only currently working on MacOS and Linux. On Windows, you're out of luck right now. Help appreciated!
+
+#### On the Web
+
+See [**Emscripten (Compile for web)**](#emscripten-compile-for-web) below.
+
+
+## Examples
+
+Pangolin is mostly documented through it's simple examples which you can find in the [*examples*](https://github.com/stevenlovegrove/Pangolin/tree/master/examples) folder and [*examples/PythonExamples*](https://github.com/stevenlovegrove/Pangolin/tree/master/examples/PythonExamples) for python versions.
+
+Browse some [**online**](https://stevenlovegrove.github.io/Pangolin/examples) and even run them in your browser, such as [**SimplePlot**](https://stevenlovegrove.github.io/Pangolin/emscripten/examples/SimplePlot), [**SimpleDisplay**](https://stevenlovegrove.github.io/Pangolin/emscripten/examples/SimpleDisplay/) and [**SimpleMultiDisplay**](https://stevenlovegrove.github.io/Pangolin/emscripten/examples/SimpleMultiDisplay/).
+
+## Issues ##
+
+Please visit [Github Issues](https://github.com/stevenlovegrove/Pangolin/issues) to view and report problems with Pangolin. Issues and pull requests should be raised against the master branch which contains the current development version.
+
+Please note; most Pangolin dependencies are optional - to disable a dependency which may be causing trouble on your machine, set the BUILD_PANGOLIN_(option) variable to false with a cmake configuration tool (e.g. ccmake or cmake-gui).
+
+#### Common Runtime Problems
+
+<u>Framebuffer with requested attributes not available</u>: You're building against an old or unaccelerated OpenGL version. Either your graphics drivers are not correctly installed or you are on an unusual platform (such as within Docker, in a VM, working over an X forwarding SSH session) which has limited graphics acceleration. For the former case, you need to make sure your system is using appropriate drivers (you can test glxgears / glxinfo on linux for instance). There isn't much you can do about the latter except changing your setup (e.g. finding a VM which can better accelerate your graphics, or perhaps using the [nvidia-docker](https://github.com/NVIDIA/nvidia-docker) wrapper around docker to correctly pass through the graphics driver)
+
+#### Common Python Problems
+
+<u>error: unknown target 'pypangolin_wheels'</u> : cmake didn't find your python. Go back and adjust your cmake variables (such as the tip above) until you see something like "Selected Python: '/opt/local/bin/python3.9'" in the output.
+
+<u>ModuleNotFoundError: No module named 'pypangolin'</u>: Did you install the wheel (see the bash comment under build)? Are you running using the same Python as Pangolin found during the `cmake ..` step?
+
+
+
+## Contributions and Continuous Integration ##
+
+For CI, Pangolin uses [Github Actions](https://github.com/stevenlovegrove/Pangolin/actions) for Windows, MacOS, Linux and Emscripten (Web).
+
+To contribute to Pangolin, I would appreciate pull requests against the master branch. If you raise an issue, please include your environment (compiler, operating system, etc).
+
+
+
+## Extensibility & Factories
+
+Pangolin uses an extensible factory mechanism for modularising video drivers, windowing backends and console interpreters. Concrete instances are instantiated from a particular factory using a URI string which identifies which factory to use and what parameters it should use. As strings, URI's are a useful mechanism for providing and validating configuration from an end user. The URI form is:
+`module_name:[option1=value1,option2=value2,...]//module_resource_to_open`.
+
+#### Video URI's
+
+The *VideoViewer* tool takes these URI's directly in order to specify what images or video to load and show:
+
+```bash
+VideoViewer test://
+VideoViewer uvc:[size=640x480]///dev/video0
+VideoViewer flip://debayer:[tile=rggb,method=downsample]//file://~/somefile.pango
+```
+
+Notice that for video, some modules support chaining to construct a simple filter graph.
+
+#### Window URI's
+
+Windowing in Pangolin is also backed by a factory. When an application calls CreateWindowAndBind() or similar, the default:// URI is specified. This can be overriden to use different windowing options by setting the`PANGOLIN_WINDOW_URI` environment variable. e.g.
+
+
+```bash
+# Use the X11 Window Driver and override the default double buffered option
+PANGOLIN_WINDOW_URI="x11:[double_buffered=false]//" ./some_pangolin_app
+
+# Create a 'virtual' window using a framebuffer
+PANGOLIN_WINDOW_URI="headless://" ./another_pangolin_app
+```
+
+Some window parameters that may be interesting to override are `DISPLAYNAME`, `DOUBLEBUFFER`, `SAMPLE_BUFFERS`, `SAMPLES`, `HIGHRES`. Window modules currently include `x11`, `winapi`, `cocoa`.
+
+#### Fonts
+
+Additionally, there are a couple of special parameters that can be passed through the `PANGOLIN_WINDOW_URI` environment variable to change the default font or adjust the default font size:
+
+```bash
+PANGOLIN_WINDOW_URI="default:[default_font_size=20]//" ./some_pangolin_app
+
+PANGOLIN_WINDOW_URI="default:[default_font=my_awesome_font.ttf,default_font_size=20]//" ./some_pangolin_app
+```
+
+To use Pangolin in your applications whilst being conscientious of changing fonts, you can query how long fonts or text are with:
+
+```C++
+#include <pangolin/display/default_font.h>
+int func()
+{
+    // E.g. Choose sensible size for Pangolin Panel
+    const int PANEL_WIDTH = 20* pangolin::default_font().MaxWidth();
+    ...
+    // E.g. Work out some column width etc.
+    const int COL_WIDTH = pangolin::default_font().Text("How big is this text?").Width();
+}
+```
+
+
+
+## Emscripten (Compile for web) ##
+
+Emscripten is a neat c++ compiler which can output javascript executable code. That's right, your Pangolin programs can run on the web, too!
+
+Follow Emscriptens instructions to install the SDK (summarized below):
+
+```bash
+mkdir ~/tools && cd ~/tools
+git clone https://github.com/emscripten-core/emsdk.git
+cd emsdk && ./emsdk install latest && ./emsdk activate latest
+```
+
+To build Pangolin with the Emscripten toolchain, create a new build directory, make sure Emscripten is on your PATH, and use the `emconfigure` utility to run CMake with the custom toolchain settings:
+
+```bash
+cd ~/code/Pangolin
+mkdir build-em && cd build-em
+source ~/tools/emsdk/emsdk_env.sh
+emcmake cmake ..
+```
+
+## Acknowledgements ##
+
+I'd like to thank the growing number of kind contributors to Pangolin for helping to make it more stable and feature rich. Many features of Pangolin have been influenced by other projects such as GFlags, GLConsole, and libcvd in particular. I'd also like to thank the FOSS projects on which Pangolin depends.
+
+For a summary of those who have made code contributions, execute:
+
+```bash
+git shortlog -sne
+```

third-party/DPVO/Pangolin/examples/HelloPangolin/CMakeLists.txt

@@ -0,0 +1,6 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.8 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(HelloPangolin main.cpp)
+target_link_libraries(HelloPangolin pango_display pango_python)

third-party/DPVO/Pangolin/examples/HelloPangolin/main.cpp

@@ -0,0 +1,37 @@
+#include <pangolin/display/display.h>
+#include <pangolin/display/view.h>
+#include <pangolin/handler/handler.h>
+#include <pangolin/gl/gldraw.h>
+
+int main( int /*argc*/, char** /*argv*/ )
+{
+    pangolin::CreateWindowAndBind("Main",640,480);
+    glEnable(GL_DEPTH_TEST);
+
+    // Define Projection and initial ModelView matrix
+    pangolin::OpenGlRenderState s_cam(
+        pangolin::ProjectionMatrix(640,480,420,420,320,240,0.2,100),
+        pangolin::ModelViewLookAt(-2,2,-2, 0,0,0, pangolin::AxisY)
+    );
+
+    // Create Interactive View in window
+    pangolin::Handler3D handler(s_cam);
+    pangolin::View& d_cam = pangolin::CreateDisplay()
+            .SetBounds(0.0, 1.0, 0.0, 1.0, -640.0f/480.0f)
+            .SetHandler(&handler);
+
+    while( !pangolin::ShouldQuit() )
+    {
+        // Clear screen and activate view to render into
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        d_cam.Activate(s_cam);
+
+        // Render OpenGL Cube
+        pangolin::glDrawColouredCube();
+
+        // Swap frames and Process Events
+        pangolin::FinishFrame();
+    }
+
+    return 0;
+}

third-party/DPVO/Pangolin/examples/HelloPangolinOffscreen/CMakeLists.txt

@@ -0,0 +1,6 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.5 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(HelloPangolinOffscreen main.cpp)
+target_link_libraries(HelloPangolinOffscreen pango_display)

third-party/DPVO/Pangolin/examples/HelloPangolinOffscreen/main.cpp

@@ -0,0 +1,44 @@
+#include <pangolin/display/display.h>
+#include <pangolin/display/view.h>
+#include <pangolin/handler/handler.h>
+#include <pangolin/gl/gldraw.h>
+
+int main( int /*argc*/, char** /*argv*/ )
+{
+    static const int w = 640;
+    static const int h = 480;
+
+    pangolin::CreateWindowAndBind("Main",w,h,pangolin::Params({{"scheme", "headless"}}));
+    glEnable(GL_DEPTH_TEST);
+
+    // Define Projection and initial ModelView matrix
+    pangolin::OpenGlRenderState s_cam(
+        pangolin::ProjectionMatrix(w,h,420,420,320,240,0.2,100),
+        pangolin::ModelViewLookAt(-2,2,-2, 0,0,0, pangolin::AxisY)
+    );
+
+    // create a frame buffer object with colour and depth buffer
+    pangolin::GlTexture color_buffer(w,h);
+    pangolin::GlRenderBuffer depth_buffer(w,h);
+    pangolin::GlFramebuffer fbo_buffer(color_buffer, depth_buffer);
+
+    fbo_buffer.Bind();
+    {
+        // Clear screen and activate view to render into
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        glViewport(0,0,w,h);
+        s_cam.Apply();
+
+        // Render OpenGL Cube
+        pangolin::glDrawColouredCube();
+
+        // Swap frames and Process Events
+        pangolin::FinishFrame();
+    }
+    fbo_buffer.Unbind();
+
+    // download and save the colour buffer
+    color_buffer.Save("fbo.png", false);
+
+    return 0;
+}

third-party/DPVO/Pangolin/examples/HelloPangolinThreads/CMakeLists.txt

@@ -0,0 +1,9 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.5 REQUIRED)
+find_package(Threads QUIET)
+
+if(Theads_FOUND)
+    add_executable(HelloPangolinThreads main.cpp)
+    target_include_directories(HelloPangolinThreads ${Pangolin_INCLUDE_DIRS})
+    target_link_libraries(HelloPangolinThreads pango_display Threads::Threads)
+endif()

third-party/DPVO/Pangolin/examples/HelloPangolinThreads/main.cpp

@@ -0,0 +1,67 @@
+#include <pangolin/display/display.h>
+#include <pangolin/display/view.h>
+#include <pangolin/gl/gl.h>
+
+#include <thread>
+
+static const std::string window_name = "HelloPangolinThreads";
+
+void setup() {
+    // create a window and bind its context to the main thread
+    pangolin::CreateWindowAndBind(window_name, 640, 480);
+
+    // enable depth
+    glEnable(GL_DEPTH_TEST);
+
+    // unset the current context from the main thread
+    pangolin::GetBoundWindow()->RemoveCurrent();
+}
+
+void run() {
+    // fetch the context and bind it to this thread
+    pangolin::BindToContext(window_name);
+
+    // we manually need to restore the properties of the context
+    glEnable(GL_DEPTH_TEST);
+
+    // Define Projection and initial ModelView matrix
+    pangolin::OpenGlRenderState s_cam(
+        pangolin::ProjectionMatrix(640,480,420,420,320,240,0.2,100),
+        pangolin::ModelViewLookAt(-2,2,-2, 0,0,0, pangolin::AxisY)
+    );
+
+    // Create Interactive View in window
+    pangolin::Handler3D handler(s_cam);
+    pangolin::View& d_cam = pangolin::CreateDisplay()
+            .SetBounds(0.0, 1.0, 0.0, 1.0, -640.0f/480.0f)
+            .SetHandler(&handler);
+
+    while( !pangolin::ShouldQuit() )
+    {
+        // Clear screen and activate view to render into
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        d_cam.Activate(s_cam);
+
+        // Render OpenGL Cube
+        pangolin::glDrawColouredCube();
+
+        // Swap frames and Process Events
+        pangolin::FinishFrame();
+    }
+
+    // unset the current context from the main thread
+    pangolin::GetBoundWindow()->RemoveCurrent();
+}
+
+int main( int /*argc*/, char** /*argv*/ )
+{
+    // create window and context in the main thread
+    setup();
+
+    // use the context in a separate rendering thread
+    std::thread render_loop;
+    render_loop = std::thread(run);
+    render_loop.join();
+
+    return 0;
+}

third-party/DPVO/Pangolin/examples/PythonExamples/SimpleDisplay.py

@@ -0,0 +1,65 @@
+import sys
+
+import pypangolin as pango
+from OpenGL.GL import *
+
+
+def a_callback():
+    print("a pressed")
+
+
+def main():
+    win = pango.CreateWindowAndBind("pySimpleDisplay", 640, 480)
+    glEnable(GL_DEPTH_TEST)
+
+    pm = pango.ProjectionMatrix(640, 480, 420, 420, 320, 240, 0.1, 1000)
+    mv = pango.ModelViewLookAt(-0, 0.5, -3, 0, 0, 0, pango.AxisY)
+    s_cam = pango.OpenGlRenderState(pm, mv)
+
+    ui_width = 180
+
+    handler = pango.Handler3D(s_cam)
+    d_cam = (
+        pango.CreateDisplay()
+        .SetBounds(
+            pango.Attach(0),
+            pango.Attach(1),
+            pango.Attach.Pix(ui_width),
+            pango.Attach(1),
+            -640.0 / 480.0,
+        )
+        .SetHandler(handler)
+    )
+
+    pango.CreatePanel("ui").SetBounds(
+        pango.Attach(0), pango.Attach(1), pango.Attach(0), pango.Attach.Pix(ui_width)
+    )
+    var_ui = pango.Var("ui")
+    var_ui.a_Button = False
+    var_ui.a_Toggle = (False, pango.VarMeta(toggle=True))
+    var_ui.a_double = (0.0, pango.VarMeta(0, 5))
+    var_ui.an_int = (2, pango.VarMeta(0, 5))
+    var_ui.a_double_log = (3.0, pango.VarMeta(1, 1e4, logscale=True))
+    var_ui.a_checkbox = (False, pango.VarMeta(toggle=True))
+    var_ui.an_int_no_input = 2
+    var_ui.a_str = "sss"
+
+    ctrl = -96
+    pango.RegisterKeyPressCallback(ctrl + ord("a"), a_callback)
+
+    while not pango.ShouldQuit():
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+
+        if var_ui.a_checkbox:
+            var_ui.an_int = var_ui.a_double
+
+        if var_ui.GuiChanged('an_int'):
+            var_ui.an_int_no_input = var_ui.an_int
+
+        d_cam.Activate(s_cam)
+        pango.glDrawColouredCube()
+        pango.FinishFrame()
+
+
+if __name__ == "__main__":
+    main()

third-party/DPVO/Pangolin/examples/PythonExamples/SimplePlot.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+import sys
+sys.path.append('../build/src')
+
+from OpenGL.GL import *
+import pypangolin as pango
+import math
+
+def main():
+    win = pango.CreateWindowAndBind("main py_pangolin", 640, 480)
+    log = pango.DataLog()
+    log.SetLabels(["sin(t)", "cos(t)", "sin(t)+cos(t)"])
+
+    t=0;
+    tinc=0.01
+
+    plotter = pango.Plotter(log,0,4*math.pi/tinc,-2,2,math.pi/(4*tinc),0.5);
+    plotter.Track("$i")
+    plotter.AddMarker(pango.Marker.Vertical, -1000, pango.Marker.LessThan, pango.Colour.Blue().WithAlpha(0.2))
+    plotter.AddMarker(pango.Marker.Horizontal, 100, pango.Marker.GreaterThan, pango.Colour.Red().WithAlpha(0.2))
+    plotter.AddMarker(pango.Marker.Horizontal,  10, pango.Marker.Equal, pango.Colour.Green().WithAlpha(0.2))
+    plotter.SetBounds(pango.Attach(0), pango.Attach(1),
+                      pango.Attach(0), pango.Attach(1))
+
+    pango.DisplayBase().AddDisplay(plotter)
+
+    while not pango.ShouldQuit():
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+
+        log.Log(math.sin(t), math.cos(t), math.sin(t)+math.cos(t))
+        t+=tinc
+
+        pango.FinishFrame()
+
+if __name__ == "__main__":
+    main()

third-party/DPVO/Pangolin/examples/PythonExamples/SimpleVideo.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+import sys
+import os
+import argparse
+import numpy as np
+import time
+import json
+
+# If this example doesn't work, it's probably because this path is wrong...
+sys.path.append('../build/src')
+
+import pypangolin as pango
+
+def main(flags):
+    vid_uri = flags.pango
+    vout_uri = flags.pangoOut
+
+    vid = pango.VideoInput(vid_uri)
+    vout = pango.VideoOutput(vout_uri) if vout_uri else None
+
+    device_properties = vid.DeviceProperties()
+
+    # print metadata
+    print("Opened video uri: '{}' with {} x {} dimensions".format( vid_uri,vid.Width(),vid.Height()))
+
+    # user specified initial frame
+    vid.Seek(flags.startFrame)
+
+    # show each frame
+    streamsBitDepth = vid.GetStreamsBitDepth()
+
+    for frame in vid:
+        if vout:
+            vout.WriteStreams(frame, streamsBitDepth, vid.FrameProperties(), device_properties);
+
+        # frame is a list of Images! One per stream
+        # process(frame)
+
+        # printing
+        sys.stdout.write('\rframe: {} / {}'.format(vid.GetCurrentFrameId(), vid.GetTotalFrames()))
+
+    print('\nDONE')
+
+if __name__ == "__main__":
+    # input flags
+    parser = argparse.ArgumentParser('Read a .pango file frame by frame. Optionally stream to another video output.')
+    parser.add_argument(
+        '--pango', type=str,
+        help='path to the input pango file.')
+    parser.add_argument(
+        '--startFrame', type=int, default=0,
+        help='index of the start frame (inclusive)')
+    parser.add_argument(
+        '--pangoOut', type=str, default=None,
+        help='path to the output pango file.')
+
+    # main function
+    main(parser.parse_args())

third-party/DPVO/Pangolin/examples/SharedMemoryCamera/CMakeLists.txt

@@ -0,0 +1,7 @@
+if(UNIX)
+find_package(Pangolin 0.8 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(SharedMemoryCamera main.cpp)
+target_link_libraries(SharedMemoryCamera pango_display)
+endif()

third-party/DPVO/Pangolin/examples/SharedMemoryCamera/main.cpp

@@ -0,0 +1,53 @@
+#include <pangolin/pangolin.h>
+
+#include <pangolin/utils/posix/condition_variable.h>
+#include <pangolin/utils/posix/shared_memory_buffer.h>
+#include <pangolin/utils/timer.h>
+
+#include <cmath>
+#include <memory>
+
+// This sample acts as a soft camera. It writes a pattern of GRAY8 pixels to the
+// shared memory space. It can be seen in Pangolin's SimpleVideo sample using
+// the shmem:[size=640x480]//example video URI.
+
+using namespace pangolin;
+
+unsigned char generate_value(double t)
+{
+  // 10s sinusoid
+  const double d = std::sin(t * 10.0 / M_PI) * 128.0 + 128.0;
+  return static_cast<unsigned char>(d);
+}
+
+int main(/*int argc, char *argv[]*/)
+{
+  std::string shmem_name = "/example";
+
+  std::shared_ptr<SharedMemoryBufferInterface> shmem_buffer =
+    create_named_shared_memory_buffer(shmem_name, 640 * 480);
+  if (!shmem_buffer) {
+    perror("Unable to create shared memory buffer");
+    exit(1);
+  }
+
+  std::string cond_name = shmem_name + "_cond";
+  std::shared_ptr<ConditionVariableInterface> buffer_full =
+    create_named_condition_variable(cond_name);
+
+  // Sit in a loop and write gray values based on some timing pattern.
+  while (true) {
+    shmem_buffer->lock();
+    unsigned char *ptr = shmem_buffer->ptr();
+    unsigned char value = generate_value(std::chrono::system_clock::now().time_since_epoch().count());
+
+    for (int i = 0; i < 640*480; ++i) {
+      ptr[i] = value;
+    }
+
+    shmem_buffer->unlock();
+    buffer_full->signal();
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+  }
+}

third-party/DPVO/Pangolin/examples/SimpleDisplay/CMakeLists.txt

@@ -0,0 +1,7 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.8 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(SimpleDisplay main.cpp)
+target_link_libraries(SimpleDisplay pango_display pango_python )
+

third-party/DPVO/Pangolin/examples/SimpleDisplay/app.cfg

@@ -0,0 +1,26 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Pangolin Sample configuration file
+%  Comments start with '%' or '#'
+%
+%  Declarations are name value pairs,
+%  seperated with '=' and terminated with ';'
+
+% We can set any variable referenced in code directly
+ui.A Double = 3.2;
+ui.A Checkbox = false;
+
+% We can set unreferenced variables too
+a.b = 1;
+a.c = 2;
+z.b = 3;
+z.c = 4;
+start = z;
+
+% Which we might refer to by reference
+ui.An Int = ${${start}.c};
+
+% Declarations can span multiple lines
+M =
+[1, 0, 0
+ 0, 1, 0
+ 0, 0, 1];

third-party/DPVO/Pangolin/examples/SimpleDisplay/main.cpp

@@ -0,0 +1,96 @@
+#include <iostream>
+
+#include <pangolin/var/var.h>
+#include <pangolin/var/varextra.h>
+#include <pangolin/gl/gl.h>
+#include <pangolin/gl/gldraw.h>
+#include <pangolin/display/display.h>
+#include <pangolin/display/view.h>
+#include <pangolin/display/widgets.h>
+#include <pangolin/display/default_font.h>
+#include <pangolin/handler/handler.h>
+
+int main(/*int argc, char* argv[]*/)
+{  
+  // Create OpenGL window in single line
+  pangolin::CreateWindowAndBind("Main",640,480);
+  
+  // 3D Mouse handler requires depth testing to be enabled
+  glEnable(GL_DEPTH_TEST);
+
+  // Define Camera Render Object (for view / scene browsing)
+  pangolin::OpenGlRenderState s_cam(
+    pangolin::ProjectionMatrix(640,480,420,420,320,240,0.1,1000),
+    pangolin::ModelViewLookAt(-0,0.5,-3, 0,0,0, pangolin::AxisY)
+  );
+
+  // Choose a sensible left UI Panel width based on the width of 20
+  // charectors from the default font.
+  const int UI_WIDTH = 20* pangolin::default_font().MaxWidth();
+
+  // Add named OpenGL viewport to window and provide 3D Handler
+  pangolin::View& d_cam = pangolin::CreateDisplay()
+    .SetBounds(0.0, 1.0, pangolin::Attach::Pix(UI_WIDTH), 1.0, 640.0f/480.0f)
+    .SetHandler(new pangolin::Handler3D(s_cam));
+
+  // Add named Panel and bind to variables beginning 'ui'
+  // A Panel is just a View with a default layout and input handling
+  pangolin::CreatePanel("ui")
+      .SetBounds(0.0, 1.0, 0.0, pangolin::Attach::Pix(UI_WIDTH));
+
+  // Safe and efficient binding of named variables.
+  // Specialisations mean no conversions take place for exact types
+  // and conversions between scalar types are cheap.
+  pangolin::Var<bool> a_button("ui.A_Button",false,false);
+  pangolin::Var<double> a_double("ui.A_Double",3,0,5);
+  pangolin::Var<int> an_int("ui.An_Int",2,0,5);
+  pangolin::Var<double> a_double_log("ui.Log_scale",3,1,1E4, true);
+  pangolin::Var<bool> a_checkbox("ui.A_Checkbox",false,true);
+  pangolin::Var<int> an_int_no_input("ui.An_Int_No_Input",2);
+  pangolin::Var<std::string> a_string("ui.A_String", "Edit ME!");
+
+  // std::function objects can be used for Var's too. These work great with C++11 closures.
+  pangolin::Var<std::function<void(void)>> save_window("ui.Save_Window", [](){
+      pangolin::SaveWindowOnRender("window");
+  });
+
+  pangolin::Var<std::function<void(void)>> save_cube_view("ui.Save_Cube", [&d_cam](){
+      pangolin::SaveWindowOnRender("cube", d_cam.v);
+  });
+
+  // Demonstration of how we can register a keyboard hook to alter a Var
+  pangolin::RegisterKeyPressCallback(pangolin::PANGO_CTRL + 'b', [&](){
+      a_double = 3.5;
+  });
+
+  // Default hooks for exiting (Esc) and fullscreen (tab).
+  while( !pangolin::ShouldQuit() )
+  {
+    // Clear entire screen
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);    
+
+    if( pangolin::Pushed(a_button) )
+      std::cout << "You Pushed a button!" << std::endl;
+
+    // Overloading of Var<T> operators allows us to treat them like
+    // their wrapped types, eg:
+    if( a_checkbox )
+      an_int = (int)a_double;
+
+    an_int_no_input = an_int;
+
+    if(d_cam.IsShown()) {
+        // Activate efficiently by object
+        d_cam.Activate(s_cam);
+
+        // Render some stuff
+        glColor3f(1.0,1.0,1.0);
+        pangolin::glDrawColouredCube();
+    }
+
+    // Swap frames and Process Events
+    pangolin::FinishFrame();
+  }
+
+  return 0;
+}

third-party/DPVO/Pangolin/examples/SimpleDisplayImage/CMakeLists.txt

@@ -0,0 +1,6 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.8 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(SimpleDisplayImage main.cpp)
+target_link_libraries(SimpleDisplayImage pango_display)

third-party/DPVO/Pangolin/examples/SimpleDisplayImage/main.cpp

@@ -0,0 +1,76 @@
+#include <limits>
+#include <iostream>
+
+#include <pangolin/display/display.h>
+#include <pangolin/display/view.h>
+#include <pangolin/handler/handler.h>
+#include <pangolin/gl/gldraw.h>
+
+void setImageData(unsigned char * imageArray, int size){
+  for(int i = 0 ; i < size;i++) {
+    imageArray[i] = (unsigned char)(rand()/(RAND_MAX/255.0));
+  }
+}
+
+int main(/*int argc, char* argv[]*/)
+{
+  // Create OpenGL window in single line
+  pangolin::CreateWindowAndBind("Main",640,480);
+
+  // 3D Mouse handler requires depth testing to be enabled
+  glEnable(GL_DEPTH_TEST);
+  
+  pangolin::OpenGlRenderState s_cam(
+    pangolin::ProjectionMatrix(640,480,420,420,320,240,0.1,1000),
+    pangolin::ModelViewLookAt(-1,1,-1, 0,0,0, pangolin::AxisY)
+  );
+
+  // Aspect ratio allows us to constrain width and height whilst fitting within specified
+  // bounds. A positive aspect ratio makes a view 'shrink to fit' (introducing empty bars),
+  // whilst a negative ratio makes the view 'grow to fit' (cropping the view).
+  pangolin::View& d_cam = pangolin::Display("cam")
+      .SetBounds(0,1.0f,0,1.0f,-640/480.0)
+      .SetHandler(new pangolin::Handler3D(s_cam));
+
+  // This view will take up no more than a third of the windows width or height, and it
+  // will have a fixed aspect ratio to match the image that it will display. When fitting
+  // within the specified bounds, push to the top-left (as specified by SetLock).
+  pangolin::View& d_image = pangolin::Display("image")
+      .SetBounds(2/3.0f,1.0f,0,1/3.0f,640.0/480)
+      .SetLock(pangolin::LockLeft, pangolin::LockTop);
+
+  std::cout << "Resize the window to experiment with SetBounds, SetLock and SetAspect." << std::endl;
+  std::cout << "Notice that the cubes aspect is maintained even though it covers the whole screen." << std::endl;
+
+  const int width =  64;
+  const int height = 48;
+
+  unsigned char* imageArray = new unsigned char[3*width*height];
+  pangolin::GlTexture imageTexture(width,height,GL_RGB,false,0,GL_RGB,GL_UNSIGNED_BYTE);
+
+  // Default hooks for exiting (Esc) and fullscreen (tab).
+  while(!pangolin::ShouldQuit())
+  {
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    d_cam.Activate(s_cam);
+
+    glColor3f(1.0,1.0,1.0);
+    pangolin::glDrawColouredCube();
+
+    //Set some random image data and upload to GPU
+    setImageData(imageArray,3*width*height);
+    imageTexture.Upload(imageArray,GL_RGB,GL_UNSIGNED_BYTE);
+
+    //display the image
+    d_image.Activate();
+    glColor3f(1.0,1.0,1.0);
+    imageTexture.RenderToViewport();
+
+    pangolin::FinishFrame();
+  }
+
+  delete[] imageArray;
+
+  return 0;
+}

third-party/DPVO/Pangolin/examples/SimpleMultiDisplay/CMakeLists.txt

@@ -0,0 +1,6 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.8 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(SimpleMultiDisplay main.cpp)
+target_link_libraries(SimpleMultiDisplay pango_display)

third-party/DPVO/Pangolin/examples/SimpleMultiDisplay/app.cfg

@@ -0,0 +1,28 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Pangolin Sample configuration file
+%  Comments start with '%' or '#'
+%
+%  Declarations are name value pairs,
+%  seperated with '=' and terminated with ';'
+
+% We can set any variable referenced in code directly
+ui.A Double = 3.2;
+
+% We can set unreferenced variables too
+a.b = 1;
+a.c = 2;
+z.b = 3;
+z.c = 4;
+start = z;
+
+% Which we might refer to by reference
+ui.An Int = ${${start}.c};
+
+% Declarations can span multiple lines
+M =
+[1, 0, 0
+ 0, 1, 0
+ 0, 0, 1];
+
+ui.Aliased Double = @ui.A Double;
+ui.Aliased Double = 2.0;

third-party/DPVO/Pangolin/examples/SimpleMultiDisplay/main.cpp

@@ -0,0 +1,108 @@
+#include <pangolin/display/display.h>
+#include <pangolin/display/view.h>
+#include <pangolin/handler/handler.h>
+#include <pangolin/gl/gldraw.h>
+
+void setImageData(unsigned char * imageArray, int size){
+  for(int i = 0 ; i < size;i++) {
+    imageArray[i] = (unsigned char)(rand()/(RAND_MAX/255.0));
+  }
+}
+
+int main(/*int argc, char* argv[]*/)
+{
+  // Create OpenGL window in single line
+  pangolin::CreateWindowAndBind("Main",640,480);
+  
+  // 3D Mouse handler requires depth testing to be enabled
+  glEnable(GL_DEPTH_TEST);  
+
+  // Issue specific OpenGl we might need
+  glEnable (GL_BLEND);
+  glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+  // Define Camera Render Object (for view / scene browsing)
+  pangolin::OpenGlMatrix proj = pangolin::ProjectionMatrix(640,480,420,420,320,240,0.1,1000);
+  pangolin::OpenGlRenderState s_cam(proj, pangolin::ModelViewLookAt(1,0.5,-2,0,0,0, pangolin::AxisY) );
+  pangolin::OpenGlRenderState s_cam2(proj, pangolin::ModelViewLookAt(0,0,-2,0,0,0, pangolin::AxisY) );
+
+  // Add named OpenGL viewport to window and provide 3D Handler
+  pangolin::View& d_cam1 = pangolin::Display("cam1")
+    .SetAspect(640.0f/480.0f)
+    .SetHandler(new pangolin::Handler3D(s_cam));
+
+  pangolin::View& d_cam2 = pangolin::Display("cam2")
+    .SetAspect(640.0f/480.0f)
+    .SetHandler(new pangolin::Handler3D(s_cam2));
+
+  pangolin::View& d_cam3 = pangolin::Display("cam3")
+    .SetAspect(640.0f/480.0f)
+    .SetHandler(new pangolin::Handler3D(s_cam));
+
+  pangolin::View& d_cam4 = pangolin::Display("cam4")
+    .SetAspect(640.0f/480.0f)
+    .SetHandler(new pangolin::Handler3D(s_cam2));
+
+  pangolin::View& d_img1 = pangolin::Display("img1")
+    .SetAspect(640.0f/480.0f);
+
+  pangolin::View& d_img2 = pangolin::Display("img2")
+    .SetAspect(640.0f/480.0f);
+
+  // LayoutEqual is an EXPERIMENTAL feature - it requires that all sub-displays
+  // share the same aspect ratio, placing them in a raster fasion in the
+  // viewport so as to maximise display size.
+  pangolin::Display("multi")
+      .SetBounds(0.0, 1.0, 0.0, 1.0)
+      .SetLayout(pangolin::LayoutEqual)
+      .AddDisplay(d_cam1)
+      .AddDisplay(d_img1)
+      .AddDisplay(d_cam2)
+      .AddDisplay(d_img2)
+      .AddDisplay(d_cam3)
+      .AddDisplay(d_cam4);
+
+  const int width =  64;
+  const int height = 48;
+  unsigned char* imageArray = new unsigned char[3*width*height];
+  pangolin::GlTexture imageTexture(width,height,GL_RGB,false,0,GL_RGB,GL_UNSIGNED_BYTE);
+
+  // Default hooks for exiting (Esc) and fullscreen (tab).
+  while( !pangolin::ShouldQuit() )
+  {
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    // Generate random image and place in texture memory for display
+    setImageData(imageArray,3*width*height);
+    imageTexture.Upload(imageArray,GL_RGB,GL_UNSIGNED_BYTE);
+
+    glColor3f(1.0,1.0,1.0);
+
+    d_cam1.Activate(s_cam);
+    pangolin::glDrawColouredCube();
+
+    d_cam2.Activate(s_cam2);
+    pangolin::glDrawColouredCube();
+
+    d_cam3.Activate(s_cam);
+    pangolin::glDrawColouredCube();
+
+    d_cam4.Activate(s_cam2);
+    pangolin::glDrawColouredCube();
+
+    d_img1.Activate();
+    glColor4f(1.0f,1.0f,1.0f,1.0f);
+    imageTexture.RenderToViewport();
+
+    d_img2.Activate();
+    glColor4f(1.0f,1.0f,1.0f,1.0f);
+    imageTexture.RenderToViewport();
+
+    // Swap frames and Process Events
+    pangolin::FinishFrame();
+  }
+
+  delete[] imageArray;
+
+  return 0;
+}

third-party/DPVO/Pangolin/examples/SimplePlot/CMakeLists.txt

@@ -0,0 +1,6 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.8 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(SimplePlot main.cpp)
+target_link_libraries(SimplePlot pango_display pango_plot)

third-party/DPVO/Pangolin/examples/SimplePlot/main.cpp

@@ -0,0 +1,48 @@
+#include <pangolin/display/display.h>
+#include <pangolin/plot/plotter.h>
+
+int main(/*int argc, char* argv[]*/)
+{
+  // Create OpenGL window in single line
+  pangolin::CreateWindowAndBind("Main",640,480);
+
+  // Data logger object
+  pangolin::DataLog log;
+
+  // Optionally add named labels
+  std::vector<std::string> labels;
+  labels.push_back(std::string("sin(t)"));
+  labels.push_back(std::string("cos(t)"));
+  labels.push_back(std::string("sin(t)+cos(t)"));
+  log.SetLabels(labels);
+
+  const float tinc = 0.01f;
+
+  // OpenGL 'view' of data. We might have many views of the same data.
+  pangolin::Plotter plotter(&log,0.0f,4.0f*(float)M_PI/tinc,-2.0f,2.0f,(float)M_PI/(4.0f*tinc),0.5f);
+  plotter.SetBounds(0.0, 1.0, 0.0, 1.0);
+  plotter.Track("$i");
+
+  // Add some sample annotations to the plot
+  plotter.AddMarker(pangolin::Marker::Vertical,   -1000, pangolin::Marker::LessThan, pangolin::Colour::Blue().WithAlpha(0.2f) );
+  plotter.AddMarker(pangolin::Marker::Horizontal,   100, pangolin::Marker::GreaterThan, pangolin::Colour::Red().WithAlpha(0.2f) );
+  plotter.AddMarker(pangolin::Marker::Horizontal,    10, pangolin::Marker::Equal, pangolin::Colour::Green().WithAlpha(0.2f) );
+
+  pangolin::DisplayBase().AddDisplay(plotter);
+
+  float t = 0;
+
+  // Default hooks for exiting (Esc) and fullscreen (tab).
+  while( !pangolin::ShouldQuit() )
+  {
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    log.Log(sin(t),cos(t),sin(t)+cos(t));
+    t += tinc;
+
+    // Render graph, Swap frames and Process Events
+    pangolin::FinishFrame();
+  }
+
+  return 0;
+}

third-party/DPVO/Pangolin/examples/SimpleRecord/CMakeLists.txt

@@ -0,0 +1,6 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.8 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(SimpleRecord main.cpp)
+target_link_libraries(SimpleRecord pango_display pango_video)

third-party/DPVO/Pangolin/examples/SimpleRecord/main.cpp

@@ -0,0 +1,100 @@
+#include <pangolin/display/display.h>
+#include <pangolin/display/view.h>
+#include <pangolin/gl/gl.h>
+#include <pangolin/gl/gldraw.h>
+#include <pangolin/video/video_input.h>
+
+void RecordSample(const std::string input_uri, const std::string record_uri)
+{
+    // Setup Video Source
+    pangolin::VideoInput video(input_uri);
+    const pangolin::PixelFormat vid_fmt = video.PixFormat();
+    const unsigned w = video.Width();
+    const unsigned h = video.Height();
+
+    pangolin::VideoOutput recorder( record_uri );
+    recorder.SetStreams(video.Streams());
+
+    // Create OpenGL window
+    pangolin::CreateWindowAndBind("Main",w,h);
+
+    // Create viewport for video with fixed aspect
+    pangolin::View vVideo((float)w/h);
+
+    // OpenGl Texture for video frame
+    pangolin::GlTexture texVideo(w,h,GL_RGBA);
+
+    // Allocate image buffer. The +1 is to give ffmpeg some alignment slack
+    // swscale seems to have a bug which goes over the array by 1...
+    unsigned char* img = new unsigned char[video.SizeBytes() + 1];
+    
+    while( !pangolin::ShouldQuit() )
+    {
+        glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
+
+        if( video.GrabNext(img,true) )
+        {
+            // Upload to GPU as texture for display
+            texVideo.Upload(img, vid_fmt.channels==1 ? GL_LUMINANCE:GL_RGB, GL_UNSIGNED_BYTE);
+
+            // Record video frame
+            recorder.WriteStreams(img);
+        }
+
+        // Activate video viewport and render texture
+        vVideo.Activate();
+        texVideo.RenderToViewportFlipY();
+
+        // Swap back buffer with front and process window events
+        pangolin::FinishFrame();
+    }
+
+    delete[] img;
+}
+
+int main( int argc, char* argv[] )
+{
+    std::string record_uri = "ffmpeg:[fps=30,bps=8388608]//video.avi";
+
+    std::string input_uris[] = {
+        "convert:[fmt=RGB24]//v4l:///dev/video0",
+        "convert:[fmt=RGB24]//v4l:///dev/video1",
+        "dc1394:[fps=30,dma=10,size=640x480,iso=400]//0",
+        "openni:[img1=rgb]//",
+        "test:[size=160x120,n=1,fmt=RGB24]//"
+        ""
+    };
+
+    if( argc >= 2 ) {
+        const std::string uri = std::string(argv[1]);
+        if( argc == 3 ) {
+            record_uri = std::string(argv[2]);
+        }
+        RecordSample(uri, record_uri);
+    }else{
+        std::cout << "Usage  : SimpleRecord [video-uri] [output-uri]" << std::endl << std::endl;
+        std::cout << "Where video-uri describes a stream or file resource, e.g." << std::endl;
+        std::cout << "\tfile:[realtime=1]///home/user/video/movie.pvn" << std::endl;
+        std::cout << "\tfile:///home/user/video/movie.avi" << std::endl;
+        std::cout << "\tfiles:///home/user/seqiemce/foo%03d.jpeg" << std::endl;
+        std::cout << "\tdc1394:[fmt=RGB24,size=640x480,fps=30,iso=400,dma=10]//0" << std::endl;
+        std::cout << "\tdc1394:[fmt=FORMAT7_1,size=640x480,pos=2+2,iso=400,dma=10]//0" << std::endl;
+        std::cout << "\tv4l:///dev/video0" << std::endl;
+        std::cout << "\tconvert:[fmt=RGB24]//v4l:///dev/video0" << std::endl;
+        std::cout << "\tmjpeg://http://127.0.0.1/?action=stream" << std::endl;
+        std::cout << std::endl;
+
+        // Try to open some video device
+        for(int i=0; !input_uris[i].empty(); ++i )
+        {
+            try{
+                std::cout << "Trying: " << input_uris[i] << std::endl;
+                RecordSample(input_uris[i], record_uri);
+                return 0;
+            }catch(const std::exception&) {}
+        }
+    }
+
+    return 0;
+
+}

third-party/DPVO/Pangolin/examples/SimpleScene/CMakeLists.txt

@@ -0,0 +1,6 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.8 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(SimpleScene main.cpp)
+target_link_libraries(SimpleScene pango_display pango_scene)

third-party/DPVO/Pangolin/examples/SimpleScene/main.cpp

@@ -0,0 +1,46 @@
+#include <pangolin/display/display.h>
+#include <pangolin/display/view.h>
+#include <pangolin/scene/axis.h>
+#include <pangolin/scene/scenehandler.h>
+
+int main( int /*argc*/, char** /*argv*/ )
+{
+    pangolin::CreateWindowAndBind("Main",640,480);
+    glEnable(GL_DEPTH_TEST);
+
+    // Define Projection and initial ModelView matrix
+    pangolin::OpenGlRenderState s_cam(
+        pangolin::ProjectionMatrix(640,480,420,420,320,240,0.2,100),
+        pangolin::ModelViewLookAt(-2,2,-2, 0,0,0, pangolin::AxisY)
+    );
+
+    pangolin::Renderable tree;
+    for(size_t i=0; i < 10; ++i ) 
+    {
+        auto axis_i = std::make_shared<pangolin::Axis>();
+        axis_i->T_pc = pangolin::OpenGlMatrix::Translate(i*2.0, i*0.1, 0.0);
+        tree.Add(axis_i);
+    }
+
+    // Create Interactive View in window
+    pangolin::SceneHandler handler(tree, s_cam);
+    pangolin::View& d_cam = pangolin::CreateDisplay()
+            .SetBounds(0.0, 1.0, 0.0, 1.0, -640.0f/480.0f)
+            .SetHandler(&handler);
+
+    d_cam.SetDrawFunction([&](pangolin::View& view){
+        view.Activate(s_cam);
+        tree.Render();
+    });
+
+    while( !pangolin::ShouldQuit() )
+    {
+        // Clear screen and activate view to render into
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        // Swap frames and Process Events
+        pangolin::FinishFrame();
+    }
+
+    return 0;
+}

third-party/DPVO/Pangolin/examples/SimpleVideo/CMakeLists.txt

@@ -0,0 +1,6 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.8 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+
+add_executable(SimpleVideo main.cpp)
+target_link_libraries(SimpleVideo pango_display pango_video)

third-party/DPVO/Pangolin/examples/SimpleVideo/main.cpp

@@ -0,0 +1,114 @@
+/**
+ * @author  Steven Lovegrove
+ * Copyright (C) 2010  Steven Lovegrove
+ *                     Imperial College London
+ **/
+
+#include <pangolin/display/display.h>
+#include <pangolin/display/view.h>
+#include <pangolin/video/video_input.h>
+#include <pangolin/gl/gl.h>
+
+
+void SetGlFormat(GLint& glformat, GLenum& gltype, const pangolin::PixelFormat& fmt)
+{
+    switch( fmt.channels) {
+    case 1: glformat = GL_LUMINANCE; break;
+    case 3: glformat = GL_RGB; break;
+    case 4: glformat = GL_RGBA; break;
+    default: throw std::runtime_error("Unable to display video format");
+    }
+
+    switch (fmt.channel_bits[0]) {
+    case 8: gltype = GL_UNSIGNED_BYTE; break;
+    case 16: gltype = GL_UNSIGNED_SHORT; break;
+    case 32: gltype = GL_FLOAT; break;
+    default: throw std::runtime_error("Unknown channel format");
+    }
+}
+
+void VideoSample(const std::string uri)
+{
+    // Setup Video Source
+    pangolin::VideoInput video(uri);
+    const pangolin::PixelFormat vid_fmt = video.PixFormat();
+    const unsigned w = video.Width();
+    const unsigned h = video.Height();
+
+    // Work out appropriate GL channel and format options
+    GLint glformat;
+    GLenum gltype;
+    SetGlFormat(glformat, gltype, vid_fmt);
+    
+    // Create OpenGL window
+    pangolin::CreateWindowAndBind("Main",w,h);
+
+    // Create viewport for video with fixed aspect
+    pangolin::View& vVideo = pangolin::Display("Video").SetAspect((float)w/h);
+
+    // OpenGl Texture for video frame.
+    pangolin::GlTexture texVideo(w,h,glformat,false,0,glformat,gltype);
+
+    unsigned char* img = new unsigned char[video.SizeBytes()];
+
+    for(int frame=0; !pangolin::ShouldQuit(); ++frame)
+    {
+        glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
+
+        if( video.GrabNext(img,true) ) {
+            texVideo.Upload( img, glformat, gltype );
+        }
+
+        // Activate video viewport and render texture
+        vVideo.Activate();
+        texVideo.RenderToViewportFlipY();
+
+        // Swap back buffer with front and process window events
+        pangolin::FinishFrame();
+    }
+
+    delete[] img;
+}
+
+
+int main( int argc, char* argv[] )
+{
+    std::string uris[] = {
+        "convert:[fmt=RGB24]//v4l:///dev/video0",
+        "convert:[fmt=RGB24]//v4l:///dev/video1",
+        "dc1394:[fps=30,dma=10,size=640x480,iso=400]//0",
+        "openni:[img1=rgb]//",
+        "test:[size=160x120,n=1,fmt=RGB24]//"
+        ""
+    };
+
+    if( argc > 1 ) {
+        const std::string uri = std::string(argv[1]);
+        VideoSample(uri);
+    }else{
+        std::cout << "Usage  : SimpleRecord [video-uri]" << std::endl << std::endl;
+        std::cout << "Where video-uri describes a stream or file resource, e.g." << std::endl;
+        std::cout << "\tfile:[realtime=1]///home/user/video/movie.pvn" << std::endl;
+        std::cout << "\tfile:///home/user/video/movie.avi" << std::endl;
+        std::cout << "\tfiles:///home/user/seqiemce/foo%03d.jpeg" << std::endl;
+        std::cout << "\tdc1394:[fmt=RGB24,size=640x480,fps=30,iso=400,dma=10]//0" << std::endl;
+        std::cout << "\tdc1394:[fmt=FORMAT7_1,size=640x480,pos=2+2,iso=400,dma=10]//0" << std::endl;
+        std::cout << "\tv4l:///dev/video0" << std::endl;
+        std::cout << "\tconvert:[fmt=RGB24]//v4l:///dev/video0" << std::endl;
+        std::cout << "\tmjpeg://http://127.0.0.1/?action=stream" << std::endl;
+        std::cout << "\topenni:[img1=rgb]//" << std::endl;
+        std::cout << std::endl;
+
+        // Try to open some video device
+        for(int i=0; !uris[i].empty(); ++i )
+        {
+            try{
+                std::cout << "Trying: " << uris[i] << std::endl;
+                VideoSample(uris[i]);
+                return 0;
+            }catch(const std::exception&) { }
+        }
+    }
+
+    return 0;
+}

third-party/DPVO/Pangolin/examples/VBODisplay/CMakeLists.txt

@@ -0,0 +1,19 @@
+# Find Pangolin (https://github.com/stevenlovegrove/Pangolin)
+find_package(Pangolin 0.8 REQUIRED)
+include_directories(${Pangolin_INCLUDE_DIRS})
+link_directories(${Pangolin_LIBRARY_DIRS})
+link_libraries(${Pangolin_LIBRARIES})
+
+find_package(CUDA QUIET)
+
+# This example could be made to work with C++11, but the kernel code must be
+# compiled without it.
+if(CUDA_FOUND)
+  cuda_include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+
+  cuda_add_executable(
+    VBODisplay
+    main.cpp kernal.cu
+  )
+
+endif()

third-party/DPVO/Pangolin/examples/VBODisplay/kernal.cu

@@ -0,0 +1,30 @@
+// Colour Sine wave Kernal
+// Based on kernal_colour in kernelVBO.cpp by Rob Farber
+__global__ void kernel(float4* dVertexArray, uchar4 *dColorArray,
+           unsigned int width, unsigned int height, float time)
+{
+    unsigned int x = blockIdx.x*blockDim.x + threadIdx.x;
+    unsigned int y = blockIdx.y*blockDim.y + threadIdx.y;
+
+    // Each thread is unique point (u,v) in interval [-1,1],[-1,1]
+    const float u = 2.0f* (x/(float)width)  - 1.0f;
+    const float v = 2.0f* (y/(float)height) - 1.0f;
+    const float w = 0.5f * sinf(4.0f*u + time) * cosf(4.0f*v + time);
+
+    // Update vertex array for point
+    dVertexArray[y*width+x] = make_float4(u, w, v, 1.0f);
+
+    // Update colour array for point
+    dColorArray[y*width+x].w = 0.0f;
+    dColorArray[y*width+x].x = 255.0f *0.5f*(1.f+sinf(w+x));
+    dColorArray[y*width+x].y = 255.0f *0.5f*(1.f+sinf(x)*cosf(y));
+    dColorArray[y*width+x].z = 255.0f *0.5f*(1.f+sinf(w+time/10.0f));
+}
+
+extern "C" void launch_kernel(float4* dVertexArray, uchar4* dColourArray,
+            unsigned int width, unsigned int height, float time)
+{
+  dim3 block(8, 8, 1);
+  dim3 grid(width / block.x, height / block.y, 1);
+  kernel<<< grid, block>>>(dVertexArray, dColourArray, width, height, time);
+}

third-party/DPVO/Pangolin/examples/VBODisplay/main.cpp

@@ -0,0 +1,84 @@
+#include <iostream>
+
+#include <GL/glew.h>
+
+#include <pangolin/pangolin.h>
+#include <pangolin/gl/glcuda.h>
+#include <pangolin/gl/glvbo.h>
+
+#include <cuda_runtime.h>
+#include <cuda_gl_interop.h>
+#include <vector_types.h>
+
+using namespace pangolin;
+using namespace std;
+
+// Mesh size
+const int mesh_width=256;
+const int mesh_height=256;
+
+extern "C" void launch_kernel(float4* dVertexArray, uchar4* dColourArray, unsigned int width, unsigned int height, float time);
+
+int main( int /*argc*/, char* argv[] )
+{
+//  cudaGLSetGLDevice(0);
+
+  pangolin::CreateWindowAndBind("Main",640,480);
+  glewInit();
+  
+  // 3D Mouse handler requires depth testing to be enabled  
+  glEnable(GL_DEPTH_TEST);  
+
+  // Create vertex and colour buffer objects and register them with CUDA
+  GlBufferCudaPtr vertex_array(
+      GlArrayBuffer, mesh_width*mesh_height, GL_FLOAT, 4,
+      cudaGraphicsMapFlagsWriteDiscard, GL_STREAM_DRAW
+  );
+  GlBufferCudaPtr colour_array(
+      GlArrayBuffer, mesh_width*mesh_height, GL_UNSIGNED_BYTE, 4,
+      cudaGraphicsMapFlagsWriteDiscard, GL_STREAM_DRAW
+  );
+
+  // Define Camera Render Object (for view / scene browsing)
+  pangolin::OpenGlRenderState s_cam(
+    ProjectionMatrix(640,480,420,420,320,240,0.1,1000),
+    ModelViewLookAt(-0,2,-2, 0,0,0, AxisY)
+  );
+  const int UI_WIDTH = 180;
+
+  // Add named OpenGL viewport to window and provide 3D Handler
+  View& d_cam = pangolin::Display("cam")
+    .SetBounds(0.0, 1.0, Attach::Pix(UI_WIDTH), 1.0, -640.0f/480.0f)
+    .SetHandler(new Handler3D(s_cam));
+
+  // Add named Panel and bind to variables beginning 'ui'
+  // A Panel is just a View with a default layout and input handling
+  View& d_panel = pangolin::CreatePanel("ui")
+      .SetBounds(0.0, 1.0, 0.0, Attach::Pix(UI_WIDTH));
+
+  // Default hooks for exiting (Esc) and fullscreen (tab).
+  for(int frame=0; !pangolin::ShouldQuit(); ++frame)
+  {
+    static double time = 0;
+    static Var<double> delta("ui.time delta", 0.001, 0, 0.005);
+
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    d_cam.Activate(s_cam);
+    glColor3f(1.0,1.0,1.0);
+
+    {
+      CudaScopedMappedPtr var(vertex_array);
+      CudaScopedMappedPtr car(colour_array);
+      launch_kernel((float4*)*var,(uchar4*)*car,mesh_width,mesh_height,time);
+      time += delta;
+    }
+
+    pangolin::RenderVboCbo(vertex_array, colour_array);
+
+    // Swap frames and Process Events
+    pangolin::FinishFrame();
+  }
+
+  return 0;
+}

third-party/DPVO/Pangolin/package.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0"?>
+<package format="2">
+  <name>pangolin</name>
+  <version>0.8.0</version>
+  <description>Pangolin is a set of lightweight and portable utility libraries for prototyping 3D, numeric or video based programs and algorithms.</description>
+  <maintainer email="[email protected]">Steven Lovegrove</maintainer>
+  <author     email="[email protected]">Steven Lovegrove</author>
+  <license>MIT</license>
+
+  <buildtool_depend>cmake</buildtool_depend>
+
+  <depend>libglew-dev</depend>
+  <depend>python3-dev</depend>
+  <build_depend>eigen</build_depend>
+
+  <export>
+    <build_type>cmake</build_type>
+  </export>
+</package>

third-party/DPVO/Pangolin/scripts/install_prerequisites.sh

@@ -0,0 +1,182 @@
+#!/bin/bash
+
+# exit when any command fails
+set -e
+
+MANAGERS=(dnf apt port vcpkg brew)
+MANAGER=""
+LIST=0
+VERBOSE=0
+DRYRUN=0
+UPDATE=0
+REQUIRED_RECOMMENDED_ALL=1
+SUDO=""
+
+PKGS_UPDATE=""
+PKGS_REQUIRED=()
+PKGS_RECOMMENDED=()
+PKGS_ALL=()
+PKGS_OPTIONS=()
+
+# Parse Command line
+PARAMS=""
+while (( "$#" )); do
+  case "$1" in
+    -v|--verbose)
+      VERBOSE=1
+      shift
+      ;;
+    -d|--dry-run)
+      DRYRUN=1
+      shift
+      ;;
+    -l|--list)
+      LIST=1
+      shift
+      ;;
+    -u|--update-package-list)
+      UPDATE=1
+      shift
+      ;;
+    -m|--package-manager)
+      if [ -n "$2" ] && [ ${2:0:1} != "-" ]; then
+        MANAGERS=($2)
+        shift 2
+      else
+        echo "Error: Argument for $1 is missing" >&2
+        exit 1
+      fi
+      ;;
+    -h|--help)
+      echo "$0 [-vh] [-m package-manager-list] [required|recommended|all]"
+      echo "  -m, --package-manager:     preferred package manager order (default: \"${MANAGERS[*]}\")"
+      echo "  -v, --verbose:             verbose output"
+      echo "  -d, --dry-run:             print actions, but do not execute"
+      echo "  -l, --list:                just list the packages to install"
+      echo "  -u, --update-package-list: update package manager package list"
+      echo "  -h, --help:                this help message"
+      echo " (required|recommended|all) the set of dependencies to select."
+      exit 0
+      ;;
+    -*|--*=) # unsupported flags
+      echo "Error: Unsupported flag $1" >&2
+      exit 1
+      ;;
+    *) # preserve positional arguments
+      PARAMS="$1"
+      shift
+      ;;
+  esac
+done
+
+# Make lower case
+PARAMS=$(echo "$PARAMS" | tr '[:upper:]' '[:lower:]' | tr -s "[:blank:]")
+
+# Work out which set of dependencies we're installing
+case "$PARAMS" in
+  required)
+    REQUIRED_RECOMMENDED_ALL=0
+    if ((VERBOSE > 0)); then echo "Selecting required dependencies only."; fi
+    ;;
+  ""|recommended)
+    REQUIRED_RECOMMENDED_ALL=1
+    if ((VERBOSE > 0)); then echo "Selecting required+recommended dependencies."; fi
+    ;;
+  all)
+    REQUIRED_RECOMMENDED_ALL=2
+    if ((VERBOSE > 0)); then echo "Selecting all available dependencies."; fi
+    ;;
+  *)
+    echo "Unrecognized positional argument \"$PARAMS\". Expecting one of (required,recommended [default],all)"
+    exit 1
+    ;;
+esac
+
+
+# Find an available package manager from the preferred list
+for m in ${MANAGERS[@]}
+do
+    if [ -x "$(command -v $m)" ]; then
+        MANAGER="$m"
+        break
+    fi
+done
+
+# If no package manager is found, exit
+if [ -z "$MANAGER" ]
+then
+      echo "Error: No preferred package managers from list [${MANAGERS[*]}] found. Use -m to select manually." >&2
+      exit 1
+fi
+if ((VERBOSE > 0)); then echo "Using \"$MANAGER\" package manager (select another using -m)"; fi
+
+# Setup prereq commands and packages.
+if [[ "$MANAGER" == "apt" ]]; then
+    SUDO="sudo"
+    PKGS_UPDATE="apt update"
+    PKGS_OPTIONS+=(install --no-install-suggests --no-install-recommends)
+    if ((DRYRUN > 0));  then PKGS_OPTIONS+=(--dry-run); fi
+    PKGS_REQUIRED+=(libgl1-mesa-dev libwayland-dev libxkbcommon-dev wayland-protocols libegl1-mesa-dev)
+    PKGS_REQUIRED+=(libc++-dev libglew-dev libeigen3-dev cmake g++ ninja-build)
+    PKGS_RECOMMENDED+=(libjpeg-dev libpng-dev)
+    PKGS_RECOMMENDED+=(libavcodec-dev libavutil-dev libavformat-dev libswscale-dev libavdevice-dev)
+    PKGS_ALL+=(libdc1394-22-dev libraw1394-dev libopenni-dev python3.9-dev python3-distutils)
+elif [[ "$MANAGER" == "dnf" ]]; then
+    SUDO="sudo"
+    PKGS_UPDATE="dnf check-update"
+    PKGS_OPTIONS+=(install)
+    PKGS_REQUIRED+=(wayland-devel libxkbcommon-devel g++ ninja-build)
+    PKGS_REQUIRED+=(glew-devel eigen3 cmake)
+    PKGS_RECOMMENDED+=(libjpeg-devel libpng-devel OpenEXR-devel)
+    PKGS_ALL+=(libdc1394-22-devel libraw1394-devel librealsense-devel openni-devel)
+    if ((DRYRUN > 0));  then
+        MANAGER="echo $MANAGER"
+    fi
+elif [[ "$MANAGER" == "port" ]]; then
+    SUDO="sudo"
+    PKGS_UPDATE="port sync -q"
+    PKGS_OPTIONS+=(-N install -q)
+    if ((DRYRUN > 0));  then PKGS_OPTIONS+=(-y); fi
+    PKGS_REQUIRED+=(glew eigen3-devel cmake +gui ninja)
+    PKGS_RECOMMENDED+=(jpeg libpng openexr tiff ffmpeg-devel lz4 zstd py37-pybind11 catch2)
+    PKGS_ALL+=(libdc1394 openni)
+elif [[ "$MANAGER" == "brew" ]]; then
+    PKGS_OPTIONS+=(install)
+    if ((VERBOSE > 0)); then PKGS_OPTIONS+=(--verbose); fi
+    PKGS_REQUIRED+=(glew eigen cmake ninja)
+    PKGS_RECOMMENDED+=(libjpeg libpng openexr libtiff ffmpeg lz4 zstd catch2)
+    # Brew doesn't have a dryrun option
+    if ((DRYRUN > 0));  then
+        MANAGER="echo $MANAGER"
+    fi
+elif [[ "$MANAGER" == "vcpkg" ]]; then
+    # TODO: this should be a config option somehow...
+    PKGS_OPTIONS+=(install --triplet=x64-windows )
+    if ((DRYRUN > 0));  then PKGS_OPTIONS+=(--dry-run); fi
+    PKGS_REQUIRED+=(glew eigen3)
+    PKGS_RECOMMENDED+=(libjpeg-turbo libpng openexr tiff ffmpeg lz4 zstd python3 Catch2)
+    PKGS_ALL+=(openni2 realsense2)
+else
+    echo "Error: Don't know how to use \"$MANAGER\", please fix the script." >&2
+    exit 1
+fi
+
+if ((REQUIRED_RECOMMENDED_ALL < 2)); then PKGS_ALL=(); fi
+if ((REQUIRED_RECOMMENDED_ALL < 1)); then PKGS_RECOMMENDED=(); fi
+
+PACKAGES=( "${PKGS_REQUIRED[*]}" "${PKGS_RECOMMENDED[*]}" "${PKGS_ALL[*]}" )
+
+if ((LIST > 0)); then
+    echo "${PACKAGES[*]}"
+    exit 0
+fi
+
+if ((UPDATE > 0)); then
+    if ((VERBOSE > 0)); then echo "Requesting \"$MANAGER\" package update."; fi
+    $SUDO $PKGS_UPDATE
+fi
+
+if ((VERBOSE > 0)); then echo "Requesting install of: ${PACKAGES[*]}"; fi
+
+# Install
+$SUDO $MANAGER ${PKGS_OPTIONS[*]} ${PACKAGES[*]}

third-party/DPVO/Pangolin/scripts/utils/ansi2html.sh

@@ -0,0 +1,527 @@
+#!/bin/sh
+
+# Convert ANSI (terminal) colours and attributes to HTML
+
+# Licence: LGPLv2
+# Author:
+#    http://www.pixelbeat.org/docs/terminal_colours/
+# Examples:
+#    ls -l --color=always | ansi2html.sh > ls.html
+#    git show --color | ansi2html.sh > last_change.html
+#    Generally one can use the `script` util to capture full terminal output.
+# Changes:
+#    V0.1, 24 Apr 2008, Initial release
+#    V0.2, 01 Jan 2009, Phil Harnish <[email protected]>
+#                         Support `git diff --color` output by
+#                         matching ANSI codes that specify only
+#                         bold or background colour.
+#                       [email protected]
+#                         Support `ls --color` output by stripping
+#                         redundant leading 0s from ANSI codes.
+#                         Support `grep --color=always` by stripping
+#                         unhandled ANSI codes (specifically ^[[K).
+#    V0.3, 20 Mar 2009, http://eexpress.blog.ubuntu.org.cn/
+#                         Remove cat -v usage which mangled non ascii input.
+#                         Cleanup regular expressions used.
+#                         Support other attributes like reverse, ...
+#                       [email protected]
+#                         Correctly nest <span> tags (even across lines).
+#                         Add a command line option to use a dark background.
+#                         Strip more terminal control codes.
+#    V0.4, 17 Sep 2009, [email protected]
+#                         Handle codes with combined attributes and color.
+#                         Handle isolated <bold> attributes with css.
+#                         Strip more terminal control codes.
+#    V0.26, 16 Nov 2019
+#      http://github.com/pixelb/scripts/commits/master/scripts/ansi2html.sh
+
+gawk --version >/dev/null || exit 1
+
+if [ "$1" = "--version" ]; then
+    printf '0.26\n' && exit
+fi
+
+usage()
+{
+printf '%s\n' \
+'This utility converts ANSI codes in data passed to stdin
+It has 4 optional parameters:
+--bg=dark --palette=linux|solarized|tango|xterm --css-only|--body-only
+E.g.: ls -l --color=always | ansi2html.sh --bg=dark > ls.html' >&2
+    exit
+}
+
+if [ "$1" = "--help" ]; then
+    usage
+fi
+
+processArg()
+{
+    [ "$1" = "--bg=dark" ] && { dark_bg=yes; return; }
+    [ "$1" = "--css-only" ] && { css_only=yes; return; }
+    [ "$1" = "--body-only" ] && { body_only=yes; return; }
+    if [ "$1" = "--palette=solarized" ]; then
+       # See http://ethanschoonover.com/solarized
+       P0=073642;  P1=D30102;  P2=859900;  P3=B58900;
+       P4=268BD2;  P5=D33682;  P6=2AA198;  P7=EEE8D5;
+       P8=002B36;  P9=CB4B16; P10=586E75; P11=657B83;
+      P12=839496; P13=6C71C4; P14=93A1A1; P15=FDF6E3;
+      return;
+    elif [ "$1" = "--palette=solarized-xterm" ]; then
+       # Above mapped onto the xterm 256 color palette
+       P0=262626;  P1=AF0000;  P2=5F8700;  P3=AF8700;
+       P4=0087FF;  P5=AF005F;  P6=00AFAF;  P7=E4E4E4;
+       P8=1C1C1C;  P9=D75F00; P10=585858; P11=626262;
+      P12=808080; P13=5F5FAF; P14=8A8A8A; P15=FFFFD7;
+      return;
+    elif [ "$1" = "--palette=tango" ]; then
+       # Gnome default
+       P0=000000;  P1=CC0000;  P2=4E9A06;  P3=C4A000;
+       P4=3465A4;  P5=75507B;  P6=06989A;  P7=D3D7CF;
+       P8=555753;  P9=EF2929; P10=8AE234; P11=FCE94F;
+      P12=729FCF; P13=AD7FA8; P14=34E2E2; P15=EEEEEC;
+      return;
+    elif [ "$1" = "--palette=xterm" ]; then
+       P0=000000;  P1=CD0000;  P2=00CD00;  P3=CDCD00;
+       P4=0000EE;  P5=CD00CD;  P6=00CDCD;  P7=E5E5E5;
+       P8=7F7F7F;  P9=FF0000; P10=00FF00; P11=FFFF00;
+      P12=5C5CFF; P13=FF00FF; P14=00FFFF; P15=FFFFFF;
+      return;
+    else # linux console
+       P0=000000;  P1=AA0000;  P2=00AA00;  P3=AA5500;
+       P4=0000AA;  P5=AA00AA;  P6=00AAAA;  P7=AAAAAA;
+       P8=555555;  P9=FF5555; P10=55FF55; P11=FFFF55;
+      P12=5555FF; P13=FF55FF; P14=55FFFF; P15=FFFFFF;
+      [ "$1" = "--palette=linux" ] && return;
+    fi
+}
+
+processArg #defaults
+for var in "$@"; do processArg $var; done
+[ "$css_only" ] && [ "$body_only" ] && usage
+
+# Mac OSX's GNU sed is installed as gsed
+# use e.g. homebrew 'gnu-sed' to get it
+if ! sed --version >/dev/null 2>&1; then
+  if gsed --version >/dev/null 2>&1; then
+    alias sed=gsed
+  else
+    echo "Error, can't find an acceptable GNU sed." >&2
+    exit 1
+  fi
+fi
+
+[ "$css_only" ] || [ "$body_only" ] || printf '%s' "<html>
+<head>
+<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\"/>
+<style type=\"text/css\">
+pre { white-space: pre-wrap; }
+"
+[ "$body_only" ] || printf ".ef0,.f0 { color: #$P0; } .eb0,.b0 { background-color: #$P0; }
+.ef1,.f1 { color: #$P1; } .eb1,.b1 { background-color: #$P1; }
+.ef2,.f2 { color: #$P2; } .eb2,.b2 { background-color: #$P2; }
+.ef3,.f3 { color: #$P3; } .eb3,.b3 { background-color: #$P3; }
+.ef4,.f4 { color: #$P4; } .eb4,.b4 { background-color: #$P4; }
+.ef5,.f5 { color: #$P5; } .eb5,.b5 { background-color: #$P5; }
+.ef6,.f6 { color: #$P6; } .eb6,.b6 { background-color: #$P6; }
+.ef7,.f7 { color: #$P7; } .eb7,.b7 { background-color: #$P7; }
+.ef8, .f0 > .bold,.bold > .f0 { color: #$P8; font-weight: normal; }
+.ef9, .f1 > .bold,.bold > .f1 { color: #$P9; font-weight: normal; }
+.ef10,.f2 > .bold,.bold > .f2 { color: #$P10; font-weight: normal; }
+.ef11,.f3 > .bold,.bold > .f3 { color: #$P11; font-weight: normal; }
+.ef12,.f4 > .bold,.bold > .f4 { color: #$P12; font-weight: normal; }
+.ef13,.f5 > .bold,.bold > .f5 { color: #$P13; font-weight: normal; }
+.ef14,.f6 > .bold,.bold > .f6 { color: #$P14; font-weight: normal; }
+.ef15,.f7 > .bold,.bold > .f7 { color: #$P15; font-weight: normal; }
+.eb8  { background-color: #$P8; }
+.eb9  { background-color: #$P9; }
+.eb10 { background-color: #$P10; }
+.eb11 { background-color: #$P11; }
+.eb12 { background-color: #$P12; }
+.eb13 { background-color: #$P13; }
+.eb14 { background-color: #$P14; }
+.eb15 { background-color: #$P15; }
+"
+# The default xterm 256 colour palette
+for red in 0 1 2 3 4 5 ; do
+  for green in 0 1 2 3 4 5 ; do
+    for blue in 0 1 2 3 4 5 ; do
+      c=$((16 + ($red * 36) + ($green * 6) + $blue))
+      r=$((($red * 40 + 55) * ($red > 0)))
+      g=$((($green * 40 + 55) * ($green > 0)))
+      b=$((($blue * 40 + 55) * ($blue > 0)))
+      [ "$body_only" ] || printf ".ef%d { color: #%2.2x%2.2x%2.2x; } " $c $r $g $b
+      [ "$body_only" ] || printf ".eb%d { background-color: #%2.2x%2.2x%2.2x; }\n" $c $r $g $b
+    done
+  done
+done
+for gray in $(seq 0 23); do
+  c=$(($gray+232))
+  l=$(($gray*10 + 8))
+  [ "$body_only" ] || printf ".ef%d { color: #%2.2x%2.2x%2.2x; } " $c $l $l $l
+  [ "$body_only" ] || printf ".eb%d { background-color: #%2.2x%2.2x%2.2x; }\n" $c $l $l $l
+done
+
+[ "$body_only" ] || printf '%s' '
+.f9 { color: '`[ "$dark_bg" ] && printf "#$P7;" || printf "#$P0;"`' }
+.b9 { background-color: #'`[ "$dark_bg" ] && printf $P0 || printf $P15`'; }
+.f9 > .bold,.bold > .f9, body.f9 > pre > .bold {
+  /* Bold is heavy black on white, or bright white
+     depending on the default background */
+  color: '`[ "$dark_bg" ] && printf "#$P15;" || printf "#$P0;"`'
+  font-weight: '`[ "$dark_bg" ] && printf 'normal;' || printf 'bold;'`'
+}
+.reverse {
+  /* CSS does not support swapping fg and bg colours unfortunately,
+     so just hardcode something that will look OK on all backgrounds. */
+  '"color: #$P0; background-color: #$P7;"'
+}
+.underline { text-decoration: underline; }
+.line-through { text-decoration: line-through; }
+.blink { text-decoration: blink; }
+
+/* Avoid pixels between adjacent span elements.
+   Note this only works for lines less than 80 chars
+   where we close span elements on the same line.
+span { display: inline-block; }
+*/
+'
+[ "$body_only" ] || [ "$css_only" ] && printf '%s\n' \
+'To use the css generated from --css-only, do: '\
+'<head><link rel="stylesheet" type="text/css" href="style.css"></head>' >&2
+[ "$css_only" ] && exit
+[ "$body_only" ] || printf '%s' '</style>
+</head>
+
+<body class="f9 b9">
+<pre>
+'
+[ "$body_only" ] && printf '%s\n' 'Be sure to use <body class="f9 b9"> and <pre>' >&2
+
+p='\x1b\['        #shortcut to match escape codes
+
+# Handle various xterm control sequences.
+# See /usr/share/doc/xterm-*/ctlseqs.txt
+sed "
+# escape ampersand and quote
+s#&#\&amp;#g; s#\"#\&quot;#g;
+s#\x1b[^\x1b]*\x1b\\\##g  # strip anything between \e and ST
+s#\x1b][0-9]*;[^\a]*\a##g # strip any OSC (xterm title etc.)
+
+s#\r\$## # strip trailing \r
+
+# strip other non SGR escape sequences
+s#[\x07]##g
+s#\x1b[]>=\][0-9;]*##g
+s#\x1bP+.\{5\}##g
+# Mark cursor positioning codes \"Jr;c;
+s#${p}\([0-9]\{1,2\}\)G#\"J;\1;#g
+s#${p}\([0-9]\{1,2\}\);\([0-9]\{1,2\}\)H#\"J\1;\2;#g
+
+# Mark clear as \"Cn where n=1 is screen and n=0 is to end-of-line
+s#${p}H#\"C1;#g
+s#${p}K#\"C0;#g
+# Mark Cursor move columns as \"Mn where n is +ve for right, -ve for left
+s#${p}C#\"M1;#g
+s#${p}\([0-9]\{1,\}\)C#\"M\1;#g
+s#${p}\([0-9]\{1,\}\)D#\"M-\1;#g
+s#${p}\([0-9]\{1,\}\)P#\"X\1;#g
+
+s#${p}[0-9;?]*[^0-9;?m]##g
+
+" |
+
+# Normalize the input before transformation
+sed "
+# escape HTML (ampersand and quote done above)
+s#>#\&gt;#g; s#<#\&lt;#g;
+
+# handle truecolor
+s#${p}38;2;\([0-9]\{1,3\}\);\([0-9]\{1,3\}\);\([0-9]\{1,3\}\)m#\
+<span style=\"color:rgb(\1\,\2\,\3\)\">#g
+s#${p}48;2;\([0-9]\{1,3\}\);\([0-9]\{1,3\}\);\([0-9]\{1,3\}\)m#\
+<span style=\"background-color:rgb(\1\,\2\,\3\)\">#g
+
+# normalize SGR codes a little
+
+# split 256 colors out and mark so that they're not
+# recognised by the following 'split combined' line
+:e
+s#${p}\([0-9;]\{1,\}\);\([34]8;5;[0-9]\{1,3\}\)m#${p}\1m${p}¬\2m#g; t e
+s#${p}\([34]8;5;[0-9]\{1,3\}\)m#${p}¬\1m#g;
+
+:c
+s#${p}\([0-9]\{1,\}\);\([0-9;]\{1,\}\)m#${p}\1m${p}\2m#g; t c   # split combined
+s#${p}0\([0-7]\)#${p}\1#g                                 #strip leading 0
+s#${p}1m\(\(${p}[4579]m\)*\)#\1${p}1m#g                   #bold last (with clr)
+s#${p}m#${p}0m#g                                          #add leading 0 to norm
+
+# undo any 256 color marking
+s#${p}¬\([34]8;5;[0-9]\{1,3\}\)m#${p}\1m#g;
+
+# map 16 color codes to color + bold
+s#${p}9\([0-7]\)m#${p}3\1m${p}1m#g;
+s#${p}10\([0-7]\)m#${p}4\1m${p}1m#g;
+
+# change 'reset' code to \"R
+s#${p}0m#\"R;#g
+" |
+
+# Convert SGR sequences to HTML
+sed "
+# common combinations to minimise html (optional)
+:f
+s#${p}3[0-7]m${p}3\([0-7]\)m#${p}3\1m#g; t f
+:b
+s#${p}4[0-7]m${p}4\([0-7]\)m#${p}4\1m#g; t b
+s#${p}3\([0-7]\)m${p}4\([0-7]\)m#<span class=\"f\1 b\2\">#g
+s#${p}4\([0-7]\)m${p}3\([0-7]\)m#<span class=\"f\2 b\1\">#g
+
+s#${p}1m#<span class=\"bold\">#g
+s#${p}4m#<span class=\"underline\">#g
+s#${p}5m#<span class=\"blink\">#g
+s#${p}7m#<span class=\"reverse\">#g
+s#${p}9m#<span class=\"line-through\">#g
+s#${p}3\([0-9]\)m#<span class=\"f\1\">#g
+s#${p}4\([0-9]\)m#<span class=\"b\1\">#g
+
+s#${p}38;5;\([0-9]\{1,3\}\)m#<span class=\"ef\1\">#g
+s#${p}48;5;\([0-9]\{1,3\}\)m#<span class=\"eb\1\">#g
+
+s#${p}[0-9;]*m##g # strip unhandled codes
+" |
+
+# Convert alternative character set and handle cursor movement codes
+# Note we convert here, as if we do at start we have to worry about avoiding
+# conversion of SGR codes etc., whereas doing here we only have to
+# avoid conversions of stuff between &...; or <...>
+#
+# Note we could use sed to do this based around:
+#   sed 'y/abcdefghijklmnopqrstuvwxyz{}`~/▒␉␌␍␊°±␤␋┘┐┌└┼⎺⎻─⎼⎽├┤┴┬│≤≥π£◆·/'
+# However that would be very awkward as we need to only conv some input.
+# The basic scheme that we do in the awk script below is:
+#  1. enable transliterate once "T1; is seen
+#  2. disable once "T0; is seen (may be on diff line)
+#  3. never transliterate between &; or <> chars
+#  4. track x,y movements and active display mode at each position
+#  5. buffer line/screen and dump when required
+sed "
+# change 'smacs' and 'rmacs' to \"T1 and \"T0 to simplify matching.
+s#\x1b(0#\"T1;#g;
+s#\x0E#\"T1;#g;
+
+s#\x1b(B#\"T0;#g
+s#\x0F#\"T0;#g
+" |
+(
+gawk '
+function dump_line(l,del,c,blanks,ret) {
+  for(c=1;c<maxX;c++) {
+    if ((c SUBSEP l) in attr || alength(cur)) {
+      ret = ret blanks fixas(cur,attr[c,l])
+      if(del) delete attr[c,l]
+      blanks=""
+    }
+    if ((c SUBSEP l) in dump) {
+      ret=ret blanks dump[c,l]
+      if(del) delete dump[c,l]
+      blanks=""
+    } else blanks=blanks " "
+  }
+  if(alength(cur)) ret=ret blanks
+  return ret
+}
+
+function dump_screen(l,ret) {
+  for(l=1;l<=maxY;l++)
+    ret=ret dump_line(l,0) "\n"
+  return ret fixas(cur, "")
+}
+
+function atos(a,i,ret) {
+  for(i=1;i<=alength(a);i++) if(i in a) ret=ret a[i]
+  return ret
+}
+
+function alength(a, i, k) {
+    k = 0
+    for(i in a) k++
+    return k
+}
+
+function fixas(a,s,spc,i,attr,rm,ret) {
+  spc=alength(a)
+  l=split(s,attr,">")
+  for(i=1;i<=spc;i++) {
+    rm=rm?rm:(a[i]!=attr[i]">")
+    if(rm) {
+      ret=ret "</span>"
+      delete a[i];
+    }
+  }
+  for(i=1;i<l;i++) {
+    attr[i]=attr[i]">"
+    if(a[i]!=attr[i]) {
+      a[i]=attr[i]
+      ret = ret attr[i]
+    }
+  }
+  return ret
+}
+
+function encode(string,start,end,i,ret,pos,sc,buf) {
+   if(!end) end=length(string);
+   if(!start) start=1;
+   state=3
+   for(i=1;i<=length(string);i++) {
+     c=substr(string,i,1)
+     if(state==2) {
+       sc=sc c
+       if(c==";") {
+          c=sc
+          state=last_mode
+       } else continue
+     } else {
+       if(c=="\r") { x=1; continue }
+       if(c=="<") {
+         # Change attributes - store current active
+         # attributes in span array
+         split(substr(string,i),cord,">");
+         i+=length(cord[1])
+         span[++spc]=cord[1] ">"
+         continue
+       }
+       else if(c=="&") {
+         # All goes to single position till we see a semicolon
+         sc=c
+         state=2
+         continue
+       }
+       else if(c=="\b") {
+          # backspace move insertion point back 1
+          if(spc) attr[x,y]=atos(span)
+          x=x>1?x-1:1
+          continue
+       }
+       else if(c=="\"") {
+          split(substr(string,i+2),cord,";")
+          cc=substr(string,i+1,1);
+          if(cc=="T") {
+              # Transliterate on/off
+              if(cord[1]==1&&state==3) last_mode=state=4
+              if(cord[1]==0&&state==4) last_mode=state=3
+          }
+          else if(cc=="C") {
+              # Clear
+              if(cord[1]+0) {
+                # Screen - if Recording dump screen
+                if(dumpStatus==dsActive) ret=ret dump_screen()
+                dumpStatus=dsActive
+                delete dump
+                delete attr
+                x=y=1
+              } else {
+                # To end of line
+                for(pos=x;pos<maxX;pos++) {
+                  dump[pos,y]=" "
+                  if (!spc) delete attr[pos,y]
+                  else attr[pos,y]=atos(span)
+                }
+              }
+          }
+          else if(cc=="J") {
+              # Jump to x,y
+              i+=length(cord[2])+1
+              # If line is higher - dump previous screen
+              if(dumpStatus==dsActive&&cord[1]<y) {
+                ret=ret dump_screen();
+                dumpStatus=dsNew;
+              }
+              x=cord[2]
+              if(length(cord[1]) && y!=cord[1]){
+                y=cord[1]
+                if(y>maxY) maxY=y
+                # Change y - start recording
+                dumpStatus=dumpStatus?dumpStatus:dsReset
+              }
+          }
+          else if(cc=="M") {
+              # Move left/right on current line
+              x+=cord[1]
+          }
+          else if(cc=="X") {
+              # delete on right
+              for(pos=x;pos<=maxX;pos++) {
+                nx=pos+cord[1]
+                if(nx<maxX) {
+                  if((nx SUBSEP y) in attr) attr[pos,y] = attr[nx,y]
+                  else delete attr[pos,y]
+                  if((nx SUBSEP y) in dump) dump[pos,y] = dump[nx,y]
+                  else delete dump[pos,y]
+                } else if(spc) {
+                  attr[pos,y]=atos(span)
+                  dump[pos,y]=" "
+                }
+              }
+          }
+          else if(cc=="R") {
+              # Reset attributes
+              while(spc) delete span[spc--]
+          }
+          i+=length(cord[1])+2
+          continue
+       }
+       else if(state==4&&i>=start&&i<=end&&c in Trans) c=Trans[c]
+     }
+     if(dumpStatus==dsReset) {
+       delete dump
+       delete attr
+       ret=ret"\n"
+       dumpStatus=dsActive
+     }
+     if(dumpStatus==dsNew) {
+       # After moving/clearing we are now ready to write
+       # somthing to the screen so start recording now
+       ret=ret"\n"
+       dumpStatus=dsActive
+     }
+     if(dumpStatus==dsActive||dumpStatus==dsOff) {
+       dump[x,y] = c
+       if(!spc) delete attr[x,y]
+       else attr[x,y] = atos(span)
+       if(++x>maxX) maxX=x;
+     }
+    }
+    # End of line if dumping increment y and set x back to first col
+    x=1
+    if(!dumpStatus) return ret dump_line(y,1);
+    else if(++y>maxY) maxY=y;
+    return ret
+}
+BEGIN{
+  OFS=FS
+  # dump screen status
+  dsOff=0    # Not dumping screen contents just write output direct
+  dsNew=1    # Just after move/clear waiting for activity to start recording
+  dsReset=2  # Screen cleared build new empty buffer and record
+  dsActive=3 # Currently recording
+  F="abcdefghijklmnopqrstuvwxyz{}`~"
+  T="▒␉␌␍␊°±␤␋┘┐┌└┼⎺⎻─⎼⎽├┤┴┬│≤≥π£◆·"
+  maxX=80
+  delete cur;
+  x=y=1
+  for(i=1;i<=length(F);i++)Trans[substr(F,i,1)]=substr(T,i,1);
+}
+
+{ $0=encode($0) }
+1
+END {
+  if(dumpStatus) {
+    print dump_screen();
+  }
+}'
+)
+
+[ "$body_only" ] || printf '</pre>
+</body>
+</html>\n'

third-party/DPVO/Pangolin/scripts/vcpkg/CONTRIBUTING.md

@@ -0,0 +1,33 @@
+# Contribution Guidelines
+
+Vcpkg is a community driven effort to build a productive and robust ecosystem of native libraries - your contributions are invaluable!
+
+## Issues
+
+The easiest way to contribute is by reporting issues with either `vcpkg.exe` or an existing package on [GitHub](https://github.com/Microsoft/vcpkg). When reporting an issue with `vcpkg.exe`, make sure to clearly state:
+- The machine setup: "I'm using Windows 10 Anniversary Update. My machine is using the fr-fr locale. I successfully ran 'install boost'." 
+- The steps to reproduce: "I run 'vcpkg list'"
+- The outcome you expected: "I expected to see 'boost:x86-windows'"
+- The actual outcome: "I get no output at all" or "I get a crash dialog"
+
+When reporting an issue with a package, make sure to clearly state:
+- The machine setup (as above)
+- What package and version you're building: "opencv 3.1.0"
+- Any relevant error logs from the build process.
+
+## Pull Requests
+
+We are happy to accept pull requests for fixes, features, new packages, and updates to existing packages. In order to avoid wasting your time, we highly encourage opening an issue to discuss whether the PR you're thinking about making will be acceptable. This is doubly true for features and new packages.
+
+### New package Guidelines
+
+We're glad you're interested in submitting a new package! Here are some guidelines to help you author an excellent portfile:
+- Avoid functional patches. Patches should be considered a last resort to implement compatibility when there's no other way. 
+- When patches can't be avoided, do not modify the default behavior. The ideal lifecycle of a patch is to get merged upstream and no longer be needed. Try to keep this goal in mind when deciding how to patch something.
+- Prefer to use the `vcpkg_xyz` functions over raw `execute_command` calls. This makes long term maintenance easier when new features (such as custom compiler flags or generators) are added.
+
+## Legal
+
+You will need to complete a Contributor License Agreement (CLA) before your pull request can be accepted. This agreement testifies that you are granting us permission to use the source code you are submitting, and that this work is being submitted under appropriate license that we can use it.
+
+You can complete the CLA by going through the steps at https://cla.microsoft.com. Once we have received the signed CLA, we'll review the request. You will only need to do this once.

third-party/DPVO/Pangolin/scripts/vcpkg/CONTRIBUTING_zh.md

@@ -0,0 +1,33 @@
+# 贡献准则
+
+Vcpkg 是一个尝试由社区驱动，旨在构建一个多产的、健壮的本地库生态系统 - 您的贡献价值不可估量！
+
+## 报告问题
+
+最简单的方法是通过 `vcpkg.exe` 或 [GitHub](https://github.com/Microsoft/vcpkg) 报告已有的包的问题。 当报告 `vcpkg.exe` 的问题时，确保清楚地说明:
+- 机器设置: “我用的是Windows 10周年更新。 我的机器正位于fr-fr区域。 我成功地运行了'install boost'。”
+- 复现步骤: “运行 'vcpkg list'”
+- 预期结果: “我预期看到 'boost:x86-windows'”
+- 实际结果: “没有输出” 或 “我得到一个崩溃对话框”
+
+当报告包的问题时，一定要清楚地说明:
+- 机器设置 (上述)
+- 您正在构建什么包以及它的版本，例如: “opencv 3.1.0”
+- 构建过程中的任何相关错误日志
+
+## 贡献 (PR)
+
+我们很乐意接受关于修复、特性、新包和更新现有包的拉取请求。 为了避免浪费您的时间，我们强烈建议您提交一个问题来讨论您想要制作的PR是否能被接受。 对于特性和新包来说也是如此。
+
+### 新包贡献准则
+
+我们很高兴您有兴趣来提交一个新的包! 这里有一些指导方针来帮助您编写一个优秀的端口文件:
+- 避免功能补丁。 当没有其他方法时，补丁应该被视为实现兼容性的最后手段。
+- 当无法避免补丁时，请不要修改默认行为。 一个补丁的理想生命周期是与上游合并，不再被需要。 在决定如何修补某些内容时，请记住这一目标。
+- 相比原始的 `execute_command` 调用，尽量改为通过 `vcpkg_xyz` 函数实现。这使得在添加新特性(如自定义编译器标志或生成器)时更容易进行长期维护。
+
+## 法律声明
+
+在您的拉取请求被接受之前，您需要完成一个贡献者许可协议 (CLA)。 本协议证明您允许我们使用您提交的源代码，并且本作品是在合适的许可下提交的，我们可以使用它。
+
+您可以通过 https://cla.microsoft.com 上的步骤来完成CLA。 一旦我们收到已签署的CLA，我们将审查请求。 您只需要这样做一次。

third-party/DPVO/Pangolin/scripts/vcpkg/bootstrap-vcpkg.bat

@@ -0,0 +1,2 @@
+@echo off
+powershell.exe -NoProfile -ExecutionPolicy Bypass "& {& '%~dp0scripts\bootstrap.ps1' %*}"

third-party/DPVO/Pangolin/scripts/vcpkg/bootstrap-vcpkg.sh

@@ -0,0 +1,4 @@
+#!/bin/sh -e
+
+vcpkgRootDir=$(X= cd -- "$(dirname -- "$0")" && pwd -P)
+. "$vcpkgRootDir/scripts/bootstrap.sh"

third-party/DPVO/Pangolin/scripts/vcpkg/docs/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-cayman

third-party/DPVO/Pangolin/scripts/vcpkg/docs/about/faq.md

@@ -0,0 +1,120 @@
+# Frequently Asked Questions
+
+## Can I contribute a new library?
+Yes! Start out by reading our [contribution guidelines](https://github.com/Microsoft/vcpkg/blob/master/CONTRIBUTING.md).
+If you want to contribute but don't have a particular library in mind then take a look at the list
+of [new port requests](https://github.com/Microsoft/vcpkg/issues?q=is%3Aissue+is%3Aopen+label%3Acategory%3Anew-port).
+
+## Can Vcpkg create pre-built binary packages? What is the binary format used by Vcpkg?
+Yes! See [the `export` command](../users/integration.md#export-command).
+
+## How do I update libraries?
+The `vcpkg update` command lists all packages which are out-of-sync with your current portfiles. To update a package, follow the instructions in the command.
+
+## How do I get more libraries?
+The list of libraries is enumerated from the [`ports\`](https://github.com/Microsoft/vcpkg/blob/master/ports) directory. By design, you can add and remove libraries from this directory as you see fit for yourself or your company -- see our examples on packaging [zipfiles](../examples/packaging-zipfiles.md) and [GitHub repos](../examples/packaging-github-repos.md).
+
+We recommend cloning directly from [GitHub](https://github.com/microsoft/vcpkg) and using `git pull` to update the list of portfiles. Once you've updated your portfiles, `vcpkg update` will indicate any installed libraries that are now out of date.
+
+## Can I build a private library with this tool?
+Yes. Follow [our packaging zlib Example](../examples/packaging-zipfiles.md) for creating a portfile using a fake URL. Then, either pre-seed the `downloads\` folder with a zip containing your private sources or replace the normal calls to `vcpkg_download_distfile` and `vcpkg_extract_source_archive` with functions that unpack your source code.
+
+## Can I use a prebuilt private library with this tool?
+Yes. The `portfile.cmake` for a library is fundamentally a script that places the headers and binaries into the correct arrangement in the `${CURRENT_PACKAGES_DIR}`, so to pull in prebuilt binaries you can write a portfile which directly downloads and arranges the files.
+
+To see an example of this, look at [`ports\opengl\portfile.cmake`](https://github.com/microsoft/vcpkg/blob/master/ports/opengl/portfile.cmake) which simply copies files out of the Windows SDK.
+
+## Which platforms I can target with Vcpkg?
+We currently target Windows Desktop (x86 and x64) as well as the Universal Windows Platform (x86, x64, and ARM). See `vcpkg help triplet` for the current list.
+
+## Does Vcpkg run on Linux/OSX?
+Yes! We continuously test on OSX and Ubuntu 16.04, however we know users have been successful with Arch, Fedora, and FreeBSD. If you have trouble with your favorite Linux distribution, let us know in an issue and we'd be happy to help!
+
+## How do I update vcpkg?
+Execute `git pull` to get the latest sources, then run `bootstrap-vcpkg.bat` (Windows) or `./bootstrap-vcpkg.sh` (Unix) to update vcpkg.
+
+## How do I use different versions of a library on one machine?
+Within a single instance of Vcpkg (e.g. one set of `installed\`, `packages\`, `ports\` and so forth), you can only have one version of a library installed (otherwise, the headers would conflict with each other!). For those with experience with system-wide package managers, packages in Vcpkg correspond to the `X-dev` or `X-devel` packages.
+
+To use different versions of a library for different projects, we recommend making separate instances of Vcpkg and using the [per-project integration mechanisms](../users/integration.md). The versions of each library are specified by the files in `ports\`, so they are easily manipulated using standard `git` commands. This makes it very easy to roll back the entire set of libraries to a consistent set of older versions which all work with each other. If you need to then pin a specific library forward, that is as easy as checking out the appropriate version of `ports\<package>\`.
+
+If your application is very sensitive to the versions of libraries, we recommend checking in the specific set of portfiles you need into your source control along with your project sources and using the `--vcpkg-root` option to redirect the working directory of `vcpkg.exe`.
+
+## How does Vcpkg protect my privacy?
+See the [Privacy document](privacy.md) for all information regarding privacy.
+
+## Can I use my own CMake toolchain file with Vcpkg's toolchain file?
+Yes. If you already have a CMake toolchain file, you will need to include our toolchain file at the end of yours. This should be as simple as an `include(<vcpkg_root>\scripts\buildsystems\vcpkg.cmake)` directive. Alternatively, you could copy the contents of our `scripts\buildsystems\vcpkg.cmake` into the end of your existing toolchain file.
+
+## Can I use my own/specific flags for rebuilding libs?
+Yes. In the current version, there is not yet a standardized global way to change them, however you can edit individual portfiles and tweak the exact build process however you'd like.
+
+By saving the changes to the portfile (and checking them in), you'll get the same results even if you're rebuilding from scratch in the future and forgot what exact settings you used.
+
+## Can I get Vcpkg integration for custom configurations?
+
+Yes. While Vcpkg will only produce the standard "Release" and "Debug" configurations when building a library, you can get integration support for your projects' custom configurations, in addition to your project's standard configurations.
+
+First of all, Vcpkg will automatically assume any custom configuration starting with "Release" (resp. "Debug") as a configuration that is compatible with the standard "Release" (resp. "Debug") configuration and will act accordingly.
+
+For other configurations, you only need to override the MSBuild `$(VcpkgConfiguration)` macro in your project file (.vcxproj) to declare the compatibility between your configuration, and the target standard configuration. Unfortunately, due to the sequential nature of MSBuild, you'll need to add those settings much higher in your vcxproj so that it is declared before the Vcpk integration is loaded. It is recommend that the `$(VcpkgConfiguration)` macro is added to the "Globals" PropertyGroup.
+
+For example, you can add support for your "MyRelease" configuration by adding in your project file:
+```
+<PropertyGroup Label="Globals">
+  ...
+  <VcpkgConfiguration Condition="'$(Configuration)' == 'MyRelease'">Release</VcpkgConfiguration>
+</PropertyGroup>
+```
+Of course, this will only produce viable binaries if your custom configuration is compatible with the target configuration (e.g. they should both link with the same runtime library).
+
+## I can't use user-wide integration. Can I use a per-project integration?
+
+Yes. A NuGet package suitable for per-project use can be generated via either the `vcpkg integrate project` command (lightweight linking) or the `vcpkg export --nuget` command (shrinkwrapped).
+
+A lower level mechanism to achieve the same as the `vcpkg integrate project` NuGet package is via the `<vcpkg_root>\scripts\buildsystems\msbuild\vcpkg.targets` file. All you need is to import it in your .vcxproj file, replacing `<vcpkg_root>` with the path where you installed vcpkg:
+
+```
+<Import Project="<vcpkg_root>\scripts\buildsystems\msbuild\vcpkg.targets" />
+```
+
+## How can I remove temporary files?
+
+You can save some disk space by completely removing the `packages\`, `buildtrees\`, and `downloads\` folders.
+
+## How is CMake used internally by Vcpkg?
+Vcpkg uses CMake internally as a build scripting language. This is because CMake is already an extremely common build system for cross-platform open source libraries and is becoming very popular for C++ projects in general. It is easy to acquire on Windows, does not require system-wide installation, and legible for unfamiliar users.
+
+## Will Vcpkg support downloading compiled binaries from a public or private server?
+We would like to eventually support downloading precompiled binaries, similar to other system package managers.
+
+In a corporate scenario, we currently recommend building the libraries once and distributing the entire vcpkg root directory to everyone else on the project through some raw file transport such as a network share or HTTP host. See the [`export`](../users/integration.md#export) command.
+
+## What Visual C++ toolsets are supported?
+We support Visual Studio 2015 Update 3 and above.
+
+## Why does Visual Studio not use my libraries with user-wide integration enabled?
+Enabling user-wide integration (`vcpkg integrate install`) changes the default for some project properties. In particular, "C/C++/General/Additional Include Directories" and "Linker/General/Additional Library Directories" are normally blank *without* user-wide integration. *With* integration, a blank value means that the augmented default supplied by vcpkg is overridden, and headers/libraries will not be found. To reinstate the default, set the properties to inherit from parent.
+
+## Why not NuGet?
+NuGet is a package manager for .NET libraries with a strong dependency on MSBuild. It does not meet the specific needs of Native C++ customers in at least three ways.
+
+- **Compilation Flavors**. With so many possible combinations of compilation options, the task of providing a truly complete set of options is intrinsically impossible. Furthermore, the download size for reasonably complete binary packages becomes enormous. This makes it a requirement to split the results into multiple packages, but then searching becomes very difficult.
+
+- **Binary vs Source**. Very closely tied to the first point, NuGet is designed from the ground up to provide relatively small, prebuilt binaries. Due to the nature of native code, developers need to have access to the source code to ensure ABI compatibility, performance, integrity, and debuggability.
+
+- **Per-dll vs Per-application**. NuGet is highly project centric. This works well in managed languages with naturally stable ABIs, because base libraries can continue to evolve without breaking those higher up. However, in native languages where the ABI is much more fragile, the only robust strategy is to explicitly build each library against the exact dependencies that will be included in the final application. This is difficult to ensure in NuGet and leads to a highly disconnected and independently versioned ecosystem.
+
+## Why not Conan?
+Conan.io is a publicly-federated, project-centric, cross-platform, C++ package manager written in python. Our primary differences are:
+
+- **Public federation vs private federation**. Conan relies on individuals publishing independent copies of each package. We believe this approach encourages a large number of packages that are all broken in different ways. We believe it is a waste of user's time to pick through the list of 20+ public packages for Boost 1.56 to determine the handful that will work for their particular situation. In contrast, we believe there should be a single, collaboratively maintained version which works for the vast majority of cases and allow users to hack freely on their private versions. We believe this will result in a set of high quality packages that are heavily tested with each other and form a fantastic base for any private modifications you need.
+
+- **Per-dll vs Per-application**. When dependencies are independently versioned on a library level, it encourages every build environment to be a completely unique, unable to take advantage of or contribute to a solid, well tested ecosystem. In contrast, by versioning all libraries together as a platform (similar to a system package manager), we hope to congregate testing and effort on very common sets of library versions to maximize the quality and stability of the ecosystem. This also completely designs out the ability for a library to ask for versions that conflict with the application's choices (I want openssl Z and boost X but X only claims to work with openssl Y).
+
+- **Cross-platform vs single-platform**. While being hosted on many platforms is an excellent north star, we believe the level of system integration and stability provided by apt-get, yum, and homebrew is well worth needing to exchange `apt-get install libboost-all-dev` with `brew install boost` in automated scripts. We chose to make our system as easy as possible to integrate into a world with these very successful system managers -- one more line for `vcpkg install boost` -- instead of attempting to replace them where they are already so successful and well-loved.
+
+- **C++/CMake vs python**. While Python is an excellent language loved by many, we believe that transparency and familiarity are the most important factors when choosing a tool as important to your workflow as a package manager. Consequently, we chose to make the implementation languages be as universally accepted as possible: C++ should be used in a C++ package manager for C++ programmers. You should not be required to learn another programming language just to understand your package manager.
+
+## Why not Chocolatey?
+Chocolatey is an excellent system for managing applications. However, it is not currently designed to acquire redistributable developer assets and help you with debugging. Vcpkg, in comparison, is designed to get you the libraries you need to build your application and help you deliver through any platform you'd like (including Chocolatey!).

third-party/DPVO/Pangolin/scripts/vcpkg/docs/about/privacy.md

@@ -0,0 +1,50 @@
+# Vcpkg Telemetry and Privacy
+
+vcpkg collects telemetry data to understand usage issues, such as failing packages, and to guide tool improvements. The collected data is anonymous.
+For more information about how Microsoft protects your privacy, see https://privacy.microsoft.com/en-US/privacystatement#mainenterprisedeveloperproductsmodule
+
+## Scope
+
+We explicitly ONLY collect information from invocations of the tool itself; we do NOT add any tracking information into the produced libraries. Telemetry is collected when using any of the `vcpkg` commands.
+
+## How to opt out
+
+The vcpkg telemetry feature is enabled by default. In order to opt-out of data collection, you can re-run the bootstrap script with the following flag, for Windows and Linux/OSX, respectively:
+
+```PS> .\bootstrap-vcpkg.bat -disableMetrics```
+
+```~/$ ./bootstrap-vcpkg.sh -disableMetrics```
+
+## Disclosure
+
+vcpkg displays text similar to the following when you build vcpkg. This is how Microsoft notifies you about data collection.
+
+```
+Telemetry
+---------
+vcpkg collects usage data in order to help us improve your experience.
+The data collected by Microsoft is anonymous.
+You can opt-out of telemetry by re-running the bootstrap-vcpkg script with -disableMetrics,
+passing --disable-metrics to vcpkg on the command line,
+or by setting the VCPKG_DISABLE_METRICS environment variable.
+
+Read more about vcpkg telemetry at docs/about/privacy.md
+```
+
+## Data Collected
+
+The telemetry feature doesn't collect personal data, such as usernames or email addresses. It doesn't scan your code and doesn't extract project-level data, such as name, repository, or author. The data is sent securely to Microsoft servers and held under restricted access.
+
+Protecting your privacy is important to us. If you suspect the telemetry is collecting sensitive data or the data is being insecurely or inappropriately handled, file an issue in the Microsoft/vcpkg repository or send an email to [email protected] for investigation.
+
+We collect various telemetry events such as the command line used, the time of invocation, and how long execution took. Some commands also add additional calculated information (such as the full set of libraries to install). We generate a completely random UUID on first use and attach it to each event.
+
+You can see the telemetry events any command by appending `--printmetrics` after the vcpkg command line.
+
+In the source code (included at https://github.com/microsoft/vcpkg-tool/ ), you can search for calls to the functions `track_property()`, `track_feature()`, `track_metric()`, and `track_buildtime()`
+to see every specific data point we collect.
+
+## Avoid inadvertent disclosure information
+
+vcpkg contributors and anyone else running a version of vcpkg that they built themselves should consider the path to their source code. If a crash occurs when using vcpkg, the file path from the build machine is collected as part of the stack trace and isn't hashed.
+Because of this, builds of vcpkg shouldn't be located in directories whose path names expose personal or sensitive information.

third-party/DPVO/Pangolin/scripts/vcpkg/docs/examples/installing-and-using-packages.md

@@ -0,0 +1,180 @@
+## Installing and Using Packages Example: SQLite
+
+  - [Step 1: Install](#install)
+  - [Step 2: Use](#use)
+    - [VS/MSBuild Project (User-wide integration)](#msbuild)
+    - [CMake (Toolchain file)](#cmake)
+    - [Other integration options](../users/integration.md)
+
+---
+<a name="install"></a>
+## Step 1: Install
+
+First, we need to know what name [SQLite](https://sqlite.org) goes by in the ports tree. To do that, we'll run the `search` command and inspect the output:
+```no-highlight
+PS D:\src\vcpkg> .\vcpkg search sqlite
+libodb-sqlite        2.4.0            Sqlite support for the ODB ORM library
+sqlite3              3.32.1           SQLite is a software library that implements a se...
+
+If your library is not listed, please open an issue at:
+    https://github.com/Microsoft/vcpkg/issues
+```
+Looking at the list, we can see that the port is named "sqlite3". You can also run the `search` command without arguments to see the full list of packages.
+
+Installing is then as simple as using the `install` command.
+```no-highlight
+PS D:\src\vcpkg> .\vcpkg install sqlite3
+Computing installation plan...
+The following packages will be built and installed:
+    sqlite3[core]:x86-windows
+Starting package 1/1: sqlite3:x86-windows
+Building package sqlite3[core]:x86-windows...
+-- Downloading https://sqlite.org/2020/sqlite-amalgamation-3320100.zip...
+-- Extracting source C:/src/vcpkg/downloads/sqlite-amalgamation-3320100.zip
+-- Applying patch fix-arm-uwp.patch
+-- Using source at C:/src/vcpkg/buildtrees/sqlite3/src/3320100-15aeda126a.clean
+-- Configuring x86-windows
+-- Building x86-windows-dbg
+-- Building x86-windows-rel
+-- Performing post-build validation
+-- Performing post-build validation done
+Building package sqlite3[core]:x86-windows... done
+Installing package sqlite3[core]:x86-windows...
+Installing package sqlite3[core]:x86-windows... done
+Elapsed time for package sqlite3:x86-windows: 12 s
+
+Total elapsed time: 12.04 s
+
+The package sqlite3:x86-windows provides CMake targets:
+
+    find_package(unofficial-sqlite3 CONFIG REQUIRED)
+    target_link_libraries(main PRIVATE unofficial::sqlite3::sqlite3))
+
+```
+
+We can check that sqlite3 was successfully installed for x86 Windows desktop by running the `list` command.
+```no-highlight
+PS D:\src\vcpkg> .\vcpkg list
+sqlite3:x86-windows         3.32.1           SQLite is a software library that implements a se...
+```
+
+To install for other architectures and platforms such as Universal Windows Platform or x64 Desktop, you can suffix the package name with `:<target>`.
+```no-highlight
+PS D:\src\vcpkg> .\vcpkg install sqlite3:x86-uwp zlib:x64-windows
+```
+
+See `.\vcpkg help triplet` for all supported targets.
+
+---
+<a name="use"></a>
+## Step 2: Use
+<a name="msbuild"></a>
+#### VS/MSBuild Project (User-wide integration)
+
+The recommended and most productive way to use vcpkg is via user-wide integration, making the system available for all projects you build. The user-wide integration will prompt for administrator access the first time it is used on a given machine, but afterwards is no longer required and the integration is configured on a per-user basis.
+```no-highlight
+PS D:\src\vcpkg> .\vcpkg integrate install
+Applied user-wide integration for this vcpkg root.
+
+All C++ projects can now #include any installed libraries.
+Linking will be handled automatically.
+Installing new libraries will make them instantly available.
+```
+*Note: You will need to restart Visual Studio or perform a Build to update intellisense with the changes.* 
+
+You can now simply use File -> New Project in Visual Studio and the library will be automatically available. For SQLite, you can try out their [C/C++ sample](https://sqlite.org/quickstart.html).
+
+To remove the integration for your user, you can use `.\vcpkg integrate remove`.
+
+<a name="cmake"></a>
+#### CMake (Toolchain File)
+
+The best way to use installed libraries with cmake is via the toolchain file `scripts\buildsystems\vcpkg.cmake`. To use this file, you simply need to add it onto your CMake command line as:  
+`-DCMAKE_TOOLCHAIN_FILE=D:\src\vcpkg\scripts\buildsystems\vcpkg.cmake`.
+
+If you are using CMake through Open Folder with Visual Studio you can define `CMAKE_TOOLCHAIN_FILE` by adding a "variables" section to each of your `CMakeSettings.json` configurations:
+
+```json
+{
+  "configurations": [{
+    "name": "x86-Debug",
+    "generator": "Visual Studio 15 2017",
+    "configurationType" : "Debug",
+    "buildRoot":  "${env.LOCALAPPDATA}\\CMakeBuild\\${workspaceHash}\\build\\${name}",
+    "cmakeCommandArgs": "",
+    "buildCommandArgs": "-m -v:minimal",
+    "variables": [{
+      "name": "CMAKE_TOOLCHAIN_FILE",
+      "value": "D:\\src\\vcpkg\\scripts\\buildsystems\\vcpkg.cmake"
+    }]
+  }]
+}
+```
+*Note: It might be necessary to delete the CMake cache folder of each modified configuration, to force a full regeneration. In the `CMake` menu, under `Cache (<configuration name>)` you'll find `Delete Cache Folders`.*
+
+Now let's make a simple CMake project with a main file.
+```cmake
+# CMakeLists.txt
+cmake_minimum_required(VERSION 3.0)
+project(test)
+
+find_package(unofficial-sqlite3 CONFIG REQUIRED)
+
+add_executable(main main.cpp)
+
+target_link_libraries(main PRIVATE unofficial::sqlite3::sqlite3)
+```
+```cpp
+// main.cpp
+#include <sqlite3.h>
+#include <stdio.h>
+
+int main()
+{
+    printf("%s\n", sqlite3_libversion());
+    return 0;
+}
+```
+
+Then, we build our project in the normal CMake way:
+```no-highlight
+PS D:\src\cmake-test> mkdir build 
+PS D:\src\cmake-test> cd build
+PS D:\src\cmake-test\build> cmake .. "-DCMAKE_TOOLCHAIN_FILE=D:\src\vcpkg\scripts\buildsystems\vcpkg.cmake"
+    // omitted CMake output here //
+-- Build files have been written to: D:/src/cmake-test/build
+PS D:\src\cmake-test\build> cmake --build .
+    // omitted MSBuild output here //
+Build succeeded.
+    0 Warning(s)
+    0 Error(s)
+
+Time Elapsed 00:00:02.38
+PS D:\src\cmake-test\build> .\Debug\main.exe
+3.15.0
+```
+
+*Note: The correct sqlite3.dll is automatically copied to the output folder when building for x86-windows. You will need to distribute this along with your application.*
+
+##### Handling libraries without native cmake support
+
+Unlike other platforms, we do not automatically add the `include\` directory to your compilation line by default. If you're using a library that does not provide CMake integration, you will need to explicitly search for the files and add them yourself using [`find_path()`][1] and [`find_library()`][2].
+
+```cmake
+# To find and use catch
+find_path(CATCH_INCLUDE_DIR catch.hpp)
+include_directories(${CATCH_INCLUDE_DIR})
+
+# To find and use azure-storage-cpp
+find_path(WASTORAGE_INCLUDE_DIR was/blob.h)
+find_library(WASTORAGE_LIBRARY wastorage)
+include_directories(${WASTORAGE_INCLUDE_DIR})
+link_libraries(${WASTORAGE_LIBRARY})
+
+# Note that we recommend using the target-specific directives for a cleaner cmake:
+#     target_include_directories(main ${LIBRARY})
+#     target_link_libraries(main PRIVATE ${LIBRARY})
+```
+
+[1]: https://cmake.org/cmake/help/latest/command/find_path.html
+[2]: https://cmake.org/cmake/help/latest/command/find_library.html

third-party/DPVO/Pangolin/scripts/vcpkg/docs/examples/manifest-mode-cmake.md

@@ -0,0 +1,200 @@
+# Manifest Mode: CMake Example
+
+We would like to add [vcpkg manifest support](../users/manifests.md) to an existing cmake project!
+Let's create a simple project that prints the fibonacci sequence up to a certain number,
+using some common dependencies.
+
+## Initial Layout
+
+Let's create the following file layout:
+
+```no-highlight
+fibo/
+  src/
+    main.cxx
+  CMakeLists.txt
+```
+
+And we wish to use [fmt](https://github.com/fmtlib/fmt), [range-v3](https://github.com/ericniebler/range-v3),
+and [cxxopts](https://github.com/jarro2783/cxxopts).
+
+Let's write our `CMakeLists.txt` first:
+
+```cmake
+cmake_minimum_required(VERSION 3.15)
+
+project(fibo CXX)
+
+find_package(fmt REQUIRED)
+find_package(range-v3 REQUIRED)
+find_package(cxxopts REQUIRED)
+
+add_executable(fibo src/main.cxx)
+target_compile_features(fibo PRIVATE cxx_std_17)
+
+target_link_libraries(fibo
+  PRIVATE
+    fmt::fmt
+    range-v3::range-v3
+    cxxopts::cxxopts)
+```
+
+And then we should add `main.cxx`:
+
+```cxx
+#include <cxxopts.hpp>
+#include <fmt/format.h>
+#include <range/v3/view.hpp>
+
+namespace view = ranges::views;
+
+int fib(int x) {
+  int a = 0, b = 1;
+
+  for (int it : view::repeat(0) | view::take(x)) {
+    (void)it;
+    int tmp = a;
+    a += b;
+    b = tmp;
+  }
+
+  return a;
+}
+
+int main(int argc, char** argv) {
+  cxxopts::Options options("fibo", "Print the fibonacci sequence up to a value 'n'");
+    options.add_options()
+      ("n,value", "The value to print to", cxxopts::value<int>()->default_value("10"));
+
+  auto result = options.parse(argc, argv);
+  auto n = result["value"].as<int>();
+
+  for (int x : view::iota(1) | view::take(n)) {
+    fmt::print("fib({}) = {}\n", x, fib(x));
+  }
+}
+```
+
+This is a simple project of course, but it should give us a clean project to start with.
+Let's try it out!
+
+Let's assume you have `fmt`, `range-v3`, and `cxxopts` installed with vcpkg classic mode;
+then, you can just do a simple:
+
+```cmd
+D:\src\fibo> cmake -B build -S . -DCMAKE_TOOLCHAIN_FILE=D:\src\vcpkg\scripts\buildsystems\vcpkg.cmake
+-- Building for: Visual Studio 16 2019
+-- Selecting Windows SDK version 10.0.18362.0 to target Windows 10.0.19041.
+-- The CXX compiler identification is MSVC 19.27.29111.0
+-- Detecting CXX compiler ABI info
+-- Detecting CXX compiler ABI info - done
+-- Check for working CXX compiler: C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.27.29110/bin/Hostx64/x64/cl.exe - skipped
+-- Detecting CXX compile features
+-- Detecting CXX compile features - done
+-- Configuring done
+-- Generating done
+-- Build files have been written to: D:/src/fibo/build
+D:\src\fibo> cmake --build build
+Microsoft (R) Build Engine version 16.7.0+b89cb5fde for .NET Framework
+Copyright (C) Microsoft Corporation. All rights reserved.
+
+  Checking Build System
+  Building Custom Rule D:/src/fibo/CMakeLists.txt
+  main.cxx
+  The contents of <span> are available only with C++20 or later.
+  fibo.vcxproj -> D:\src\fibo\build\Debug\fibo.exe
+  Building Custom Rule D:/src/fibo/CMakeLists.txt
+```
+
+And now we can try out the `fibo` binary!
+
+```cmd
+D:\src\fibo> .\build\Debug\fibo.exe -n 7 
+fib(1) = 1
+fib(2) = 1
+fib(3) = 2
+fib(4) = 3
+fib(5) = 5
+fib(6) = 8
+fib(7) = 13
+```
+
+it works!
+
+## Converting to Manifest Mode
+
+We now wish to use manifest mode, so all of our dependencies are managed for us! Let's write a `vcpkg.json`:
+
+```json
+{
+  "name": "fibo",
+  "version-string": "0.1.0",
+  "dependencies": [
+    "cxxopts",
+    "fmt",
+    "range-v3"
+  ]
+}
+```
+
+Let's delete the build directory and rerun the build:
+
+```cmd
+D:\src\fibo> rmdir /S /Q build
+D:\src\fibo> cmake -B build -S . -DCMAKE_TOOLCHAIN_FILE=D:\src\vcpkg\scripts\buildsystems\vcpkg.cmake
+-- Running vcpkg install
+Detecting compiler hash for triplet x64-windows...
+The following packages will be built and installed:
+    cxxopts[core]:x64-windows
+    fmt[core]:x64-windows
+    range-v3[core]:x64-windows
+Starting package 1/3: cxxopts:x64-windows
+Building package cxxopts[core]:x64-windows...
+Using cached binary package: C:\Users\me\AppData\Local\vcpkg/archives\d2\d2d1e5302cdfefef2fd090d8eda84cc0c1fbe6f1.zip
+Building package cxxopts[core]:x64-windows... done
+Installing package cxxopts[core]:x64-windows...
+Installing package cxxopts[core]:x64-windows... done
+Elapsed time for package cxxopts:x64-windows: 50.64 ms
+Starting package 2/3: fmt:x64-windows
+Building package fmt[core]:x64-windows...
+Using cached binary package: C:\Users\me\AppData\Local\vcpkg/archives\bf\bf00d5214e912d71414b545b241f54ef87fdf6e5.zip
+Building package fmt[core]:x64-windows... done
+Installing package fmt[core]:x64-windows...
+Installing package fmt[core]:x64-windows... done
+Elapsed time for package fmt:x64-windows: 225 ms
+Starting package 3/3: range-v3:x64-windows
+Building package range-v3[core]:x64-windows...
+Using cached binary package: C:\Users\me\AppData\Local\vcpkg/archives\fe\fe2cdedef6953bf954e8ddca471bf3cc8d9b06d7.zip
+Building package range-v3[core]:x64-windows... done
+Installing package range-v3[core]:x64-windows...
+Installing package range-v3[core]:x64-windows... done
+Elapsed time for package range-v3:x64-windows: 1.466 s
+
+Total elapsed time: 1.742 s
+
+-- Running vcpkg install - done
+-- Selecting Windows SDK version 10.0.18362.0 to target Windows 10.0.19041.
+-- The CXX compiler identification is MSVC 19.27.29111.0
+-- Detecting CXX compiler ABI info
+-- Detecting CXX compiler ABI info - done
+-- Check for working CXX compiler: C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.27.29110/bin/Hostx64/x64/cl.exe - skipped
+-- Detecting CXX compile features
+-- Detecting CXX compile features - done
+-- Configuring done
+-- Generating done
+-- Build files have been written to: D:/src/fibo/build
+D:\src\fibo> cmake --build build
+Microsoft (R) Build Engine version 16.7.0+b89cb5fde for .NET Framework
+Copyright (C) Microsoft Corporation. All rights reserved.
+
+  Checking Build System
+  Building Custom Rule D:/src/fibo/CMakeLists.txt
+  main.cxx
+  The contents of <span> are available only with C++20 or later.
+  fibo.vcxproj -> D:\src\fibo\build\Debug\fibo.exe
+  Building Custom Rule D:/src/fibo/CMakeLists.txt
+```
+
+You can see that with just a _single file_, we've changed over to manifests without _any_ trouble.
+The build system doesn't change _at all_! We just add a `vcpkg.json` file, delete the build directory,
+and reconfigure. And we're done!

third-party/DPVO/Pangolin/scripts/vcpkg/docs/examples/modify-baseline-to-pin-old-boost.md

@@ -0,0 +1,190 @@
+# Pin old Boost versions
+This document will teach you how to set versions of meta-packages like `boost` or `qt5`. 
+
+**What is a meta-package?**  
+In vcpkg we call meta-packages to ports that by themselves don't install anything but that instead forward installation to another port or ports. The reasons for these meta-packages to exist are plenty: to install different versions of a library depending on platform (like the old OpenSSL port did), to allow for multiple versions to exist in the vcpkg registry at the same time (OpenCV), or to conveniently install/uninstall a catalog of related packages (Boost and Qt).  
+
+In the case of Boost, it is unlikely that a user requires all of the 140+ Boost libraries in their project. For the sake of convenience, vcpkg splits Boost into multiple sub-packages broken down to individual libraries. By doing so, users can limit the subset of Boost libraries that they depend on. 
+
+If a user wants to install all of the Boost libraries available in vcpkg, they can do so by installing the `boost` meta-package. 
+
+Due to the nature of meta-packages, some unexpected issues arise when trying to use them with versioning. If a user writes the following manifest file:
+
+`vcpkg.json`
+```json
+{
+    "name": "demo",
+    "version": "1.0.0",
+    "builtin-baseline": "787fe1418ea968913cc6daf11855ffd8b0b5e9d4",
+    "dependencies": [ "boost-tuple" ],
+    "overrides": [ 
+        { "name": "boost", "version": "1.72.0" }
+    ]
+}
+```
+
+The resulting installation plan is:
+```
+The following packages will be built and installed:
+    boost-assert[core]:x64-windows -> 1.75.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-assert\3393715b4ebe30fe1c3b68acf7f84363e611f156
+    boost-compatibility[core]:x64-windows -> 1.75.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-compatibility\cda5675366367789659c59aca65fc57d03c51deb
+    boost-config[core]:x64-windows -> 1.75.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-config\ca82ca1b9c1739c91f3cf42c68cee56c896ae6bd
+    boost-container-hash[core]:x64-windows -> 1.75.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-container-hash\bf472c23d29c3d80b562c43471eb92cea998f372
+    boost-core[core]:x64-windows -> 1.75.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-core\20a19f6ece37686a02eed33e1f58add8b7a2582a
+    boost-detail[core]:x64-windows -> 1.75.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-detail\96744251f025f9b3c856a275dfc338031876777b
+    boost-integer[core]:x64-windows -> 1.75.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-integer\de70ce0d1500df1eda3496c4f98f42f5db256b4a
+    boost-io[core]:x64-windows -> 1.75.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-io\7bf3407372f8fc2a99321d24a0e952d44fe25bf3
+    boost-preprocessor[core]:x64-windows -> 1.75.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-preprocessor\8d78b8ba2e9f54cb00137115ddd2ffec1c63c149
+    boost-static-assert[core]:x64-windows -> 1.75.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-static-assert\2a41c4703c7122de25b1c60510c43edc9371f63d
+    boost-throw-exception[core]:x64-windows -> 1.75.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-throw-exception\b13bdf32a20786a0165cc20205ef63765cac0627
+    boost-tuple[core]:x64-windows -> 1.75.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-tuple\22e3d000a178a88992c430d8ae8a0244c7dea674
+    boost-type-traits[core]:x64-windows -> 1.75.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-type-traits\8829793f6c6c913257314caa317599f8d253a5ca
+    boost-uninstall[core]:x64-windows -> 1.75.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-uninstall\08933bad27b6d41caef0940c31e2069ecb6a079c
+    boost-utility[core]:x64-windows -> 1.75.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-utility\47572946bf6a63c731b9c4142eecb8bef3d3b270
+    boost-vcpkg-helpers[core]:x64-windows -> 7#2 -- D:\vcpkg\buildtrees\versioning\versions\boost-vcpkg-helpers\2a21e5ab45d1ce41c185faf85dff0670ea6def1d
+```
+
+It is reasonable to expect that overriding `boost` to version 1.72.0 results in all Boost packages being pinned to version 1.72.0. **However, vcpkg does not treat the `boost` meta-package any differently that any other port.** In other words, vcpkg has no notion that `boost` is related to all the other `boost-*` libraries, other than it depends on all of them. For this reason, all the other boost packages are installed at version 1.75.0, which is the baseline version.
+
+Below, we describe two methods to pin down Boost versions effectively.
+
+## Method 1: Pin specific packages
+Use `"overrides"` to force specific versions in a package-by-package basis. 
+
+`vcpkg.json`
+```json
+{
+    "name": "demo",
+    "version": "1.0.0",
+    "builtin-baseline": "787fe1418ea968913cc6daf11855ffd8b0b5e9d4",
+    "dependencies": [ "boost-tuple" ],
+    "overrides": [
+        { "name": "boost-core", "version": "1.72" },
+        { "name": "boost-integer", "version": "1.72" },
+        { "name": "boost-io", "version": "1.72" },
+        { "name": "boost-tuple", "version": "1.72" }
+    ]
+}
+```
+
+This method allows you to quickly set the specific versions you want, but you will need to write an override for each package. Boost libraries are also heavily interdependent, which means that you may end up writing a lot of override lines.
+
+The second method makes it easy to pin the entire Boost collection and end up with a very simple manifest file.
+
+## Method 2: Modify baseline
+An easy way to set the version for the entirety of boost is to use the `"builtin-baseline"` property. 
+
+As of right now, it is only possible to go back to Boost version `1.75.0` using a baseline. Since that was the contemporary Boost version when the versioning feature was merged. **But, it is possible to modify the baseline to whatever you like and use that instead.**
+
+### Step 1: Create a new branch
+As described in the versioning documentation. The value that goes in `"builtin-baseline"` is a Git commit in the vcpkg repository's history. Then it stands to reason, that if you want to customize the baseline you should be able to create a new commit with said custom baseline. 
+
+Let's start by creating a new branch to hold our modified baseline.  
+In the directory containing your clone of the vcpkg Git repository run:
+
+```
+git checkout -b custom-boost-baseline
+```
+
+This will create a new branch named `custom-boost-baseline` and check it out immediately.
+
+### Step 2: Modify the baseline
+The next step is to modify the baseline file, open the file in your editor of choice and modify the entries for the Boost libraries.
+
+Change the `"baseline"` version to your desired version.  
+_NOTE: Remember to also set the port versions to 0 (or your desired version)._
+
+`${vcpkg-root}/versions/baseline.json`
+```diff
+...
+     "boost": {
+-      "baseline": "1.75.0",
++      "baseline": "1.72.0",
+       "port-version": 0
+     },
+     "boost-accumulators": {
+-      "baseline": "1.75.0",
+-      "port-version": 1
++      "baseline": "1.72.0",
++      "port-version": 0
+     },
+     "boost-algorithm": {
+-      "baseline": "1.75.0",
++      "baseline": "1.72.0",
+       "port-version": 0
+     },
+     "boost-align": {
+-      "baseline": "1.75.0",
++      "baseline": "1.72.0",
+       "port-version": 0
+     },
+...
+    "boost-uninstall: {
+        "baseline": "1.75.0",
+        "port-version": 0
+    },
+...
+```
+
+Some `boost-` packages are helpers used by vcpkg and are not part of Boost. For example, `"boost-uninstall"` is a vcpkg helper to conveniently uninstall all Boost libraries, but it didn't exist for Boost version `1.72.0`, in this case it is fine to leave it at `1.75.0` to avoid baseline errors (since all versions in `baseline.json` must have existed). 
+
+### Step 3: Commit your changes
+After saving your modified file, run these commands to commit your changes:
+
+```
+git add versions/baseline.json
+git commit -m "Baseline Boost 1.72.0"
+```
+
+You can set the commit message to whatever you want, just make it useful for you.
+
+### Step 4: Get your baseline commit SHA
+Once all your changes are ready, you can get the commit SHA by running:
+```
+git rev-parse HEAD
+```
+
+The output of that command will be the commit SHA you need to put as the `"builtin-baseline"` in your project's manifest file. Copy the 40-hex digits and save them to use later in your manifest file.
+
+### Step 5: (Optional) Go back to the main repository branch
+Once your changes have been committed locally, you can refer to the commit SHA regardless of the repository branch you're working on. So, let's go back to the main vcpkg repository branch.
+
+```
+git checkout master
+```
+
+### Step 6: Create your manifest file with your custom baseline
+
+```json
+{
+    "name": "demo",
+    "version": "1.0.0",
+    "builtin-baseline": "9b5cf7c3d9376ddf43429671282972ec4f99aa85",
+    "dependencies": [ "boost-tuple" ]
+}
+```
+
+In this example, commit SHA `9b5cf7c3d9376ddf43429671282972ec4f99aa85` is the commit ID with the modified baseline. Even when a different branch (`master` in this case) is checked out, Git is able to find the commit as long as the branch with the modified baseline exists (the `custom-boost-baseline` branch we created in step 1).
+
+We run `vcpkg install` in the directory containing our manifest file and the output looks like this:
+
+```
+The following packages will be built and installed:
+    boost-assert[core]:x64-windows -> 1.72.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-assert\6754398591f48435b28014ca0d60e5375a4c04d1
+    boost-compatibility[core]:x64-windows -> 1.72.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-compatibility\9893ff3c554575bc712df4108a949e07b269f401
+    boost-config[core]:x64-windows -> 1.72.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-config\de2784767046b06ec31eb718f10df512e51f2aad
+    boost-container-hash[core]:x64-windows -> 1.72.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-container-hash\cc19fb0154bbef188f309f49b2664ec7623b96b6
+    boost-core[core]:x64-windows -> 1.72.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-core\0eb5e20df9e267e9eca325be946f52ceb8a60229
+    boost-detail[core]:x64-windows -> 1.72.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-detail\759d7c6a3f9dbaed0b0c69fa0bb764f7606bb02d
+    boost-integer[core]:x64-windows -> 1.72.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-integer\173956c61a26e83b0f8b58b0baf60f06aeee637c
+    boost-preprocessor[core]:x64-windows -> 1.72.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-preprocessor\86eb3938b7875f124feb845331dbe84cbab5d1c6
+    boost-static-assert[core]:x64-windows -> 1.72.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-static-assert\e82d8f7f3ee07e927dc374f5a08ed6d6f4ef81f4
+    boost-throw-exception[core]:x64-windows -> 1.72.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-throw-exception\64df295f7df41de4fcb219834889b126b5020def
+    boost-tuple[core]:x64-windows -> 1.72.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-tuple\b3e1b01ffce6e367e4fed0a5538a8546abacb6b2
+    boost-type-traits[core]:x64-windows -> 1.72.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-type-traits\5e44ec657660eccf4d3b2710b092dd238e1e7a2d
+    boost-uninstall[core]:x64-windows -> 1.75.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-uninstall\08933bad27b6d41caef0940c31e2069ecb6a079c
+    boost-utility[core]:x64-windows -> 1.72.0 -- D:\vcpkg\buildtrees\versioning\versions\boost-utility\7d721b2458d5d595ac341eb54883274f38a4b8c2
+    boost-vcpkg-helpers[core]:x64-windows -> 7#2 -- D:\vcpkg\buildtrees\versioning\versions\boost-vcpkg-helpers\2a21e5ab45d1ce41c185faf85dff0670ea6def1d
+```
+
+Notice how simple our manifest file has become, instead of having a multitude of `"overrides"` you can pin down all Boost packages just by setting the `"builtin-baseline"` to be your modified baseline commit SHA.

third-party/DPVO/Pangolin/scripts/vcpkg/docs/examples/overlay-triplets-linux-dynamic.md

@@ -0,0 +1,126 @@
+# Overlay triplets example
+
+## Building dynamic libraries on Linux
+
+Using **vcpkg** you can build libraries for many configurations out of the box. However, this doesn't currently include shared libraries on Linux and Mac OS.
+
+This doesn't mean that you cannot use **vcpkg** to build your dynamic libraries on these platforms! This document will guide you through creating your own custom triplets with `--overlay-triplets` to easily build dynamic libraries on Linux.
+
+### Step 1: Create the custom triplet files
+
+To save time, copy the existing `x64-linux.cmake` triplet file.
+
+```sh
+~/git$ mkdir custom-triplets
+~/git$ cp vcpkg/triplets/x64-linux.cmake custom-triplets/x64-linux-dynamic.cmake
+```
+
+And modify `custom-triplets/x64-linux-dynamic.cmake` to match the contents below:
+```cmake
+# ~/git/custom-triplets/x64-linux-dynamic.cmake
+set(VCPKG_TARGET_ARCHITECTURE x64)
+set(VCPKG_CRT_LINKAGE dynamic)
+set(VCPKG_LIBRARY_LINKAGE dynamic) # This changed from static to dynamic
+
+set(VCPKG_CMAKE_SYSTEM_NAME Linux)
+```
+
+### Step 2: Use `--overlay-triplets` to build dynamic libraries
+
+Use the `--overlay-triplets` option to include the triplets in the `custom-triplets` directory. 
+
+```
+~/git$ vcpkg/vcpkg install sqlite3:x64-linux-dynamic --overlay-triplets=custom-triplets
+The following packages will be built and installed:
+    sqlite3[core]:x64-linux-dynamic
+Starting package 1/1: sqlite3:x64-linux-dynamic
+Building package sqlite3[core]:x64-linux-dynamic...
+-- Loading triplet configuration from: /home/victor/git/custom-triplets/x64-linux-dynamic.cmake
+-- Downloading https://sqlite.org/2019/sqlite-amalgamation-3280000.zip...
+-- Extracting source /home/victor/git/vcpkg/downloads/sqlite-amalgamation-3280000.zip
+-- Applying patch fix-arm-uwp.patch
+-- Using source at /home/victor/git/vcpkg/buildtrees/sqlite3/src/3280000-6a3ff7ce92
+-- Configuring x64-linux-dynamic-dbg
+-- Configuring x64-linux-dynamic-rel
+-- Building x64-linux-dynamic-dbg
+-- Building x64-linux-dynamic-rel
+-- Performing post-build validation
+-- Performing post-build validation done
+Building package sqlite3[core]:x64-linux-dynamic... done
+Installing package sqlite3[core]:x64-linux-dynamic...
+Installing package sqlite3[core]:x64-linux-dynamic... done
+Elapsed time for package sqlite3:x64-linux-dynamic: 44.82 s
+
+Total elapsed time: 44.82 s
+
+The package sqlite3:x64-linux-dynamic provides CMake targets:
+
+    find_package(unofficial-sqlite3 CONFIG REQUIRED)
+    target_link_libraries(main PRIVATE unofficial::sqlite3::sqlite3)
+```
+
+Overlay triplets enables your custom triplet files when using `vcpkg install`, `vcpkg update`, `vcpkg upgrade`, and `vcpkg remove`.
+
+When using the `--overlay-triplets` option, a message like the following lets you know that a custom triplet is being used: 
+
+```
+-- Loading triplet configuration from: /home/custom-triplets/x64-linux-dynamic.cmake
+```
+
+## Overriding default triplets
+
+As you may have noticed, the default triplets for Windows (`x86-windows` and `x64-windows`) install dynamic libraries, while a suffix (`-static`) is needed for static libraries. This is different with Linux and Mac OS where static libraries are built by `x64-linux` and `x64-osx`.
+
+Using `--overlay-triplets` it is possible to override the default triplets to accomplish the same behavior on Linux:
+
+* `x64-linux`: Builds dynamic libraries,
+* `x64-linux-static`: Builds static libraries.
+
+### Step 1: Create the overlay triplets
+
+Using the custom triplet created in the previous example, rename `custom-triplets/x64-linux-dynamic.cmake` to `custom-triplets/x64-linux.cmake`. Then, copy the default `x64-linux` triplet (which builds static libraries) in your `custom-triplets` folder and rename it to `x64-linux-static.cmake`.
+
+```sh
+~/git$ mv custom-triplets/x64-linux-dynamic.cmake custom-triplets/x64-linux.cmake
+~/git$ cp vcpkg/triplets/x64-linux.cmake custom-triplets/x64-linux-static.cmake
+```
+
+### Step 2: Use `--overlay-triplets` to override default triplets
+
+Use the `--overlay-triplets` option to include the triplets in the `custom-triplets` directory.
+
+```
+~/git$ vcpkg/vcpkg install sqlite3:x64-linux --overlay-triplets=custom-triplets
+The following packages will be built and installed:
+    sqlite3[core]:x64-linux
+Starting package 1/1: sqlite3:x64-linux
+Building package sqlite3[core]:x64-linux...
+-- Loading triplet configuration from: /home/victor/git/custom-triplets/x64-linux.cmake
+-- Downloading https://sqlite.org/2019/sqlite-amalgamation-3280000.zip...
+-- Extracting source /home/victor/git/vcpkg/downloads/sqlite-amalgamation-3280000.zip
+-- Applying patch fix-arm-uwp.patch
+-- Using source at /home/victor/git/vcpkg/buildtrees/sqlite3/src/3280000-6a3ff7ce92
+-- Configuring x64-linux-dbg
+-- Configuring x64-linux-rel
+-- Building x64-linux-dbg
+-- Building x64-linux-rel
+-- Performing post-build validation
+-- Performing post-build validation done
+Building package sqlite3[core]:x64-linux... done
+Installing package sqlite3[core]:x64-linux...
+Installing package sqlite3[core]:x64-linux... done
+Elapsed time for package sqlite3:x64-linux: 44.82 s
+
+Total elapsed time: 44.82 s
+
+The package sqlite3:x64-linux provides CMake targets:
+
+    find_package(unofficial-sqlite3 CONFIG REQUIRED)
+    target_link_libraries(main PRIVATE unofficial::sqlite3::sqlite3)
+```
+
+Note that the default triplet is masked by your custom triplet:
+
+```
+-- Loading triplet configuration from: /home/victor/git/custom-triplets/x64-linux.cmake
+```

third-party/DPVO/Pangolin/scripts/vcpkg/docs/examples/packaging-github-repos.md

@@ -0,0 +1,54 @@
+## Packaging Github Repos Example: libogg
+### Create the manifest file
+The manifest file (called `vcpkg.json`) is a json file describing the package's metadata.
+
+For libogg, we'll create the file `ports/libogg/vcpkg.json` with the following content:
+
+```json
+{
+  "name": "libogg",
+  "version-string": "1.3.3",
+  "description": "Ogg is a multimedia container format, and the native file and stream format for the Xiph.org multimedia codecs."
+}
+```
+
+You can format the manifest file to our specifications with `vcpkg format-manifest ports/libogg/vcpkg.json`.
+
+### Create the portfile
+`portfile.cmake` describes how to build and install the package. First we download the project from Github with [`vcpkg_from_github`](../maintainers/vcpkg_from_github.md):
+
+```cmake
+vcpkg_from_github(
+    OUT_SOURCE_PATH SOURCE_PATH
+    REPO xiph/ogg
+    REF v1.3.3
+    SHA512 0bd6095d647530d4cb1f509eb5e99965a25cc3dd9b8125b93abd6b248255c890cf20710154bdec40568478eb5c4cde724abfb2eff1f3a04e63acef0fbbc9799b
+    HEAD_REF master
+)
+```
+
+The important parts to update are `REPO` for the GitHub repository path, `REF` for a stable tag/commit to use, and `SHA512` with the checksum of the downloaded zipfile (you can get this easily by setting it to `0`, trying to install the package, and copying the checksum).
+
+Finally, we configure the project with CMake, install the package, and copy over the license file:
+
+```cmake
+vcpkg_cmake_configure(SOURCE_PATH ${SOURCE_PATH})
+vcpkg_cmake_install()
+file(INSTALL "${SOURCE_PATH}/COPYING" DESTINATION "${CURRENT_PACKAGES_DIR}/share/libogg" RENAME copyright)
+```
+
+Check the documentation for [`vcpkg_cmake_configure`](../maintainers/ports/vcpkg-cmake/vcpkg_cmake_configure.md) and [`vcpkg_cmake_install`](../maintainers/ports/vcpkg-cmake/vcpkg_cmake_install.md) if your package needs additional options. 
+
+Now you can run `vcpkg install libogg` to build and install the package.
+
+### Suggested example portfiles
+In the `ports/` directory are many libraries that can be used as examples, including many that are not based on CMake.
+
+- Header only libraries
+  - rapidjson
+  - range-v3
+- MSBuild-based
+  - mpg123
+- Non-CMake, custom buildsystem
+  - openssl
+  - ffmpeg

third-party/DPVO/Pangolin/scripts/vcpkg/docs/examples/packaging-zipfiles.md

@@ -0,0 +1,76 @@
+## Packaging `.zip` Files Example: zlib
+
+### Bootstrap with `create`
+First, locate a globally accessible archive of the library's sources. Zip, gzip, and bzip are all supported. Strongly prefer official sources or mirrors over unofficial mirrors.
+
+*Looking at zlib's website, the URL http://zlib.net/zlib-1.2.11.tar.gz looks appropriate.*
+
+Second, determine a suitable package name. This should be ASCII, lowercase, and recognizable to someone who knows the library's "human name". If the library is already packaged in another package manager, prefer that name.
+
+*Since zlib is already packaged as zlib, we will use the name zlib2 for this example.*
+
+Finally, if the server's name for the archive is not very descriptive (such as downloading a zipped commit or branch from GitHub), choose a nice archive name of the form `<packagename>-<version>.zip`.
+
+*`zlib1211.zip` is a fine name, so no change needed.*
+
+All this information can then be passed into the `create` command, which will download the sources and bootstrap the packaging process inside `ports/<packagename>`.
+
+```no-highlight
+PS D:\src\vcpkg> .\vcpkg create zlib2 http://zlib.net/zlib-1.2.11.tar.gz zlib1211.tar.gz
+-- Generated portfile: D:/src/vcpkg/ports/zlib2/portfile.cmake
+```
+
+### Create the manifest file
+In addition to the generated `ports/<package>/portfile.cmake`, we also need a `ports/<package>/vcpkg.json` file. This file is a simple set of fields describing the package's metadata.
+
+*For zlib2, we'll create the file `ports/zlib2/vcpkg.json` with the following contents:*
+```json
+{
+  "name": "zlib2",
+  "version-string": "1.2.11",
+  "description": "A Massively Spiffy Yet Delicately Unobtrusive Compression Library"
+}
+```
+
+### Tweak the generated portfile
+The generated `portfile.cmake` will need some editing to correctly package most libraries in the wild, however we can start by trying out the build.
+
+```no-highlight
+PS D:\src\vcpkg> .\vcpkg install zlib2
+Computing installation plan...
+The following packages will be built and installed:
+    zlib2[core]:x64-uwp
+Starting package 1/1: zlib2:x64-uwp
+Building package zlib2[core]:x64-uwp...
+-- Using cached C:/src/vcpkg/downloads/zlib1211.tar.gz
+-- Cleaning sources at C:/src/vcpkg/buildtrees/zlib2/src/1.2.11-deec42f53b.clean. Pass --editable to vcpkg to reuse sources.
+-- Extracting source C:/src/vcpkg/downloads/zlib1211.tar.gz
+-- Applying patch cmake_dont_build_more_than_needed.patch
+-- Using source at C:/src/vcpkg/buildtrees/zlib2/src/1.2.11-deec42f53b.clean
+-- Configuring x64-uwp
+-- Building x64-uwp-dbg
+-- Building x64-uwp-rel
+-- Installing: C:/src/vcpkg/packages/zlib2_x64-uwp/share/zlib2/copyright
+-- Performing post-build validation
+Include files should not be duplicated into the /debug/include directory. If this cannot be disabled in the project cmake, use
+    file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/debug/include)
+/debug/share should not exist. Please reorganize any important files, then use
+    file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/debug/share)
+The software license must be available at ${CURRENT_PACKAGES_DIR}/share/zlib2/copyright
+Found 3 error(s). Please correct the portfile:
+    D:\src\vcpkg\ports\zlib2\portfile.cmake
+```
+
+At this point, it is a matter of reading the error messages and log files while steadily improving the quality of the portfile. Zlib required providing a discrete copy of the LICENSE to copy into the package, suppressing the build and installation of executables and headers, and removing the static libraries after they were installed.
+
+### Suggested example portfiles
+In the `ports/` directory are many libraries that can be used as examples, including many that are not based on CMake.
+
+- Header only libraries
+    - rapidjson
+    - range-v3
+- MSBuild-based
+    - mpg123
+- Non-CMake, custom buildsystem
+    - openssl
+    - ffmpeg