├── thirdparty ├── Sophus │ ├── SOPHUS_VERSION │ ├── sympy │ │ ├── sophus │ │ │ ├── __init__.py │ │ │ └── cse_codegen.py │ │ ├── cpp_gencode │ │ │ ├── So2_Dx_log_exp_x_times_this_at_0.cpp │ │ │ ├── So2_Dx_log_this.cpp │ │ │ ├── So2_Dx_exp_x.cpp │ │ │ ├── So2_Dx_this_mul_exp_x_at_0.cpp │ │ │ ├── Se2_Dx_this_mul_exp_x_at_0.cpp │ │ │ ├── So3_Dx_this_mul_exp_x_at_0.cpp │ │ │ ├── Se2_Dx_exp_x.cpp │ │ │ ├── So3_Dx_log_this.cpp │ │ │ ├── Se2_Dx_log_this.cpp │ │ │ └── So3_Dx_exp_x.cpp │ │ └── run_tests.sh │ ├── sophus_pybind-stubs │ │ └── py.typed │ ├── test │ │ ├── CMakeLists.txt │ │ ├── core │ │ │ └── CMakeLists.txt │ │ └── ceres │ │ │ └── CMakeLists.txt │ ├── sophus_pybind │ │ ├── bindings.cpp │ │ └── SophusPyBind.h │ ├── examples │ │ ├── ensure_example.cpp │ │ ├── custom_ensure_handler.cpp │ │ └── CMakeLists.txt │ ├── SophusConfig.cmake.in │ ├── generate_stubs.py │ ├── scripts │ │ ├── run_cpp_tests_gcc.sh │ │ ├── run_cpp_tests_clang.sh │ │ ├── install_osx_deps_incl_ceres.sh │ │ └── install_ubuntu_deps_incl_ceres.sh │ ├── LICENSE.txt │ └── sophus │ │ └── interpolate.hpp ├── spdlog │ ├── .gitattributes │ ├── logos │ │ └── spdlog.png │ ├── include │ │ └── spdlog │ │ │ ├── fmt │ │ │ ├── bundled │ │ │ │ ├── core.h │ │ │ │ └── fmt.license.rst │ │ │ ├── xchar.h │ │ │ ├── chrono.h │ │ │ ├── ostr.h │ │ │ ├── ranges.h │ │ │ ├── compile.h │ │ │ ├── std.h │ │ │ └── fmt.h │ │ │ ├── details │ │ │ ├── windows_include.h │ │ │ ├── console_globals.h │ │ │ ├── periodic_worker-inl.h │ │ │ ├── synchronous_factory.h │ │ │ ├── log_msg_buffer.h │ │ │ ├── null_mutex.h │ │ │ ├── backtracer.h │ │ │ └── log_msg.h │ │ │ ├── fwd.h │ │ │ ├── version.h │ │ │ ├── formatter.h │ │ │ ├── sinks │ │ │ ├── sink-inl.h │ │ │ ├── sink.h │ │ │ ├── ostream_sink.h │ │ │ └── null_sink.h │ │ │ └── cfg │ │ │ ├── helpers.h │ │ │ ├── env.h │ │ │ └── argv.h │ ├── .git-blame-ignore-revs │ ├── scripts │ │ ├── ci_setup_clang.sh │ │ ├── extract_version.py │ │ └── format.sh │ ├── src │ │ ├── cfg.cpp │ │ ├── async.cpp │ │ ├── file_sinks.cpp │ │ └── spdlog.cpp │ ├── tests │ │ ├── main.cpp │ │ ├── utils.h │ │ ├── test_systemd.cpp │ │ ├── includes.h │ │ └── test_circular_q.cpp │ ├── cmake │ │ ├── spdlog.pc.in │ │ ├── spdlogConfig.cmake.in │ │ ├── version.rc.in │ │ └── ide.cmake │ ├── .clang-format │ ├── bench │ │ ├── utils.h │ │ └── CMakeLists.txt │ ├── example │ │ └── CMakeLists.txt │ ├── INSTALL │ ├── .github │ │ └── workflows │ │ │ └── macos.yml │ └── LICENSE ├── pangolin │ ├── components │ │ ├── pango_core │ │ │ ├── src │ │ │ │ ├── dummy.cpp │ │ │ │ └── factory │ │ │ │ │ └── factory_registry.cpp │ │ │ └── include │ │ │ │ ├── pangolin │ │ │ │ ├── utils │ │ │ │ │ ├── signal_slot.h │ │ │ │ │ ├── posix │ │ │ │ │ │ ├── semaphore.h │ │ │ │ │ │ ├── condition_variable.h │ │ │ │ │ │ └── shared_memory_buffer.h │ │ │ │ │ ├── true_false_toggle.h │ │ │ │ │ ├── is_streamable.h │ │ │ │ │ ├── compontent_cast.h │ │ │ │ │ ├── variadic_all.h │ │ │ │ │ └── memstreambuf.h │ │ │ │ └── factory │ │ │ │ │ ├── factory.h │ │ │ │ │ └── factory_help.h │ │ │ │ ├── dynalo │ │ │ │ └── detail │ │ │ │ │ └── config.hpp │ │ │ │ ├── sigslot │ │ │ │ └── LICENCE │ │ │ │ └── NaturalSort │ │ │ │ ├── LICENSE.md │ │ │ │ └── README.md │ │ ├── pango_windowing │ │ │ ├── include │ │ │ │ └── pangolin │ │ │ │ │ └── windowing │ │ │ │ │ └── X11GlContext.h │ │ │ └── src │ │ │ │ └── window.cpp │ │ ├── pango_opengl │ │ │ ├── src │ │ │ │ ├── fonts │ │ │ │ │ └── AnonymousPro.ttf │ │ │ │ ├── gltexturecache.cpp │ │ │ │ └── compat │ │ │ │ │ └── gl2engine.cpp │ │ │ └── include │ │ │ │ └── pangolin │ │ │ │ └── gl │ │ │ │ └── compat │ │ │ │ └── gl_es_compat.h │ │ ├── pango_display │ │ │ ├── include │ │ │ │ └── pangolin │ │ │ │ │ └── display │ │ │ │ │ └── default_font.h │ │ │ ├── src │ │ │ │ └── default_font.cpp │ │ │ └── CMakeLists.txt │ │ ├── pango_plot │ │ │ ├── include │ │ │ │ └── pangolin │ │ │ │ │ └── plot │ │ │ │ │ └── loaders │ │ │ │ │ ├── table_loader.h │ │ │ │ │ └── csv_table_loader.h │ │ │ └── CMakeLists.txt │ │ ├── tinyobj │ │ │ ├── CMakeLists.txt │ │ │ └── src │ │ │ │ └── tinyobj.cpp │ │ ├── pango_scene │ │ │ ├── CMakeLists.txt │ │ │ └── include │ │ │ │ └── pangolin │ │ │ │ └── scene │ │ │ │ └── tree.h │ │ ├── pango_glgeometry │ │ │ └── CMakeLists.txt │ │ ├── pango_tools │ │ │ └── CMakeLists.txt │ │ ├── pango_video │ │ │ ├── include │ │ │ │ └── pangolin │ │ │ │ │ └── video │ │ │ │ │ ├── stream_encoder_factory.h │ │ │ │ │ ├── video_exception.h │ │ │ │ │ ├── video_help.h │ │ │ │ │ ├── drivers │ │ │ │ │ └── shared_memory.h │ │ │ │ │ └── video_record_repeat.h │ │ │ ├── tests │ │ │ │ └── tests_video_loading.cpp │ │ │ └── src │ │ │ │ └── video_help.cpp │ │ ├── pango_image │ │ │ ├── src │ │ │ │ └── image_io_raw.cpp │ │ │ └── include │ │ │ │ └── pangolin │ │ │ │ └── image │ │ │ │ └── image_convert.h │ │ ├── pango_vars │ │ │ └── CMakeLists.txt │ │ ├── pango_geometry │ │ │ ├── CMakeLists.txt │ │ │ └── include │ │ │ │ └── pangolin │ │ │ │ └── geometry │ │ │ │ └── geometry_obj.h │ │ ├── pango_packetstream │ │ │ ├── CMakeLists.txt │ │ │ └── src │ │ │ │ └── playback_session.cpp │ │ └── pango_python │ │ │ └── src │ │ │ ├── pypangolin │ │ │ ├── pypangoio.cpp │ │ │ ├── image.cpp │ │ │ ├── gl.hpp │ │ │ ├── glsl.hpp │ │ │ ├── glvbo.hpp │ │ │ ├── colour.hpp │ │ │ ├── display.hpp │ │ │ ├── video.hpp │ │ │ ├── view.hpp │ │ │ ├── attach.hpp │ │ │ ├── datalog.hpp │ │ │ ├── gl_draw.hpp │ │ │ ├── image_view.hpp │ │ │ ├── params.hpp │ │ │ ├── plotter.hpp │ │ │ ├── widget.hpp │ │ │ ├── window.hpp │ │ │ ├── viewport.hpp │ │ │ ├── pixel_format.hpp │ │ │ └── opengl_render_state.hpp │ │ │ ├── pypangolin_embed.cpp │ │ │ └── pypangolin_module.cpp │ ├── cmake │ │ ├── wheel-dist-info │ │ │ ├── top_level.txt │ │ │ ├── WHEEL │ │ │ └── METADATA │ │ ├── CreateMethodCallFile.cmake │ │ ├── FindLz4.cmake │ │ ├── PangolinConfig.cmake.in │ │ ├── FindTooN.cmake │ │ ├── PangolinConfigVersion.cmake.in │ │ ├── FindMediaFoundation.cmake │ │ ├── FindDC1394.cmake │ │ ├── FindOpenEXR.cmake │ │ ├── cmake_uninstall.cmake.in │ │ ├── FindXrandr.cmake │ │ ├── Findzstd.cmake │ │ ├── FindGLUES.cmake │ │ ├── Finduvc.cmake │ │ ├── FindLibraw.cmake │ │ ├── Findlibusb1.cmake │ │ ├── Findpthread.cmake │ │ ├── FindDepthSense.cmake │ │ ├── FindRealSense.cmake │ │ ├── FindRealSense2.cmake │ │ ├── SetPlatformVars.cmake │ │ └── EmscriptenUtils.cmake │ ├── .clang-format │ ├── tools │ │ ├── CMakeLists.txt │ │ ├── ModelViewer │ │ │ ├── CMakeLists.txt │ │ │ └── util.h │ │ ├── Plotter │ │ │ └── application-x-pangoplot.xml │ │ ├── VideoViewer │ │ │ └── application-x-pango.xml │ │ ├── VideoConvert │ │ │ └── CMakeLists.txt │ │ └── VideoJson │ │ │ ├── CMakeLists.txt │ │ │ └── main-print.cpp │ ├── examples │ │ ├── SharedMemoryCamera │ │ │ └── CMakeLists.txt │ │ ├── SimplePlot │ │ │ └── CMakeLists.txt │ │ ├── SimpleScene │ │ │ └── CMakeLists.txt │ │ ├── SimpleVideo │ │ │ └── CMakeLists.txt │ │ ├── SimpleRecord │ │ │ └── CMakeLists.txt │ │ ├── HelloPangolin │ │ │ ├── CMakeLists.txt │ │ │ └── main.cpp │ │ ├── SimpleDisplayImage │ │ │ └── CMakeLists.txt │ │ ├── SimpleMultiDisplay │ │ │ ├── CMakeLists.txt │ │ │ └── app.cfg │ │ ├── SimpleDisplay │ │ │ ├── CMakeLists.txt │ │ │ └── app.cfg │ │ ├── HelloPangolinOffscreen │ │ │ ├── CMakeLists.txt │ │ │ └── main.cpp │ │ ├── HelloPangolinThreads │ │ │ └── CMakeLists.txt │ │ ├── CMakeLists.txt │ │ ├── VBODisplay │ │ │ ├── CMakeLists.txt │ │ │ └── kernal.cu │ │ ├── BasicOpenGL │ │ │ ├── CMakeLists.txt │ │ │ └── 2_gl_intro_pango_triangle_vbo.cpp │ │ └── PythonExamples │ │ │ └── SimplePlot.py │ ├── package.xml │ └── LICENCE └── ceres-solver │ ├── internal │ └── ceres │ │ ├── gmock │ │ └── .clang-format │ │ ├── gtest │ │ └── .clang-format │ │ ├── generated │ │ └── .clang-format │ │ ├── generated_bundle_adjustment_tests │ │ └── .clang-format │ │ └── autodiff_benchmarks │ │ └── CMakeLists.txt │ ├── docs │ └── source │ │ ├── loss.png │ │ ├── slam2d.png │ │ ├── least_squares_fit.png │ │ ├── pose_graph_3d_ex.png │ │ ├── forward_central_error.png │ │ ├── robust_least_squares_fit.png │ │ ├── manhattan_olson_3500_result.png │ │ ├── non_robust_least_squares_fit.png │ │ ├── forward_central_ridders_error.png │ │ ├── tutorial.rst │ │ ├── _templates │ │ └── layout.html │ │ ├── CMakeLists.txt │ │ └── faqs.rst │ ├── data │ ├── libmv-ba-problems │ │ ├── problem_01.bin │ │ ├── problem_02.bin │ │ ├── problem_03.bin │ │ └── Readme.txt │ ├── 2x2.foe │ ├── README.foe │ └── 3x3.foe │ ├── .clang-format │ ├── .gitignore │ ├── travis │ ├── install_travis_linux_deps.sh │ └── install_travis_osx_deps.sh │ ├── CONTRIBUTING.md │ └── README.md ├── .dockerignore ├── .gitignore ├── docker_entrypoint.sh ├── LICENSE ├── src └── util │ ├── StringUtils.h │ └── StringUtils.cpp └── Dockerfile /thirdparty/Sophus/SOPHUS_VERSION: -------------------------------------------------------------------------------- 1 | 1.24.6 -------------------------------------------------------------------------------- /thirdparty/Sophus/sympy/sophus/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /thirdparty/Sophus/sophus_pybind-stubs/py.typed: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /thirdparty/spdlog/.gitattributes: -------------------------------------------------------------------------------- 1 | * text=false 2 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_core/src/dummy.cpp: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/wheel-dist-info/top_level.txt: -------------------------------------------------------------------------------- 1 | @python_module@ 2 | -------------------------------------------------------------------------------- /thirdparty/pangolin/.clang-format: -------------------------------------------------------------------------------- 1 | DisableFormat: true 2 | SortIncludes: false 3 | -------------------------------------------------------------------------------- /thirdparty/Sophus/sympy/cpp_gencode/So2_Dx_log_exp_x_times_this_at_0.cpp: -------------------------------------------------------------------------------- 1 | result = 1; 2 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_windowing/include/pangolin/windowing/X11GlContext.h: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /thirdparty/Sophus/test/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory(core) 2 | add_subdirectory(ceres) 3 | -------------------------------------------------------------------------------- /thirdparty/Sophus/sympy/cpp_gencode/So2_Dx_log_this.cpp: -------------------------------------------------------------------------------- 1 | result = -c[1]/(pow(c[0], 2) + pow(c[1], 2)); 2 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/internal/ceres/gmock/.clang-format: -------------------------------------------------------------------------------- 1 | DisableFormat: true 2 | SortIncludes: false 3 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/internal/ceres/gtest/.clang-format: -------------------------------------------------------------------------------- 1 | DisableFormat: true 2 | SortIncludes: false 3 | -------------------------------------------------------------------------------- /thirdparty/Sophus/sympy/cpp_gencode/So2_Dx_exp_x.cpp: -------------------------------------------------------------------------------- 1 | result[0] = -sin(theta); 2 | result[1] = cos(theta); 3 | -------------------------------------------------------------------------------- /thirdparty/Sophus/sympy/cpp_gencode/So2_Dx_this_mul_exp_x_at_0.cpp: -------------------------------------------------------------------------------- 1 | result[0] = -c[1]; 2 | result[1] = c[0]; 3 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/internal/ceres/generated/.clang-format: -------------------------------------------------------------------------------- 1 | DisableFormat: true 2 | SortIncludes: false 3 | -------------------------------------------------------------------------------- /thirdparty/spdlog/logos/spdlog.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/93won/lightweight_vio/HEAD/thirdparty/spdlog/logos/spdlog.png -------------------------------------------------------------------------------- /thirdparty/ceres-solver/internal/ceres/generated_bundle_adjustment_tests/.clang-format: -------------------------------------------------------------------------------- 1 | DisableFormat: true 2 | SortIncludes: false 3 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_core/include/pangolin/utils/signal_slot.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | -------------------------------------------------------------------------------- /thirdparty/Sophus/sophus_pybind/bindings.cpp: -------------------------------------------------------------------------------- 1 | #include "SophusPyBind.h" 2 | 3 | PYBIND11_MODULE(sophus_pybind, m) { Sophus::exportSophus(m); } 4 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/docs/source/loss.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/93won/lightweight_vio/HEAD/thirdparty/ceres-solver/docs/source/loss.png -------------------------------------------------------------------------------- /thirdparty/ceres-solver/docs/source/slam2d.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/93won/lightweight_vio/HEAD/thirdparty/ceres-solver/docs/source/slam2d.png -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/wheel-dist-info/WHEEL: -------------------------------------------------------------------------------- 1 | Wheel-Version: 1.0 2 | Generator: @wheel_generator_string@ 3 | Root-Is-Purelib: false 4 | Tag: @complete_tag@ 5 | 6 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/docs/source/least_squares_fit.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/93won/lightweight_vio/HEAD/thirdparty/ceres-solver/docs/source/least_squares_fit.png -------------------------------------------------------------------------------- /thirdparty/ceres-solver/docs/source/pose_graph_3d_ex.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/93won/lightweight_vio/HEAD/thirdparty/ceres-solver/docs/source/pose_graph_3d_ex.png -------------------------------------------------------------------------------- /thirdparty/ceres-solver/data/libmv-ba-problems/problem_01.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/93won/lightweight_vio/HEAD/thirdparty/ceres-solver/data/libmv-ba-problems/problem_01.bin -------------------------------------------------------------------------------- /thirdparty/ceres-solver/data/libmv-ba-problems/problem_02.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/93won/lightweight_vio/HEAD/thirdparty/ceres-solver/data/libmv-ba-problems/problem_02.bin -------------------------------------------------------------------------------- /thirdparty/ceres-solver/data/libmv-ba-problems/problem_03.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/93won/lightweight_vio/HEAD/thirdparty/ceres-solver/data/libmv-ba-problems/problem_03.bin -------------------------------------------------------------------------------- /thirdparty/ceres-solver/docs/source/forward_central_error.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/93won/lightweight_vio/HEAD/thirdparty/ceres-solver/docs/source/forward_central_error.png -------------------------------------------------------------------------------- /thirdparty/ceres-solver/docs/source/robust_least_squares_fit.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/93won/lightweight_vio/HEAD/thirdparty/ceres-solver/docs/source/robust_least_squares_fit.png -------------------------------------------------------------------------------- /thirdparty/Sophus/examples/ensure_example.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | int main() { SOPHUS_ENSURE(false, "There is an error. Details: {}", 42); } 6 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/docs/source/manhattan_olson_3500_result.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/93won/lightweight_vio/HEAD/thirdparty/ceres-solver/docs/source/manhattan_olson_3500_result.png -------------------------------------------------------------------------------- /thirdparty/ceres-solver/docs/source/non_robust_least_squares_fit.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/93won/lightweight_vio/HEAD/thirdparty/ceres-solver/docs/source/non_robust_least_squares_fit.png -------------------------------------------------------------------------------- /thirdparty/Sophus/SophusConfig.cmake.in: -------------------------------------------------------------------------------- 1 | @PACKAGE_INIT@ 2 | 3 | include (CMakeFindDependencyMacro) 4 | 5 | @Eigen3_DEPENDENCY@ 6 | 7 | include ("${CMAKE_CURRENT_LIST_DIR}/SophusTargets.cmake") 8 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/docs/source/forward_central_ridders_error.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/93won/lightweight_vio/HEAD/thirdparty/ceres-solver/docs/source/forward_central_ridders_error.png -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_opengl/src/fonts/AnonymousPro.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/93won/lightweight_vio/HEAD/thirdparty/pangolin/components/pango_opengl/src/fonts/AnonymousPro.ttf -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_display/include/pangolin/display/default_font.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace pangolin { 6 | GlFont& default_font(); 7 | } 8 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/docs/source/tutorial.rst: -------------------------------------------------------------------------------- 1 | .. _chapter-tutorial: 2 | 3 | ======== 4 | Tutorial 5 | ======== 6 | 7 | .. toctree:: 8 | :maxdepth: 3 9 | 10 | nnls_tutorial 11 | gradient_tutorial 12 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/.clang-format: -------------------------------------------------------------------------------- 1 | BasedOnStyle: Google 2 | Standard: Cpp11 3 | BinPackArguments: false 4 | BinPackParameters: false 5 | PointerAlignment: Left 6 | DerivePointerAlignment: false 7 | CommentPragmas: NOLINT.* 8 | -------------------------------------------------------------------------------- /thirdparty/pangolin/tools/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory(VideoViewer) 2 | add_subdirectory(VideoConvert) 3 | add_subdirectory(VideoJson) 4 | add_subdirectory(Plotter) 5 | 6 | if(NOT EMSCRIPTEN) 7 | add_subdirectory(ModelViewer) 8 | endif() 9 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/fmt/bundled/core.h: -------------------------------------------------------------------------------- 1 | // This file is only provided for compatibility and may be removed in future 2 | // versions. Use fmt/base.h if you don't need fmt::format and fmt/format.h 3 | // otherwise. 4 | 5 | #include "format.h" 6 | -------------------------------------------------------------------------------- /thirdparty/spdlog/.git-blame-ignore-revs: -------------------------------------------------------------------------------- 1 | # clang-format 2 | 1a0bfc7a89f2d58e22605a4dc7e18a9a555b65aa 3 | 95c226e9c92928e20ccdac0d060e7241859e282b 4 | 9d52261185b5f2c454c381d626ec5c84d7b195f4 5 | 4b2a8219d5d1b40062d030441adde7d1fb0d4f84 6 | 0a53eafe18d983c7c8ba4cadd02d0cc7f7308f28 7 | -------------------------------------------------------------------------------- /thirdparty/Sophus/generate_stubs.py: -------------------------------------------------------------------------------- 1 | import subprocess 2 | 3 | subprocess.run( 4 | "pybind11-stubgen sophus_pybind -o sophus_pybind-stubs/", 5 | shell=True, 6 | check=True, 7 | ) 8 | 9 | subprocess.run("touch sophus_pybind-stubs/py.typed", shell=True, check=True) 10 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/SharedMemoryCamera/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | if(UNIX) 2 | find_package(Pangolin 0.8 REQUIRED) 3 | include_directories(${Pangolin_INCLUDE_DIRS}) 4 | 5 | add_executable(SharedMemoryCamera main.cpp) 6 | target_link_libraries(SharedMemoryCamera pango_display) 7 | endif() 8 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/details/windows_include.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #ifndef NOMINMAX 4 | #define NOMINMAX // prevent windows redefining min/max 5 | #endif 6 | 7 | #ifndef WIN32_LEAN_AND_MEAN 8 | #define WIN32_LEAN_AND_MEAN 9 | #endif 10 | 11 | #include 12 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/SimplePlot/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Find Pangolin (https://github.com/stevenlovegrove/Pangolin) 2 | find_package(Pangolin 0.8 REQUIRED) 3 | include_directories(${Pangolin_INCLUDE_DIRS}) 4 | 5 | add_executable(SimplePlot main.cpp) 6 | target_link_libraries(SimplePlot pango_display pango_plot) 7 | -------------------------------------------------------------------------------- /thirdparty/pangolin/tools/ModelViewer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Find Pangolin (https://github.com/stevenlovegrove/Pangolin) 2 | find_package(Pangolin 0.3 REQUIRED) 3 | include_directories(${Pangolin_INCLUDE_DIRS}) 4 | 5 | add_executable(ModelViewer main.cpp) 6 | target_link_libraries(ModelViewer ${Pangolin_LIBRARIES}) 7 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/SimpleScene/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Find Pangolin (https://github.com/stevenlovegrove/Pangolin) 2 | find_package(Pangolin 0.8 REQUIRED) 3 | include_directories(${Pangolin_INCLUDE_DIRS}) 4 | 5 | add_executable(SimpleScene main.cpp) 6 | target_link_libraries(SimpleScene pango_display pango_scene) 7 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/SimpleVideo/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Find Pangolin (https://github.com/stevenlovegrove/Pangolin) 2 | find_package(Pangolin 0.8 REQUIRED) 3 | include_directories(${Pangolin_INCLUDE_DIRS}) 4 | 5 | add_executable(SimpleVideo main.cpp) 6 | target_link_libraries(SimpleVideo pango_display pango_video) 7 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/SimpleRecord/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Find Pangolin (https://github.com/stevenlovegrove/Pangolin) 2 | find_package(Pangolin 0.8 REQUIRED) 3 | include_directories(${Pangolin_INCLUDE_DIRS}) 4 | 5 | add_executable(SimpleRecord main.cpp) 6 | target_link_libraries(SimpleRecord pango_display pango_video) 7 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/HelloPangolin/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Find Pangolin (https://github.com/stevenlovegrove/Pangolin) 2 | find_package(Pangolin 0.8 REQUIRED) 3 | include_directories(${Pangolin_INCLUDE_DIRS}) 4 | 5 | add_executable(HelloPangolin main.cpp) 6 | target_link_libraries(HelloPangolin pango_display pango_python) 7 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/SimpleDisplayImage/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Find Pangolin (https://github.com/stevenlovegrove/Pangolin) 2 | find_package(Pangolin 0.8 REQUIRED) 3 | include_directories(${Pangolin_INCLUDE_DIRS}) 4 | 5 | add_executable(SimpleDisplayImage main.cpp) 6 | target_link_libraries(SimpleDisplayImage pango_display) 7 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/SimpleMultiDisplay/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Find Pangolin (https://github.com/stevenlovegrove/Pangolin) 2 | find_package(Pangolin 0.8 REQUIRED) 3 | include_directories(${Pangolin_INCLUDE_DIRS}) 4 | 5 | add_executable(SimpleMultiDisplay main.cpp) 6 | target_link_libraries(SimpleMultiDisplay pango_display) 7 | -------------------------------------------------------------------------------- /thirdparty/spdlog/scripts/ci_setup_clang.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | set -ex 4 | 5 | VERSION=$1 6 | 7 | apt-get update 8 | apt-get install -y libc++-${VERSION}-dev libc++abi-${VERSION}-dev 9 | 10 | if [[ "${VERSION}" -ge 12 ]]; then 11 | apt-get install -y --no-install-recommends libunwind-${VERSION}-dev 12 | fi 13 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_plot/include/pangolin/plot/loaders/table_loader.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | namespace pangolin { 6 | 7 | struct TableLoaderInterface 8 | { 9 | virtual bool ReadRow(std::vector& row) = 0; 10 | }; 11 | 12 | } 13 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/SimpleDisplay/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Find Pangolin (https://github.com/stevenlovegrove/Pangolin) 2 | find_package(Pangolin 0.8 REQUIRED) 3 | include_directories(${Pangolin_INCLUDE_DIRS}) 4 | 5 | add_executable(SimpleDisplay main.cpp) 6 | target_link_libraries(SimpleDisplay pango_display pango_python ) 7 | 8 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/HelloPangolinOffscreen/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Find Pangolin (https://github.com/stevenlovegrove/Pangolin) 2 | find_package(Pangolin 0.5 REQUIRED) 3 | include_directories(${Pangolin_INCLUDE_DIRS}) 4 | 5 | add_executable(HelloPangolinOffscreen main.cpp) 6 | target_link_libraries(HelloPangolinOffscreen pango_display) 7 | -------------------------------------------------------------------------------- /thirdparty/spdlog/src/cfg.cpp: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #ifndef SPDLOG_COMPILED_LIB 5 | #error Please define SPDLOG_COMPILED_LIB to compile this file. 6 | #endif 7 | 8 | #include 9 | -------------------------------------------------------------------------------- /thirdparty/Sophus/sympy/cpp_gencode/Se2_Dx_this_mul_exp_x_at_0.cpp: -------------------------------------------------------------------------------- 1 | Scalar const c0 = -c[1]; 2 | result[0] = 0; 3 | result[1] = 0; 4 | result[2] = c0; 5 | result[3] = 0; 6 | result[4] = 0; 7 | result[5] = c[0]; 8 | result[6] = c[0]; 9 | result[7] = c0; 10 | result[8] = 0; 11 | result[9] = c[1]; 12 | result[10] = c[0]; 13 | result[11] = 0; 14 | -------------------------------------------------------------------------------- /.dockerignore: -------------------------------------------------------------------------------- 1 | # Docker ignore file for lightweight VIO 2 | # Ignore build artifacts 3 | build/ 4 | **/build/ 5 | 6 | # Ignore IDE files 7 | .vscode/ 8 | .idea/ 9 | *.swp 10 | *.swo 11 | *~ 12 | 13 | # Ignore git files 14 | .git/ 15 | .gitignore 16 | 17 | # Ignore log files 18 | *.log 19 | 20 | # Ignore temporary files 21 | *.tmp 22 | *.temp 23 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_core/src/factory/factory_registry.cpp: -------------------------------------------------------------------------------- 1 | #include "pangolin/factory/factory_registry.h" 2 | 3 | namespace pangolin { 4 | 5 | std::shared_ptr FactoryRegistry::I() 6 | { 7 | static std::shared_ptr registry(new FactoryRegistry()); 8 | return registry; 9 | } 10 | 11 | } 12 | -------------------------------------------------------------------------------- /thirdparty/spdlog/tests/main.cpp: -------------------------------------------------------------------------------- 1 | #if defined(__GNUC__) && __GNUC__ == 12 2 | #pragma GCC diagnostic push 3 | #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // Workaround for GCC 12 4 | #endif 5 | 6 | #include 7 | 8 | #if defined(__GNUC__) && __GNUC__ == 12 9 | #pragma GCC diagnostic pop 10 | #endif 11 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/data/libmv-ba-problems/Readme.txt: -------------------------------------------------------------------------------- 1 | Problem files are created from Tears of Steel production files. 2 | 3 | - problem_01.bin is a final camera motion refinement step of 07_1a scene. 4 | - problem_02.bin is a final camera motion refinement step of 03_2a scene. 5 | - problem_03.bin is a final camera motion refinement step of 09_1a scene. 6 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/data/2x2.foe: -------------------------------------------------------------------------------- 1 | 2 3 2 | 0 1 0 1 3 | 0 0 1 1 4 | 0.586612685392731 1.157638405566669 0.846059486257292 5 | -0.0582774013402734 0.0339010363051084 -0.0501593018104054 0.0745568557931712 6 | 0.0492112815304123 -0.0307820846538285 -0.123247230948424 0.104812330861557 7 | 0.0562633568728865 0.0152832583489560 -0.0576215592718086 -0.0139673758425540 8 | 9 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Build directories 2 | build/ 3 | bin/ 4 | lib/ 5 | 6 | # IDE files 7 | .vscode/ 8 | .idea/ 9 | *.swp 10 | *.swo 11 | 12 | # ImGui configuration 13 | imgui.ini 14 | 15 | # Compiled objects 16 | *.o 17 | *.so 18 | *.a 19 | 20 | # CMake generated files 21 | CMakeCache.txt 22 | CMakeFiles/ 23 | cmake_install.cmake 24 | Makefile 25 | 26 | # Datasets 27 | datasets/ 28 | -------------------------------------------------------------------------------- /thirdparty/Sophus/sympy/run_tests.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | EXIT=0 4 | 5 | python3 -m sophus.complex || EXIT=$? 6 | python3 -m sophus.quaternion || EXIT=$? 7 | python3 -m sophus.dual_quaternion || EXIT=$? 8 | python3 -m sophus.so2 || EXIT=$? 9 | python3 -m sophus.se2 || EXIT=$? 10 | python3 -m sophus.so3 || EXIT=$? 11 | python3 -m sophus.se3 || EXIT=$? 12 | 13 | exit $EXIT 14 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/.gitignore: -------------------------------------------------------------------------------- 1 | *~ 2 | .*.swp 3 | CMakeLists.txt.user* 4 | *.kdev* 5 | *.bak 6 | *.orig 7 | build/ 8 | build-release/ 9 | build-debug/ 10 | docs/html 11 | *.aux 12 | *.blg 13 | *.toc 14 | *.fdb_latexmk 15 | *.bbl 16 | *.log 17 | *.synctex.gz 18 | ceres.pdf 19 | ceres-solver.pdf 20 | docs/minted.sty 21 | obj/ 22 | jni/libs/ 23 | .buildinfo 24 | bazel-* 25 | *.pyc 26 | -------------------------------------------------------------------------------- /thirdparty/Sophus/scripts/run_cpp_tests_gcc.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | set -x # echo on 4 | set -e # exit on error 5 | 6 | mkdir build 7 | cd build 8 | pwd 9 | cmake -DCMAKE_CXX_COMPILER=g++ -DCMAKE_COMPILE_WARNING_AS_ERROR=On -DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER_LAUNCHER=ccache .. 10 | # Ubuntu builds via Github actions run on 2-core virtual machines 11 | make -j2 12 | ctest --output-on-failure 13 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/wheel-dist-info/METADATA: -------------------------------------------------------------------------------- 1 | Metadata-Version: 2.1 2 | Name: @python_module@ 3 | Version: @MAKEWHEEL_VERSION@ 4 | Summary: @MAKEWHEEL_SUMMARY@ 5 | Home-page: @MAKEWHEEL_HOMEPAGE@ 6 | Author: @MAKEWHEEL_AUTHOR@ 7 | Author-email: @MAKEWHEEL_EMAIL@ 8 | License: @MAKEWHEEL_LICENCE@ 9 | Description-Content-Type: text/markdown 10 | @MAKEWHEEL_REQUIRES@ 11 | 12 | @MAKEWHEEL_DESCRIPTION@ 13 | -------------------------------------------------------------------------------- /thirdparty/Sophus/scripts/run_cpp_tests_clang.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | set -x # echo on 4 | set -e # exit on error 5 | 6 | mkdir build 7 | cd build 8 | pwd 9 | cmake -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_COMPILER=clang -DCMAKE_COMPILE_WARNING_AS_ERROR=On -DCMAKE_CXX_COMPILER_LAUNCHER=ccache .. 10 | # Ubuntu builds via Github actions run on 2-core virtual machines 11 | make -j2 12 | ctest --output-on-failure 13 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/travis/install_travis_linux_deps.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Stop processing on any error. 4 | set -e 5 | 6 | # Install default versions of standard dependencies that are new enough in 18.04 7 | sudo apt-get install -y cmake 8 | sudo apt-get install -y libatlas-base-dev libsuitesparse-dev 9 | sudo apt-get install -y libgoogle-glog-dev libgflags-dev 10 | sudo apt-get install -y libeigen3-dev 11 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/fwd.h: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #pragma once 5 | 6 | namespace spdlog { 7 | class logger; 8 | class formatter; 9 | 10 | namespace sinks { 11 | class sink; 12 | } 13 | 14 | namespace level { 15 | enum level_enum : int; 16 | } 17 | 18 | } // namespace spdlog 19 | -------------------------------------------------------------------------------- /thirdparty/pangolin/tools/Plotter/application-x-pangoplot.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | Pangolin Video File 5 | 6 | 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /thirdparty/spdlog/cmake/spdlog.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@CMAKE_INSTALL_PREFIX@ 2 | exec_prefix=${prefix} 3 | includedir=@PKG_CONFIG_INCLUDEDIR@ 4 | libdir=@PKG_CONFIG_LIBDIR@ 5 | 6 | Name: lib@PROJECT_NAME@ 7 | Description: Fast C++ logging library. 8 | URL: https://github.com/gabime/@PROJECT_NAME@ 9 | Version: @SPDLOG_VERSION@ 10 | CFlags: -I${includedir} @PKG_CONFIG_DEFINES@ 11 | Libs: -L${libdir} -lspdlog -pthread 12 | Requires: @PKG_CONFIG_REQUIRES@ 13 | 14 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/HelloPangolinThreads/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Find Pangolin (https://github.com/stevenlovegrove/Pangolin) 2 | find_package(Pangolin 0.5 REQUIRED) 3 | find_package(Threads QUIET) 4 | 5 | if(Theads_FOUND) 6 | add_executable(HelloPangolinThreads main.cpp) 7 | target_include_directories(HelloPangolinThreads ${Pangolin_INCLUDE_DIRS}) 8 | target_link_libraries(HelloPangolinThreads pango_display Threads::Threads) 9 | endif() 10 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_windowing/src/window.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | namespace pangolin 6 | { 7 | 8 | std::unique_ptr ConstructWindow(const Uri& uri) 9 | { 10 | RegisterFactoriesWindowInterface(); 11 | return FactoryRegistry::I()->Construct(uri); 12 | } 13 | 14 | } 15 | -------------------------------------------------------------------------------- /thirdparty/pangolin/tools/VideoViewer/application-x-pango.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | Pangolin Video File 5 | 6 | 7 | 8 | 9 | 10 | 11 | -------------------------------------------------------------------------------- /thirdparty/spdlog/src/async.cpp: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #ifndef SPDLOG_COMPILED_LIB 5 | #error Please define SPDLOG_COMPILED_LIB to compile this file. 6 | #endif 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/tinyobj/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(COMPONENT tinyobj) 2 | 3 | target_sources( ${COMPONENT} PRIVATE "${CMAKE_CURRENT_LIST_DIR}/src/tinyobj.cpp") 4 | set_property(TARGET ${COMPONENT} PROPERTY CXX_STANDARD 11) 5 | target_include_directories(${COMPONENT} PUBLIC 6 | $ 7 | $ 8 | ) 9 | install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/include" 10 | DESTINATION ${CMAKE_INSTALL_PREFIX} 11 | ) 12 | -------------------------------------------------------------------------------- /thirdparty/Sophus/examples/custom_ensure_handler.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | #include 5 | 6 | namespace Sophus { 7 | void ensureFailed(char const* function, char const* file, int line, 8 | char const* description) { 9 | std::printf("Sophus ensure failed in function '%s', file '%s', line %d.\n", 10 | file, function, line); 11 | throw std::runtime_error("Sophus ensure failed"); 12 | } 13 | } // namespace Sophus 14 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/version.h: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #pragma once 5 | 6 | #define SPDLOG_VER_MAJOR 1 7 | #define SPDLOG_VER_MINOR 15 8 | #define SPDLOG_VER_PATCH 3 9 | 10 | #define SPDLOG_TO_VERSION(major, minor, patch) (major * 10000 + minor * 100 + patch) 11 | #define SPDLOG_VERSION SPDLOG_TO_VERSION(SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH) 12 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory(BasicOpenGL) 2 | 3 | add_subdirectory(HelloPangolin) 4 | add_subdirectory(HelloPangolinThreads) 5 | add_subdirectory(SimpleDisplay) 6 | add_subdirectory(SimpleMultiDisplay) 7 | add_subdirectory(SimpleDisplayImage) 8 | add_subdirectory(SimplePlot) 9 | add_subdirectory(SimpleVideo) 10 | add_subdirectory(SimpleRecord) 11 | 12 | if(NOT EMSCRIPTEN) 13 | add_subdirectory(HelloPangolinOffscreen) 14 | add_subdirectory(SimpleScene) 15 | endif() 16 | -------------------------------------------------------------------------------- /thirdparty/Sophus/sympy/cpp_gencode/So3_Dx_this_mul_exp_x_at_0.cpp: -------------------------------------------------------------------------------- 1 | Scalar const c0 = 0.5*q.w(); 2 | Scalar const c1 = 0.5*q.z(); 3 | Scalar const c2 = -c1; 4 | Scalar const c3 = 0.5*q.y(); 5 | Scalar const c4 = 0.5*q.x(); 6 | Scalar const c5 = -c4; 7 | Scalar const c6 = -c3; 8 | result[0] = c0; 9 | result[1] = c2; 10 | result[2] = c3; 11 | result[3] = c1; 12 | result[4] = c0; 13 | result[5] = c5; 14 | result[6] = c6; 15 | result[7] = c4; 16 | result[8] = c0; 17 | result[9] = c5; 18 | result[10] = c6; 19 | result[11] = c2; 20 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_display/src/default_font.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "pangolin_gl.h" 4 | 5 | extern const unsigned char AnonymousPro_ttf[]; 6 | 7 | namespace pangolin { 8 | 9 | GlFont& default_font() 10 | { 11 | PangolinGl* context = GetCurrentContext(); 12 | PANGO_ASSERT(context); 13 | if(!context->font) { 14 | context->font = std::make_shared(AnonymousPro_ttf, 18); 15 | } 16 | return *(context->font.get()); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | --------------------------------- 2 | Do not make GitHub pull requests! 3 | --------------------------------- 4 | 5 | Ceres development happens on 6 | [Gerrit](https://ceres-solver.googlesource.com/), including both 7 | repository hosting and code reviews. 8 | 9 | This GitHub Repository is a continuously updated mirror which is 10 | primarily meant for issue tracking. 11 | 12 | Please see our 13 | [Contributing to Ceres Guide](http://ceres-solver.org/contributing.html) 14 | for more details. 15 | -------------------------------------------------------------------------------- /thirdparty/spdlog/.clang-format: -------------------------------------------------------------------------------- 1 | --- 2 | Language: Cpp 3 | BasedOnStyle: Google 4 | AccessModifierOffset: -4 5 | Standard: c++17 6 | IndentWidth: 4 7 | TabWidth: 4 8 | UseTab: Never 9 | ColumnLimit: 100 10 | AlignAfterOpenBracket: Align 11 | BinPackParameters: false 12 | AlignEscapedNewlines: Left 13 | AlwaysBreakTemplateDeclarations: Yes 14 | PackConstructorInitializers: Never 15 | BreakConstructorInitializersBeforeComma: false 16 | IndentPPDirectives: BeforeHash 17 | SortIncludes: Never 18 | ... 19 | 20 | -------------------------------------------------------------------------------- /thirdparty/spdlog/tests/utils.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | std::size_t count_files(const std::string &folder); 7 | 8 | void prepare_logdir(); 9 | 10 | std::string file_contents(const std::string &filename); 11 | 12 | std::size_t count_lines(const std::string &filename); 13 | 14 | void require_message_count(const std::string &filename, const std::size_t messages); 15 | 16 | std::size_t get_filesize(const std::string &filename); 17 | 18 | bool ends_with(std::string const &value, std::string const &ending); -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_scene/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME) 2 | 3 | target_sources( ${COMPONENT} 4 | PRIVATE 5 | ${CMAKE_CURRENT_LIST_DIR}/src/renderable.cpp 6 | ) 7 | 8 | target_link_libraries(${COMPONENT} PUBLIC pango_opengl) 9 | target_include_directories(${COMPONENT} PUBLIC 10 | $ 11 | $ 12 | ) 13 | install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/include" 14 | DESTINATION ${CMAKE_INSTALL_PREFIX} 15 | ) 16 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_glgeometry/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME) 2 | 3 | target_sources( ${COMPONENT} 4 | PRIVATE 5 | ${CMAKE_CURRENT_LIST_DIR}/src/glgeometry.cpp 6 | ) 7 | 8 | target_link_libraries(${COMPONENT} pango_geometry pango_opengl) 9 | target_include_directories(${COMPONENT} PUBLIC 10 | $ 11 | $ 12 | ) 13 | install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/include" 14 | DESTINATION ${CMAKE_INSTALL_PREFIX} 15 | ) 16 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_tools/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME) 2 | 3 | target_sources( ${COMPONENT} 4 | PRIVATE 5 | ${CMAKE_CURRENT_LIST_DIR}/src/video_viewer.cpp 6 | ) 7 | 8 | target_link_libraries(${COMPONENT} PUBLIC pango_display pango_video) 9 | target_include_directories(${COMPONENT} PUBLIC 10 | $ 11 | $ 12 | ) 13 | install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/include" 14 | DESTINATION ${CMAKE_INSTALL_PREFIX} 15 | ) 16 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/formatter.h: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #pragma once 5 | 6 | #include 7 | #include 8 | 9 | namespace spdlog { 10 | 11 | class formatter { 12 | public: 13 | virtual ~formatter() = default; 14 | virtual void format(const details::log_msg &msg, memory_buf_t &dest) = 0; 15 | virtual std::unique_ptr clone() const = 0; 16 | }; 17 | } // namespace spdlog 18 | -------------------------------------------------------------------------------- /thirdparty/Sophus/sympy/sophus/cse_codegen.py: -------------------------------------------------------------------------------- 1 | import io 2 | 3 | import sympy 4 | 5 | 6 | def cse_codegen(symbols): 7 | cse_results = sympy.cse(symbols, sympy.numbered_symbols("c")) 8 | output = io.StringIO() 9 | for helper in cse_results[0]: 10 | output.write("Scalar const ") 11 | output.write(sympy.printing.ccode(helper[1], helper[0])) 12 | output.write("\n") 13 | assert len(cse_results[1]) == 1 14 | 15 | output.write(sympy.printing.ccode(cse_results[1][0], "result")) 16 | output.write("\n") 17 | output.seek(0) 18 | return output 19 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/data/README.foe: -------------------------------------------------------------------------------- 1 | The *.foe files contain coefficients provided by Stefan Roth, who agreed to 2 | release them under a BSD license. See his home page: 3 | 4 | http://www.gris.informatik.tu-darmstadt.de/~sroth/research/foe/index.html 5 | 6 | The coefficients in the *.foe files have been obtained by extracting the 7 | matrices from the MATLAB files and performing matrix multiplication. 8 | 9 | The format of the files is ASCII: 10 | 11 | ... 12 | ... 13 | ... 14 | ... 15 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/docs/source/_templates/layout.html: -------------------------------------------------------------------------------- 1 | {% extends "!layout.html" %} 2 | 3 | {% block footer %} 4 | {{ super() }} 5 | 13 | {% endblock %} 14 | -------------------------------------------------------------------------------- /thirdparty/pangolin/tools/VideoConvert/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Find Pangolin (https://github.com/stevenlovegrove/Pangolin) 2 | find_package(Pangolin 0.8 REQUIRED) 3 | include_directories(${Pangolin_INCLUDE_DIRS}) 4 | 5 | add_executable(VideoConvert main.cpp) 6 | target_link_libraries(VideoConvert ${Pangolin_LIBRARIES}) 7 | 8 | ####################################################### 9 | ## Install 10 | 11 | install(TARGETS VideoConvert 12 | RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin 13 | LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/lib 14 | ARCHIVE DESTINATION ${CMAKE_INSTALL_PREFIX}/lib 15 | ) 16 | -------------------------------------------------------------------------------- /thirdparty/spdlog/scripts/extract_version.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | import os 4 | import re 5 | 6 | base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) 7 | config_h = os.path.join(base_path, 'include', 'spdlog', 'version.h') 8 | data = {'MAJOR': 0, 'MINOR': 0, 'PATCH': 0} 9 | reg = re.compile(r'^\s*#define\s+SPDLOG_VER_([A-Z]+)\s+([0-9]+).*$') 10 | 11 | with open(config_h, 'r') as fp: 12 | for l in fp: 13 | m = reg.match(l) 14 | if m: 15 | data[m.group(1)] = int(m.group(2)) 16 | 17 | print(f"{data['MAJOR']}.{data['MINOR']}.{data['PATCH']}") 18 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_core/include/dynalo/detail/config.hpp: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #if defined(__linux__) || defined(__linux) || defined(linux) || defined(_LINUX) 4 | #define DYNALO_HAS_LINUX 5 | #elif defined(_WIN32) || defined(_WIN64) 6 | #define DYNALO_HAS_WINDOWS 7 | #elif defined(__APPLE__) 8 | #define DYNALO_HAS_MACOS 9 | #else 10 | #error "dynalo/detail/config.hpp OS Not Supported" 11 | #endif 12 | 13 | #define DYNALO_VERSION_MAJOR 1 14 | #define DYNALO_VERSION_MINOR 0 15 | #define DYNALO_VERSION_PATCH 3 16 | #define DYNALO_VERSION 0x010003 /**< major minor patch*/ 17 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/CreateMethodCallFile.cmake: -------------------------------------------------------------------------------- 1 | macro( CreateMethodCallFile filename namespace function symbols) 2 | file(WRITE ${filename} "// CMake generated file. Do Not Edit.\n\n#pragma once\n\nnamespace ${namespace} {\n\n") 3 | foreach( symbol ${symbols} ) 4 | file(APPEND ${filename} "void ${symbol}();\n") 5 | endforeach() 6 | file(APPEND ${filename} "\ninline bool ${function}()\n{\n") 7 | foreach( symbol ${symbols} ) 8 | file(APPEND ${filename} " ${symbol}();\n") 9 | endforeach() 10 | file(APPEND ${filename} " return true;\n}\n\n} // ${namespace}\n") 11 | endmacro() 12 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/VBODisplay/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Find Pangolin (https://github.com/stevenlovegrove/Pangolin) 2 | find_package(Pangolin 0.8 REQUIRED) 3 | include_directories(${Pangolin_INCLUDE_DIRS}) 4 | link_directories(${Pangolin_LIBRARY_DIRS}) 5 | link_libraries(${Pangolin_LIBRARIES}) 6 | 7 | find_package(CUDA QUIET) 8 | 9 | # This example could be made to work with C++11, but the kernel code must be 10 | # compiled without it. 11 | if(CUDA_FOUND) 12 | cuda_include_directories(${CMAKE_CURRENT_SOURCE_DIR}) 13 | 14 | cuda_add_executable( 15 | VBODisplay 16 | main.cpp kernal.cu 17 | ) 18 | 19 | endif() 20 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/FindLz4.cmake: -------------------------------------------------------------------------------- 1 | 2 | find_path(Lz4_INCLUDE_DIRS 3 | NAMES lz4frame.h 4 | PATHS 5 | /opt/local/include 6 | /usr/local/include 7 | /usr/include 8 | ) 9 | 10 | find_library(Lz4_LIBRARIES 11 | NAMES lz4 12 | PATHS 13 | /usr/local/lib 14 | /opt/local/lib 15 | /user/local/lib 16 | /usr/lib 17 | ) 18 | 19 | include(FindPackageHandleStandardArgs) 20 | find_package_handle_standard_args(Lz4 REQUIRED_VARS Lz4_LIBRARIES Lz4_INCLUDE_DIRS) 21 | 22 | mark_as_advanced( 23 | Lz4_INCLUDE_DIRS 24 | Lz4_LIBRARIES 25 | Lz4_FOUND 26 | ) 27 | -------------------------------------------------------------------------------- /thirdparty/pangolin/package.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | pangolin 5 | 0.7.0 6 | pangolin 7 | Steven Lovegrove 8 | Steven Lovegrove 9 | MIT 10 | cmake 11 | libglew-dev 12 | cmake 13 | python3-dev 14 | 15 | cmake 16 | 17 | 18 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/PangolinConfig.cmake.in: -------------------------------------------------------------------------------- 1 | # Compute paths 2 | get_filename_component( PROJECT_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH ) 3 | 4 | # Library dependencies (contains definitions for IMPORTED targets) 5 | if( NOT @PROJECT_NAME@_BINARY_DIR ) 6 | include( "${PROJECT_CMAKE_DIR}/@PROJECT_NAME@Targets.cmake" ) 7 | endif() 8 | 9 | SET( Pangolin_CMAKEMODULES @CMAKE_CURRENT_SOURCE_DIR@/cmake ) 10 | SET( Pangolin_LIBRARIES @component_list@ ) 11 | SET( Pangolin_LIBRARY "${Pangolin_LIBRARIES}" ) 12 | 13 | include(CMakeFindDependencyMacro) 14 | find_dependency(Eigen3) 15 | 16 | if (UNIX) 17 | find_dependency(Threads) 18 | endif() 19 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_core/include/pangolin/utils/posix/semaphore.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | 7 | namespace pangolin 8 | { 9 | 10 | class SemaphoreInterface 11 | { 12 | public: 13 | 14 | virtual ~SemaphoreInterface() { 15 | } 16 | 17 | virtual bool tryAcquire() = 0; 18 | virtual void acquire() = 0; 19 | virtual void release() = 0; 20 | }; 21 | 22 | std::shared_ptr create_named_semaphore(const std::string& name, 23 | unsigned int value); 24 | std::shared_ptr open_named_semaphore(const std::string& name); 25 | 26 | } 27 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_plot/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME) 2 | 3 | target_sources( ${COMPONENT} 4 | PRIVATE 5 | ${CMAKE_CURRENT_LIST_DIR}/src/datalog.cpp 6 | ${CMAKE_CURRENT_LIST_DIR}/src/plotter.cpp 7 | ${CMAKE_CURRENT_LIST_DIR}/src/loaders/csv_table_loader.cpp 8 | ) 9 | 10 | target_link_libraries(${COMPONENT} pango_display) 11 | target_include_directories(${COMPONENT} PUBLIC 12 | $ 13 | $ 14 | ) 15 | install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/include" 16 | DESTINATION ${CMAKE_INSTALL_PREFIX} 17 | ) 18 | -------------------------------------------------------------------------------- /thirdparty/spdlog/cmake/spdlogConfig.cmake.in: -------------------------------------------------------------------------------- 1 | # Copyright(c) 2019 spdlog authors 2 | # Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | @PACKAGE_INIT@ 5 | 6 | find_package(Threads REQUIRED) 7 | 8 | set(SPDLOG_FMT_EXTERNAL @SPDLOG_FMT_EXTERNAL@) 9 | set(SPDLOG_FMT_EXTERNAL_HO @SPDLOG_FMT_EXTERNAL_HO@) 10 | set(config_targets_file @config_targets_file@) 11 | 12 | if(SPDLOG_FMT_EXTERNAL OR SPDLOG_FMT_EXTERNAL_HO) 13 | include(CMakeFindDependencyMacro) 14 | find_dependency(fmt CONFIG) 15 | endif() 16 | 17 | 18 | include("${CMAKE_CURRENT_LIST_DIR}/${config_targets_file}") 19 | 20 | check_required_components(spdlog) 21 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/SimpleDisplay/app.cfg: -------------------------------------------------------------------------------- 1 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 2 | % Pangolin Sample configuration file 3 | % Comments start with '%' or '#' 4 | % 5 | % Declarations are name value pairs, 6 | % seperated with '=' and terminated with ';' 7 | 8 | % We can set any variable referenced in code directly 9 | ui.A Double = 3.2; 10 | ui.A Checkbox = false; 11 | 12 | % We can set unreferenced variables too 13 | a.b = 1; 14 | a.c = 2; 15 | z.b = 3; 16 | z.c = 4; 17 | start = z; 18 | 19 | % Which we might refer to by reference 20 | ui.An Int = ${${start}.c}; 21 | 22 | % Declarations can span multiple lines 23 | M = 24 | [1, 0, 0 25 | 0, 1, 0 26 | 0, 0, 1]; 27 | -------------------------------------------------------------------------------- /thirdparty/spdlog/tests/test_systemd.cpp: -------------------------------------------------------------------------------- 1 | #include "includes.h" 2 | #include "spdlog/sinks/systemd_sink.h" 3 | 4 | TEST_CASE("systemd", "[all]") { 5 | auto systemd_sink = std::make_shared(); 6 | spdlog::logger logger("spdlog_systemd_test", systemd_sink); 7 | logger.set_level(spdlog::level::trace); 8 | logger.trace("test spdlog trace"); 9 | logger.debug("test spdlog debug"); 10 | SPDLOG_LOGGER_INFO((&logger), "test spdlog info"); 11 | SPDLOG_LOGGER_WARN((&logger), "test spdlog warn"); 12 | SPDLOG_LOGGER_ERROR((&logger), "test spdlog error"); 13 | SPDLOG_LOGGER_CRITICAL((&logger), "test spdlog critical"); 14 | } 15 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/fmt/xchar.h: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright(c) 2016 Gabi Melman. 3 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 4 | // 5 | 6 | #pragma once 7 | // 8 | // include bundled or external copy of fmtlib's xchar support 9 | // 10 | #include 11 | 12 | #if !defined(SPDLOG_USE_STD_FORMAT) 13 | #if !defined(SPDLOG_FMT_EXTERNAL) 14 | #ifdef SPDLOG_HEADER_ONLY 15 | #ifndef FMT_HEADER_ONLY 16 | #define FMT_HEADER_ONLY 17 | #endif 18 | #endif 19 | #include 20 | #else 21 | #include 22 | #endif 23 | #endif 24 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/fmt/chrono.h: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright(c) 2016 Gabi Melman. 3 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 4 | // 5 | 6 | #pragma once 7 | // 8 | // include bundled or external copy of fmtlib's chrono support 9 | // 10 | #include 11 | 12 | #if !defined(SPDLOG_USE_STD_FORMAT) 13 | #if !defined(SPDLOG_FMT_EXTERNAL) 14 | #ifdef SPDLOG_HEADER_ONLY 15 | #ifndef FMT_HEADER_ONLY 16 | #define FMT_HEADER_ONLY 17 | #endif 18 | #endif 19 | #include 20 | #else 21 | #include 22 | #endif 23 | #endif 24 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/fmt/ostr.h: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright(c) 2016 Gabi Melman. 3 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 4 | // 5 | 6 | #pragma once 7 | // 8 | // include bundled or external copy of fmtlib's ostream support 9 | // 10 | #include 11 | 12 | #if !defined(SPDLOG_USE_STD_FORMAT) 13 | #if !defined(SPDLOG_FMT_EXTERNAL) 14 | #ifdef SPDLOG_HEADER_ONLY 15 | #ifndef FMT_HEADER_ONLY 16 | #define FMT_HEADER_ONLY 17 | #endif 18 | #endif 19 | #include 20 | #else 21 | #include 22 | #endif 23 | #endif 24 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/fmt/ranges.h: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright(c) 2016 Gabi Melman. 3 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 4 | // 5 | 6 | #pragma once 7 | // 8 | // include bundled or external copy of fmtlib's ranges support 9 | // 10 | #include 11 | 12 | #if !defined(SPDLOG_USE_STD_FORMAT) 13 | #if !defined(SPDLOG_FMT_EXTERNAL) 14 | #ifdef SPDLOG_HEADER_ONLY 15 | #ifndef FMT_HEADER_ONLY 16 | #define FMT_HEADER_ONLY 17 | #endif 18 | #endif 19 | #include 20 | #else 21 | #include 22 | #endif 23 | #endif 24 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/FindTooN.cmake: -------------------------------------------------------------------------------- 1 | # - Try to find libTooN 2 | # 3 | # TooN_FOUND - system has libTooN 4 | # TooN_INCLUDE_DIR - the libTooN include directories 5 | 6 | FIND_PATH( 7 | TooN_INCLUDE_DIR 8 | NAMES TooN/TooN.h 9 | PATHS 10 | ${CMAKE_SOURCE_DIR} 11 | ${CMAKE_SOURCE_DIR}/.. 12 | /usr/include 13 | /usr/local/include 14 | ) 15 | 16 | IF(TooN_INCLUDE_DIR) 17 | SET(TooN_FOUND TRUE) 18 | ENDIF() 19 | 20 | IF(TooN_FOUND) 21 | IF(NOT TooN_FIND_QUIETLY) 22 | MESSAGE(STATUS "Found TooN: ${TooN_INCLUDE_DIR}") 23 | ENDIF() 24 | ELSE() 25 | IF(TooN_FIND_REQUIRED) 26 | MESSAGE(FATAL_ERROR "Could not find TooN") 27 | ENDIF() 28 | ENDIF() 29 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_video/include/pangolin/video/stream_encoder_factory.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | 7 | namespace pangolin { 8 | 9 | using ImageEncoderFunc = std::function&)>; 10 | using ImageDecoderFunc = std::function; 11 | 12 | class StreamEncoderFactory 13 | { 14 | public: 15 | static StreamEncoderFactory& I(); 16 | 17 | ImageEncoderFunc GetEncoder(const std::string& encoder_spec, const PixelFormat& fmt); 18 | 19 | ImageDecoderFunc GetDecoder(const std::string& encoder_spec, const PixelFormat& fmt); 20 | }; 21 | 22 | } 23 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/fmt/compile.h: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright(c) 2016 Gabi Melman. 3 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 4 | // 5 | 6 | #pragma once 7 | // 8 | // include bundled or external copy of fmtlib's compile-time support 9 | // 10 | #include 11 | 12 | #if !defined(SPDLOG_USE_STD_FORMAT) 13 | #if !defined(SPDLOG_FMT_EXTERNAL) 14 | #ifdef SPDLOG_HEADER_ONLY 15 | #ifndef FMT_HEADER_ONLY 16 | #define FMT_HEADER_ONLY 17 | #endif 18 | #endif 19 | #include 20 | #else 21 | #include 22 | #endif 23 | #endif 24 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/README.md: -------------------------------------------------------------------------------- 1 | [![Build Status](https://travis-ci.org/ceres-solver/ceres-solver.svg?branch=master)](https://travis-ci.org/ceres-solver/ceres-solver) 2 | 3 | Ceres Solver 4 | ============ 5 | 6 | Ceres Solver is an open source C++ library for modeling and solving 7 | large, complicated optimization problems. It is a feature rich, mature 8 | and performant library which has been used in production at Google 9 | since 2010. Ceres Solver can solve two kinds of problems. 10 | 11 | 1. Non-linear Least Squares problems with bounds constraints. 12 | 2. General unconstrained optimization problems. 13 | 14 | Please see [ceres-solver.org](http://ceres-solver.org/) for more 15 | information. 16 | -------------------------------------------------------------------------------- /thirdparty/Sophus/sympy/cpp_gencode/Se2_Dx_exp_x.cpp: -------------------------------------------------------------------------------- 1 | Scalar const c0 = sin(theta); 2 | Scalar const c1 = cos(theta); 3 | Scalar const c2 = 1.0/theta; 4 | Scalar const c3 = c0*c2; 5 | Scalar const c4 = 1 - c1; 6 | Scalar const c5 = c2*c4; 7 | Scalar const c6 = c1*c2; 8 | Scalar const c7 = pow(theta, -2); 9 | Scalar const c8 = c0*c7; 10 | Scalar const c9 = c4*c7; 11 | result[0] = 0; 12 | result[1] = 0; 13 | result[2] = -c0; 14 | result[3] = 0; 15 | result[4] = 0; 16 | result[5] = c1; 17 | result[6] = c3; 18 | result[7] = -c5; 19 | result[8] = -c3*upsilon[1] + c6*upsilon[0] - c8*upsilon[0] + c9*upsilon[1]; 20 | result[9] = c5; 21 | result[10] = c3; 22 | result[11] = c3*upsilon[0] + c6*upsilon[1] - c8*upsilon[1] - c9*upsilon[0]; 23 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_core/include/pangolin/utils/posix/condition_variable.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | 7 | namespace pangolin 8 | { 9 | 10 | class ConditionVariableInterface 11 | { 12 | public: 13 | virtual ~ConditionVariableInterface() 14 | { 15 | } 16 | 17 | virtual void wait() = 0; 18 | virtual bool wait(timespec t) = 0; 19 | virtual void signal() = 0; 20 | virtual void broadcast() = 0; 21 | }; 22 | 23 | std::shared_ptr create_named_condition_variable(const 24 | std::string& name); 25 | std::shared_ptr open_named_condition_variable(const 26 | std::string& name); 27 | } 28 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/SimpleMultiDisplay/app.cfg: -------------------------------------------------------------------------------- 1 | %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 2 | % Pangolin Sample configuration file 3 | % Comments start with '%' or '#' 4 | % 5 | % Declarations are name value pairs, 6 | % seperated with '=' and terminated with ';' 7 | 8 | % We can set any variable referenced in code directly 9 | ui.A Double = 3.2; 10 | 11 | % We can set unreferenced variables too 12 | a.b = 1; 13 | a.c = 2; 14 | z.b = 3; 15 | z.c = 4; 16 | start = z; 17 | 18 | % Which we might refer to by reference 19 | ui.An Int = ${${start}.c}; 20 | 21 | % Declarations can span multiple lines 22 | M = 23 | [1, 0, 0 24 | 0, 1, 0 25 | 0, 0, 1]; 26 | 27 | ui.Aliased Double = @ui.A Double; 28 | ui.Aliased Double = 2.0; 29 | -------------------------------------------------------------------------------- /thirdparty/Sophus/scripts/install_osx_deps_incl_ceres.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | set -x # echo on 4 | set -e # exit on error 5 | 6 | brew update 7 | brew install ccache 8 | 9 | # Get dependencies for Ceres Solver 10 | brew install eigen 11 | brew install gflags 12 | brew install glog 13 | brew install gcc 14 | brew install openblas 15 | brew install libomp 16 | brew install hwloc 17 | brew install tbb 18 | 19 | git clone https://ceres-solver.googlesource.com/ceres-solver ceres-solver 20 | cd ceres-solver 21 | git reset --hard 6a74af202d83cf31811ea17dc66c74d03b89d79e 22 | mkdir target 23 | cd target 24 | ls 25 | ccache -s 26 | cmake -DMINIGLOG=On -DCMAKE_CXX_COMPILER_LAUNCHER=ccache .. 27 | make -j8 28 | sudo make install 29 | cd ../.. 30 | -------------------------------------------------------------------------------- /thirdparty/spdlog/scripts/format.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | cd "$(dirname "$0")"/.. 4 | pwd 5 | find_sources="find include src tests example bench -not ( -path include/spdlog/fmt/bundled -prune ) -type f -name *\.h -o -name *\.cpp" 6 | echo -n "Running dos2unix " 7 | $find_sources | xargs -I {} sh -c "dos2unix '{}' 2>/dev/null; echo -n '.'" 8 | echo 9 | echo -n "Running clang-format " 10 | 11 | $find_sources | xargs -I {} sh -c "clang-format -i {}; echo -n '.'" 12 | 13 | echo 14 | echo -n "Running cmake-format " 15 | find . -type f -name "CMakeLists.txt" -o -name "*\.cmake"|grep -v bundled|grep -v build|xargs -I {} sh -c "cmake-format --line-width 120 --tab-size 4 --max-subgroups-hwrap 4 -i {}; echo -n '.'" 16 | echo 17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_core/include/pangolin/factory/factory.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace pangolin 8 | { 9 | 10 | class FactoryInterface { 11 | public: 12 | using Name = std::string; 13 | using Precedence = int32_t; 14 | 15 | virtual ~FactoryInterface(){}; 16 | 17 | virtual std::map Schemes() const = 0; 18 | 19 | virtual const char* Description() const = 0; 20 | 21 | virtual ParamSet Params() const = 0; 22 | }; 23 | 24 | template 25 | class TypedFactoryInterface : public FactoryInterface 26 | { 27 | public: 28 | virtual std::unique_ptr Open(const Uri& uri) = 0; 29 | }; 30 | 31 | } 32 | -------------------------------------------------------------------------------- /thirdparty/pangolin/tools/VideoJson/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Find Pangolin (https://github.com/stevenlovegrove/Pangolin) 2 | find_package(Pangolin 0.8 REQUIRED) 3 | include_directories(${Pangolin_INCLUDE_DIRS}) 4 | 5 | add_executable(VideoJsonPrint main-print.cpp) 6 | target_link_libraries(VideoJsonPrint ${Pangolin_LIBRARIES}) 7 | 8 | add_executable(VideoJsonTransform main-transform.cpp) 9 | target_link_libraries(VideoJsonTransform ${Pangolin_LIBRARIES}) 10 | 11 | ####################################################### 12 | ## Install 13 | 14 | install(TARGETS VideoJsonPrint VideoJsonTransform 15 | RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX}/bin 16 | LIBRARY DESTINATION ${CMAKE_INSTALL_PREFIX}/lib 17 | ARCHIVE DESTINATION ${CMAKE_INSTALL_PREFIX}/lib 18 | ) 19 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/docs/source/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | find_package(Sphinx REQUIRED) 2 | 3 | # HTML output directory 4 | set(SPHINX_HTML_DIR "${Ceres_BINARY_DIR}/docs/html") 5 | 6 | # Install documentation 7 | install(DIRECTORY ${SPHINX_HTML_DIR} 8 | DESTINATION "${CERES_DOCS_INSTALL_DIR}" 9 | COMPONENT Doc 10 | PATTERN "${SPHINX_HTML_DIR}/*") 11 | 12 | # Building using 'make_docs.py' python script 13 | add_custom_target(ceres_docs ALL 14 | python 15 | "${Ceres_SOURCE_DIR}/scripts/make_docs.py" 16 | "${Ceres_SOURCE_DIR}" 17 | "${Ceres_BINARY_DIR}/docs" 18 | "${SPHINX_EXECUTABLE}" 19 | COMMENT "Building HTML documentation with Sphinx") 20 | -------------------------------------------------------------------------------- /thirdparty/Sophus/test/core/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Tests to run 2 | set(TEST_SOURCES 3 | test_common 4 | test_cartesian2 5 | test_cartesian3 6 | test_so2 7 | test_se2 8 | test_rxso2 9 | test_sim2 10 | test_so3 11 | test_se3 12 | test_rxso3 13 | test_sim3 14 | test_geometry) 15 | find_package(Ceres 2) 16 | 17 | foreach(test_src ${TEST_SOURCES}) 18 | add_executable(${test_src} ${test_src}.cpp tests.hpp 19 | ../../sophus/test_macros.hpp) 20 | target_link_libraries(${test_src} sophus) 21 | if(Ceres_FOUND) 22 | target_link_libraries(${test_src} Ceres::ceres) 23 | add_definitions(-DSOPHUS_CERES) 24 | endif(Ceres_FOUND) 25 | add_test(${test_src} ${test_src}) 26 | endforeach(test_src) 27 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/details/console_globals.h: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #pragma once 5 | 6 | #include 7 | #include 8 | 9 | namespace spdlog { 10 | namespace details { 11 | 12 | struct console_mutex { 13 | using mutex_t = std::mutex; 14 | static mutex_t &mutex() { 15 | static mutex_t s_mutex; 16 | return s_mutex; 17 | } 18 | }; 19 | 20 | struct console_nullmutex { 21 | using mutex_t = null_mutex; 22 | static mutex_t &mutex() { 23 | static mutex_t s_mutex; 24 | return s_mutex; 25 | } 26 | }; 27 | } // namespace details 28 | } // namespace spdlog 29 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/travis/install_travis_osx_deps.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | # Stop processing on any error. 4 | set -e 5 | 6 | function install_if_not_installed() { 7 | declare -r formula="$1" 8 | if [[ $(brew list ${formula} &>/dev/null; echo $?) -ne 0 ]]; then 9 | brew install ${formula} 10 | else 11 | echo "$0 - ${formula} is already installed." 12 | fi 13 | } 14 | 15 | # Manually trigger an update prior to installing packages to avoid Ruby 16 | # version related errors as per [1]. 17 | # 18 | # [1]: https://github.com/travis-ci/travis-ci/issues/8552 19 | brew update 20 | 21 | install_if_not_installed cmake 22 | install_if_not_installed glog 23 | install_if_not_installed gflags 24 | install_if_not_installed eigen 25 | install_if_not_installed suite-sparse 26 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/fmt/std.h: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright(c) 2016 Gabi Melman. 3 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 4 | // 5 | 6 | #pragma once 7 | // 8 | // include bundled or external copy of fmtlib's std support (for formatting e.g. 9 | // std::filesystem::path, std::thread::id, std::monostate, std::variant, ...) 10 | // 11 | #include 12 | 13 | #if !defined(SPDLOG_USE_STD_FORMAT) 14 | #if !defined(SPDLOG_FMT_EXTERNAL) 15 | #ifdef SPDLOG_HEADER_ONLY 16 | #ifndef FMT_HEADER_ONLY 17 | #define FMT_HEADER_ONLY 18 | #endif 19 | #endif 20 | #include 21 | #else 22 | #include 23 | #endif 24 | #endif 25 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/details/periodic_worker-inl.h: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #pragma once 5 | 6 | #ifndef SPDLOG_HEADER_ONLY 7 | #include 8 | #endif 9 | 10 | namespace spdlog { 11 | namespace details { 12 | 13 | // stop the worker thread and join it 14 | SPDLOG_INLINE periodic_worker::~periodic_worker() { 15 | if (worker_thread_.joinable()) { 16 | { 17 | std::lock_guard lock(mutex_); 18 | active_ = false; 19 | } 20 | cv_.notify_one(); 21 | worker_thread_.join(); 22 | } 23 | } 24 | 25 | } // namespace details 26 | } // namespace spdlog 27 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_core/include/pangolin/utils/posix/shared_memory_buffer.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #include 6 | 7 | namespace pangolin 8 | { 9 | class SharedMemoryBufferInterface 10 | { 11 | public: 12 | virtual ~SharedMemoryBufferInterface() { 13 | } 14 | virtual bool tryLock() = 0; 15 | virtual void lock() = 0; 16 | virtual void unlock() = 0; 17 | virtual unsigned char *ptr() = 0; 18 | virtual std::string name() = 0; 19 | }; 20 | 21 | std::shared_ptr create_named_shared_memory_buffer(const 22 | std::string& name, size_t size); 23 | std::shared_ptr open_named_shared_memory_buffer(const 24 | std::string& name, bool readwrite); 25 | } 26 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/PangolinConfigVersion.cmake.in: -------------------------------------------------------------------------------- 1 | set(PACKAGE_VERSION "@PANGOLIN_VERSION@") 2 | 3 | # Check build type is valid 4 | if( "System:${CMAKE_SYSTEM_NAME},Win64:${CMAKE_CL_64},Android:${ANDROID},iOS:${IOS}" STREQUAL 5 | "System:@CMAKE_SYSTEM_NAME@,Win64:@CMAKE_CL_64@,Android:@ANDROID@,iOS:@IOS@" ) 6 | # Check whether the requested PACKAGE_FIND_VERSION is compatible 7 | if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}") 8 | set(PACKAGE_VERSION_COMPATIBLE FALSE) 9 | else() 10 | set(PACKAGE_VERSION_COMPATIBLE TRUE) 11 | if ("${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}") 12 | set(PACKAGE_VERSION_EXACT TRUE) 13 | endif() 14 | endif() 15 | else() 16 | set(PACKAGE_VERSION_COMPATIBLE FALSE) 17 | endif() 18 | -------------------------------------------------------------------------------- /thirdparty/spdlog/bench/utils.h: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright(c) 2015 Gabi Melman. 3 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 4 | // 5 | 6 | #pragma once 7 | 8 | #include 9 | #include 10 | #include 11 | 12 | namespace utils { 13 | 14 | template 15 | inline std::string format(const T &value) { 16 | static std::locale loc(""); 17 | std::stringstream ss; 18 | ss.imbue(loc); 19 | ss << value; 20 | return ss.str(); 21 | } 22 | 23 | template <> 24 | inline std::string format(const double &value) { 25 | static std::locale loc(""); 26 | std::stringstream ss; 27 | ss.imbue(loc); 28 | ss << std::fixed << std::setprecision(1) << value; 29 | return ss.str(); 30 | } 31 | 32 | } // namespace utils 33 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/data/3x3.foe: -------------------------------------------------------------------------------- 1 | 3 8 2 | 0 1 2 0 1 2 0 1 2 3 | 0 0 0 1 1 1 2 2 2 4 | 1.201143e-01 7.520515e-02 9.078330e-02 1.280545e-01 6.276734e-02 1.201840e-01 1.092460e-01 1.217102e-01 5 | -1.06290 1.81622 -0.80592 0.27489 0.13790 -0.49836 0.76669 -1.95329 1.32468 6 | -1.39695 1.62887 -0.27482 1.46226 -2.21903 0.82016 -0.12290 0.67906 -0.57683 7 | 0.89899 0.27696 0.04805 -0.07191 0.00777 -0.00488 -0.80267 -0.31249 -0.03957 8 | -0.86612 1.66525 -1.03168 1.87671 -3.28802 1.92990 -1.22515 2.01814 -1.08079 9 | -0.37343 -0.23977 0.56955 -0.41741 0.05711 0.42774 -0.14881 0.02528 0.10072 10 | 0.62783 0.27746 0.44180 -1.22190 -0.27753 -1.23532 0.54919 0.15855 0.68658 11 | 0.46483 -1.12896 0.57926 0.22646 -0.25658 0.18881 0.57866 -1.13277 0.48707 12 | 0.86662 0.19780 -1.06759 -1.92170 -0.10882 2.02231 1.14262 -0.09817 -1.03353 13 | 14 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_image/src/image_io_raw.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | namespace pangolin { 5 | 6 | TypedImage LoadImage( 7 | const std::string& filename, 8 | const PixelFormat& raw_fmt, 9 | size_t raw_width, size_t raw_height, size_t raw_pitch 10 | ) { 11 | TypedImage img(raw_width, raw_height, raw_fmt, raw_pitch); 12 | 13 | // Read from file, row at a time. 14 | std::ifstream bFile( filename.c_str(), std::ios::in | std::ios::binary ); 15 | for(size_t r=0; r 12 | $ 13 | ) 14 | install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/include" 15 | DESTINATION ${CMAKE_INSTALL_PREFIX} 16 | ) 17 | 18 | if(BUILD_TESTS) 19 | add_executable(test_vars ${CMAKE_CURRENT_LIST_DIR}/tests/test_all.cpp) 20 | target_link_libraries(test_vars PRIVATE Catch2::Catch2 ${COMPONENT}) 21 | catch_discover_tests(test_vars) 22 | endif() 23 | -------------------------------------------------------------------------------- /thirdparty/Sophus/scripts/install_ubuntu_deps_incl_ceres.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | set -x # echo on 4 | set -e # exit on error 5 | 6 | cmake --version 7 | 8 | sudo apt update -y 9 | sudo apt install libc++-dev libgflags-dev libsuitesparse-dev clang 10 | 11 | git clone https://gitlab.com/libeigen/eigen.git 12 | cd eigen 13 | git checkout c1d637433e3b3f9012b226c2c9125c494b470ae6 14 | 15 | mkdir build-eigen 16 | cd build-eigen 17 | cmake .. -DEIGEN_DEFAULT_TO_ROW_MAJOR=$ROW_MAJOR_DEFAULT 18 | sudo make install 19 | cd ../.. 20 | 21 | git clone https://ceres-solver.googlesource.com/ceres-solver ceres-solver 22 | cd ceres-solver 23 | git reset --hard 6a74af202d83cf31811ea17dc66c74d03b89d79e 24 | mkdir build 25 | cd build 26 | ccache -s 27 | cmake -DMINIGLOG=On -DCMAKE_CXX_COMPILER_LAUNCHER=ccache .. 28 | make -j8 29 | sudo make install 30 | cd ../.. 31 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_core/include/pangolin/utils/true_false_toggle.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | namespace pangolin { 4 | 5 | enum class TrueFalseToggle 6 | { 7 | False=0, 8 | True=1, 9 | Toggle=2 10 | }; 11 | 12 | inline bool to_bool(const TrueFalseToggle on_off_toggle, const bool current_value) 13 | { 14 | switch (on_off_toggle) { 15 | case TrueFalseToggle::True: return true; 16 | case TrueFalseToggle::False: return false; 17 | case TrueFalseToggle::Toggle: return !current_value; 18 | default: return false; 19 | } 20 | } 21 | 22 | inline bool should_toggle(const TrueFalseToggle on_off_toggle, const bool current_value) 23 | { 24 | return ( (on_off_toggle == TrueFalseToggle::Toggle) || 25 | (current_value != (on_off_toggle==TrueFalseToggle::True)) 26 | ); 27 | } 28 | 29 | } 30 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_geometry/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME) 2 | 3 | find_package (Eigen3 REQUIRED QUIET) 4 | message(STATUS "Found Eigen: '${EIGEN3_INCLUDE_DIRS}'") 5 | target_compile_definitions(${COMPONENT} PUBLIC HAVE_EIGEN) 6 | 7 | target_sources( ${COMPONENT} 8 | PRIVATE 9 | ${CMAKE_CURRENT_LIST_DIR}/src/geometry.cpp 10 | ${CMAKE_CURRENT_LIST_DIR}/src/geometry_obj.cpp 11 | ${CMAKE_CURRENT_LIST_DIR}/src/geometry_ply.cpp 12 | ) 13 | 14 | target_link_libraries(${COMPONENT} pango_core pango_image tinyobj Eigen3::Eigen) 15 | target_include_directories(${COMPONENT} PUBLIC 16 | $ 17 | $ 18 | ) 19 | install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/include" 20 | DESTINATION ${CMAKE_INSTALL_PREFIX} 21 | ) 22 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/sinks/sink-inl.h: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #pragma once 5 | 6 | #ifndef SPDLOG_HEADER_ONLY 7 | #include 8 | #endif 9 | 10 | #include 11 | 12 | SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const { 13 | return msg_level >= level_.load(std::memory_order_relaxed); 14 | } 15 | 16 | SPDLOG_INLINE void spdlog::sinks::sink::set_level(level::level_enum log_level) { 17 | level_.store(log_level, std::memory_order_relaxed); 18 | } 19 | 20 | SPDLOG_INLINE spdlog::level::level_enum spdlog::sinks::sink::level() const { 21 | return static_cast(level_.load(std::memory_order_relaxed)); 22 | } 23 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/BasicOpenGL/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Find Pangolin (https://github.com/stevenlovegrove/Pangolin) 2 | find_package(Pangolin 0.8 REQUIRED) 3 | include_directories(${Pangolin_INCLUDE_DIRS}) 4 | 5 | set(sample_srcs 6 | 1_gl_intro_classic_triangle.cpp 7 | 1_gl_intro_pango_triangle.cpp 8 | 2_gl_intro_classic_triangle_vbo.cpp 9 | 2_gl_intro_pango_triangle_vbo.cpp 10 | 3_gl_intro_classic_triangle_vbo_shader.cpp 11 | 3_gl_intro_pango_triangle_vbo_shader.cpp 12 | 4_gl_intro_viewport.cpp 13 | 5_gl_intro_view_transforms.cpp 14 | ) 15 | 16 | foreach( sample_src ${sample_srcs}) 17 | get_filename_component(sample_name ${sample_src} NAME_WE) 18 | set(target_name "tutorial_${sample_name}") 19 | add_executable(${target_name} ${sample_src}) 20 | target_link_libraries(${target_name} pango_display) 21 | endforeach() 22 | 23 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/FindMediaFoundation.cmake: -------------------------------------------------------------------------------- 1 | # - Find MediaFoundation 2 | # Find the Windows SDK MediaFoundation libraries 3 | # 4 | # MediaFoundation_LIBRARIES - List of libraries when using MediaFoundation 5 | # MediaFoundation_FOUND - True if MediaFoundation found 6 | 7 | IF (MSVC) 8 | SET( MediaFoundation_LIBRARIES mf.lib mfplat.lib mfreadwrite.lib mfuuid.lib strmiids.lib ) 9 | SET( MediaFoundation_FOUND true ) 10 | ENDIF (MSVC) 11 | 12 | IF (MediaFoundation_FOUND) 13 | IF (NOT MediaFoundation_FIND_QUIETLY) 14 | MESSAGE(STATUS "Found MediaFoundation: ${MediaFoundation_LIBRARIES}") 15 | ENDIF (NOT MediaFoundation_FIND_QUIETLY) 16 | ELSE (MediaFoundation_FOUND) 17 | IF (MediaFoundation_FIND_REQUIRED) 18 | MESSAGE(FATAL_ERROR "Could not find MediaFoundation") 19 | ENDIF (MediaFoundation_FIND_REQUIRED) 20 | ENDIF (MediaFoundation_FOUND) 21 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_video/include/pangolin/video/video_exception.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | namespace pangolin { 8 | 9 | struct PANGOLIN_EXPORT VideoException : std::exception 10 | { 11 | VideoException(std::string str) : desc(str) {} 12 | VideoException(std::string str, std::string detail) { 13 | desc = str + "\n\t" + detail; 14 | } 15 | ~VideoException() throw() {} 16 | const char* what() const throw() { return desc.c_str(); } 17 | std::string desc; 18 | }; 19 | 20 | struct PANGOLIN_EXPORT VideoExceptionNoKnownHandler : public VideoException 21 | { 22 | VideoExceptionNoKnownHandler(const std::string& scheme) 23 | : VideoException("No known video handler for URI '" + scheme + "'") 24 | { 25 | } 26 | }; 27 | 28 | } 29 | 30 | -------------------------------------------------------------------------------- /docker_entrypoint.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | set -e 3 | 4 | # Default values 5 | APP_TYPE="vio" 6 | DATASET_PATH="" 7 | 8 | # Parse arguments 9 | if [ "$1" = "vo" ] || [ "$1" = "vio" ]; then 10 | APP_TYPE=$1 11 | shift 12 | fi 13 | 14 | if [ -n "$1" ]; then 15 | DATASET_PATH=$1 16 | fi 17 | 18 | # Determine which config to use 19 | if [ "$APP_TYPE" = "vio" ]; then 20 | CONFIG_FILE="/workspace/config/euroc_vio.yaml" 21 | else 22 | CONFIG_FILE="/workspace/config/euroc_vo.yaml" 23 | fi 24 | 25 | # Change to the build directory 26 | cd /workspace/build 27 | 28 | # Check if a dataset path is provided 29 | if [ -z "$DATASET_PATH" ]; then 30 | echo "No dataset path provided. Running with --help." 31 | exec ./euroc_stereo --help 32 | else 33 | echo "Running $APP_TYPE with dataset: $DATASET_PATH" 34 | exec ./euroc_stereo $CONFIG_FILE $DATASET_PATH 35 | fi 36 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/docs/source/faqs.rst: -------------------------------------------------------------------------------- 1 | .. _chapter-tricks: 2 | 3 | .. default-domain:: cpp 4 | 5 | .. cpp:namespace:: ceres 6 | 7 | =================== 8 | FAQS, Tips & Tricks 9 | =================== 10 | 11 | Answers to frequently asked questions, tricks of the trade and general 12 | wisdom. 13 | 14 | .. toctree:: 15 | :maxdepth: 2 16 | 17 | modeling_faqs 18 | solving_faqs 19 | 20 | 21 | Further Reading 22 | =============== 23 | 24 | For a short but informative introduction to the subject we recommend 25 | the booklet by [Madsen]_ . For a general introduction to non-linear 26 | optimization we recommend [NocedalWright]_. [Bjorck]_ remains the 27 | seminal reference on least squares problems. [TrefethenBau]_ book is 28 | our favorite text on introductory numerical linear algebra. [Triggs]_ 29 | provides a thorough coverage of the bundle adjustment problem. 30 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_video/include/pangolin/video/video_help.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace pangolin { 7 | 8 | /// Print to \p out supported pixel format codes 9 | /// \p color whether ANSI Color codes should be used for formatting 10 | void PrintPixelFormats(std::ostream& out = std::cout, bool color = true); 11 | 12 | /// Print to \p out general Video URL usage and registered VideoFactories 13 | /// \p out the stream to stream the help message to 14 | /// \p scheme_filter a constraint on schemes to print, or empty if all should be listed 15 | /// \p level the level of detail to use when printing (see enum above) 16 | void VideoHelp( 17 | std::ostream& out = std::cout, const std::string& scheme_filter="", 18 | HelpVerbosity verbosity = HelpVerbosity::SYNOPSIS 19 | ); 20 | 21 | } 22 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/cfg/helpers.h: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #pragma once 5 | 6 | #include 7 | #include 8 | 9 | namespace spdlog { 10 | namespace cfg { 11 | namespace helpers { 12 | // 13 | // Init levels from given string 14 | // 15 | // Examples: 16 | // 17 | // set global level to debug: "debug" 18 | // turn off all logging except for logger1: "off,logger1=debug" 19 | // turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info" 20 | // 21 | SPDLOG_API void load_levels(const std::string &txt); 22 | } // namespace helpers 23 | 24 | } // namespace cfg 25 | } // namespace spdlog 26 | 27 | #ifdef SPDLOG_HEADER_ONLY 28 | #include "helpers-inl.h" 29 | #endif // SPDLOG_HEADER_ONLY 30 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/FindDC1394.cmake: -------------------------------------------------------------------------------- 1 | # Try to find the dc1394 v2 lib and include files 2 | # 3 | # DC1394_INCLUDE_DIR 4 | # DC1394_LIBRARIES 5 | # DC1394_FOUND 6 | 7 | FIND_PATH( DC1394_INCLUDE_DIR dc1394/control.h 8 | /usr/include 9 | /usr/local/include 10 | ) 11 | 12 | FIND_LIBRARY( DC1394_LIBRARY dc1394 13 | /usr/lib64 14 | /usr/lib 15 | /usr/local/lib 16 | ) 17 | 18 | IF(DC1394_INCLUDE_DIR AND DC1394_LIBRARY) 19 | SET( DC1394_FOUND TRUE ) 20 | SET( DC1394_LIBRARIES ${DC1394_LIBRARY} ) 21 | ENDIF(DC1394_INCLUDE_DIR AND DC1394_LIBRARY) 22 | 23 | IF(DC1394_FOUND) 24 | IF(NOT DC1394_FIND_QUIETLY) 25 | MESSAGE(STATUS "Found DC1394: ${DC1394_LIBRARY}") 26 | ENDIF(NOT DC1394_FIND_QUIETLY) 27 | ELSE(DC1394_FOUND) 28 | IF(DC1394_FIND_REQUIRED) 29 | MESSAGE(FATAL_ERROR "Could not find libdc1394") 30 | ENDIF(DC1394_FIND_REQUIRED) 31 | ENDIF(DC1394_FOUND) 32 | 33 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_packetstream/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME) 2 | 3 | target_sources( ${COMPONENT} 4 | PRIVATE 5 | ${CMAKE_CURRENT_LIST_DIR}/src/packet.cpp 6 | ${CMAKE_CURRENT_LIST_DIR}/src/packetstream.cpp 7 | ${CMAKE_CURRENT_LIST_DIR}/src/packetstream_reader.cpp 8 | ${CMAKE_CURRENT_LIST_DIR}/src/packetstream_writer.cpp 9 | ${CMAKE_CURRENT_LIST_DIR}/src/playback_session.cpp 10 | ) 11 | 12 | target_compile_definitions(${COMPONENT} PRIVATE "PANGOLIN_VERSION_STRING=\"${PANGOLIN_VERSION}\"") 13 | target_link_libraries(${COMPONENT} PUBLIC pango_core) 14 | target_include_directories(${COMPONENT} PUBLIC 15 | $ 16 | $ 17 | ) 18 | install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/include" 19 | DESTINATION ${CMAKE_INSTALL_PREFIX} 20 | ) 21 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/details/synchronous_factory.h: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #pragma once 5 | 6 | #include "registry.h" 7 | 8 | namespace spdlog { 9 | 10 | // Default logger factory- creates synchronous loggers 11 | class logger; 12 | 13 | struct synchronous_factory { 14 | template 15 | static std::shared_ptr create(std::string logger_name, SinkArgs &&...args) { 16 | auto sink = std::make_shared(std::forward(args)...); 17 | auto new_logger = std::make_shared(std::move(logger_name), std::move(sink)); 18 | details::registry::instance().initialize_logger(new_logger); 19 | return new_logger; 20 | } 21 | }; 22 | } // namespace spdlog 23 | -------------------------------------------------------------------------------- /thirdparty/Sophus/sympy/cpp_gencode/So3_Dx_log_this.cpp: -------------------------------------------------------------------------------- 1 | Scalar const c0 = pow(q.x(), 2); 2 | Scalar const c1 = pow(q.y(), 2); 3 | Scalar const c2 = pow(q.z(), 2); 4 | Scalar const c3 = c0 + c1 + c2; 5 | Scalar const c4 = sqrt(c3); 6 | Scalar const c5 = 1.0/q.w(); 7 | Scalar const c6 = 2*atan(c4*c5); 8 | Scalar const c7 = c6/c4; 9 | Scalar const c8 = c6/pow(c3, 3.0/2.0); 10 | Scalar const c9 = 2*c5/(c3*(c3/pow(q.w(), 2) + 1)); 11 | Scalar const c10 = c8*q.x(); 12 | Scalar const c11 = c9*q.x(); 13 | Scalar const c12 = -c10*q.y() + c11*q.y(); 14 | Scalar const c13 = -c10*q.z() + c11*q.z(); 15 | Scalar const c14 = q.y()*q.z(); 16 | Scalar const c15 = -c14*c8 + c14*c9; 17 | result[0] = -c0*c8 + c0*c9 + c7; 18 | result[1] = c12; 19 | result[2] = c13; 20 | result[3] = c12; 21 | result[4] = -c1*c8 + c1*c9 + c7; 22 | result[5] = c15; 23 | result[6] = c13; 24 | result[7] = c15; 25 | result[8] = -c2*c8 + c2*c9 + c7; 26 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/fmt/fmt.h: -------------------------------------------------------------------------------- 1 | // 2 | // Copyright(c) 2016-2018 Gabi Melman. 3 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 4 | // 5 | 6 | #pragma once 7 | 8 | // 9 | // Include a bundled header-only copy of fmtlib or an external one. 10 | // By default spdlog include its own copy. 11 | // 12 | #include 13 | 14 | #if defined(SPDLOG_USE_STD_FORMAT) // SPDLOG_USE_STD_FORMAT is defined - use std::format 15 | #include 16 | #elif !defined(SPDLOG_FMT_EXTERNAL) 17 | #if !defined(SPDLOG_COMPILED_LIB) && !defined(FMT_HEADER_ONLY) 18 | #define FMT_HEADER_ONLY 19 | #endif 20 | #ifndef FMT_USE_WINDOWS_H 21 | #define FMT_USE_WINDOWS_H 0 22 | #endif 23 | #include 24 | #else // SPDLOG_FMT_EXTERNAL is defined - use external fmtlib 25 | #include 26 | #endif 27 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/FindOpenEXR.cmake: -------------------------------------------------------------------------------- 1 | # Try to find the OpenEXR v2 lib and include files 2 | # 3 | # OpenEXR_INCLUDE_DIR 4 | # OpenEXR_LIBRARIES 5 | # OpenEXR_FOUND 6 | 7 | FIND_PATH( OpenEXR_INCLUDE_DIR ImfHeader.h 8 | /usr/include 9 | /usr/local/include 10 | PATH_SUFFIXES OpenEXR 11 | ) 12 | 13 | FIND_LIBRARY( OpenEXR_LIBRARY IlmImf 14 | /usr/lib64 15 | /usr/lib 16 | /usr/local/lib 17 | ) 18 | 19 | IF(OpenEXR_INCLUDE_DIR AND OpenEXR_LIBRARY) 20 | SET( OpenEXR_FOUND TRUE ) 21 | SET( OpenEXR_LIBRARIES ${OpenEXR_LIBRARY} ) 22 | ENDIF() 23 | 24 | IF(OpenEXR_FOUND) 25 | IF(NOT OpenEXR_FIND_QUIETLY) 26 | MESSAGE(STATUS "Found OpenEXR: ${OpenEXR_LIBRARY}") 27 | ENDIF(NOT OpenEXR_FIND_QUIETLY) 28 | ELSE(OpenEXR_FOUND) 29 | IF(OpenEXR_FIND_REQUIRED) 30 | MESSAGE(FATAL_ERROR "Could not find libOpenEXR") 31 | ENDIF(OpenEXR_FIND_REQUIRED) 32 | ENDIF(OpenEXR_FOUND) 33 | 34 | -------------------------------------------------------------------------------- /thirdparty/spdlog/src/file_sinks.cpp: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #ifndef SPDLOG_COMPILED_LIB 5 | #error Please define SPDLOG_COMPILED_LIB to compile this file. 6 | #endif 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | #include 14 | 15 | template class SPDLOG_API spdlog::sinks::basic_file_sink; 16 | template class SPDLOG_API spdlog::sinks::basic_file_sink; 17 | 18 | #include 19 | template class SPDLOG_API spdlog::sinks::rotating_file_sink; 20 | template class SPDLOG_API spdlog::sinks::rotating_file_sink; 21 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_image/include/pangolin/image/image_convert.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace pangolin 7 | { 8 | 9 | template 10 | void ImageConvert(Image& dst, const Image& src, To scale = 1.0) 11 | { 12 | for(unsigned int y = 0; y < dst.h; ++y) 13 | { 14 | const T* prs = src.RowPtr(y); 15 | To* prd = dst.RowPtr(y); 16 | for(unsigned int x = 0; x < dst.w; ++x) 17 | { 18 | *(prd++) = scale * ComponentCast::cast(*(prs++)); 19 | } 20 | } 21 | } 22 | 23 | template 24 | ManagedImage ImageConvert(const Image& src, To scale = 1.0) 25 | { 26 | ManagedImage dst(src.w, src.h); 27 | ImageConvert(dst,src,scale); 28 | return dst; 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /thirdparty/Sophus/sympy/cpp_gencode/Se2_Dx_log_this.cpp: -------------------------------------------------------------------------------- 1 | Scalar const c0 = c[0] - 1; 2 | Scalar const c1 = 0.5*atan2(c[1], c[0]); 3 | Scalar const c2 = c1*c[1]/pow(c0, 2); 4 | Scalar const c3 = pow(c[1], 2); 5 | Scalar const c4 = 1.0/(c3 + pow(c[0], 2)); 6 | Scalar const c5 = c4*c[1]; 7 | Scalar const c6 = 0.5*t[1]; 8 | Scalar const c7 = c5*c6; 9 | Scalar const c8 = 0.5*t[0]; 10 | Scalar const c9 = 1.0/c0; 11 | Scalar const c10 = c3*c4*c9; 12 | Scalar const c11 = c1*c9; 13 | Scalar const c12 = c4*c[0]; 14 | Scalar const c13 = c5*c8; 15 | Scalar const c14 = c9*c[0]; 16 | Scalar const c15 = -c11*c[1]; 17 | result[0] = c10*c8 + c2*t[0] - c7; 18 | result[1] = -c11*t[0] + c12*c6 - c13*c14; 19 | result[2] = c15; 20 | result[3] = c1; 21 | result[4] = c10*c6 + c13 + c2*t[1]; 22 | result[5] = -c11*t[1] - c12*c8 - c14*c7; 23 | result[6] = -c1; 24 | result[7] = c15; 25 | result[8] = -c5; 26 | result[9] = c12; 27 | result[10] = 0; 28 | result[11] = 0; 29 | -------------------------------------------------------------------------------- /thirdparty/pangolin/tools/ModelViewer/util.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | template 4 | bool is_ready(std::future const& f) 5 | { return f.wait_for(std::chrono::seconds(0)) == std::future_status::ready; } 6 | 7 | inline std::vector ExpandGlobOption(const argagg::option_results& opt) 8 | { 9 | std::vector expanded; 10 | for(const auto& o : opt.all) 11 | { 12 | const std::string r = o.as(); 13 | pangolin::FilesMatchingWildcard(r, expanded); 14 | } 15 | return expanded; 16 | } 17 | 18 | template 19 | inline std::vector TryLoad(const std::vector& in, const F& load_func) 20 | { 21 | std::vector loaded; 22 | for(const Tin& file : in) 23 | { 24 | try { 25 | loaded.emplace_back(load_func(file)); 26 | }catch(const std::exception&) { 27 | } 28 | } 29 | return loaded; 30 | } 31 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/cmake_uninstall.cmake.in: -------------------------------------------------------------------------------- 1 | if(NOT EXISTS "@CMAKE_BINARY_DIR@/install_manifest.txt") 2 | message(FATAL_ERROR "Cannot find install manifest: @CMAKE_BINARY_DIR@/install_manifest.txt") 3 | endif() 4 | 5 | file(READ "@CMAKE_BINARY_DIR@/install_manifest.txt" files) 6 | string(REGEX REPLACE "\n" ";" files "${files}") 7 | foreach(file ${files}) 8 | message(STATUS "Uninstalling $ENV{DESTDIR}${file}") 9 | if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") 10 | exec_program( 11 | "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\"" 12 | OUTPUT_VARIABLE rm_out 13 | RETURN_VALUE rm_retval 14 | ) 15 | if(NOT "${rm_retval}" STREQUAL 0) 16 | message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}") 17 | endif() 18 | else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}") 19 | message(STATUS "File $ENV{DESTDIR}${file} does not exist.") 20 | endif() 21 | endforeach() 22 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/FindXrandr.cmake: -------------------------------------------------------------------------------- 1 | # - Try to find Xrandr 2 | # 3 | # Xrandr_FOUND - system has libXrandr 4 | # Xrandr_INCLUDE_DIRS - the libXrandr include directories 5 | # Xrandr_LIBRARIES - link these to use libXrandr 6 | 7 | FIND_PATH( 8 | Xrandr_INCLUDE_DIRS 9 | NAMES X11/extensions/Xrandr.h 10 | PATH_SUFFIXES X11/extensions 11 | DOC "The Xrandr include directory" 12 | ) 13 | 14 | FIND_LIBRARY( 15 | Xrandr_LIBRARIES 16 | NAMES Xrandr 17 | DOC "The Xrandr library" 18 | ) 19 | 20 | IF (Xrandr_INCLUDE_DIRS AND Xrandr_LIBRARIES) 21 | SET(Xrandr_FOUND TRUE) 22 | ENDIF (Xrandr_INCLUDE_DIRS AND Xrandr_LIBRARIES) 23 | 24 | IF (Xrandr_FOUND) 25 | IF (NOT Xrandr_FIND_QUIETLY) 26 | MESSAGE(STATUS "Found Xrandr: ${Xrandr_LIBRARIES}") 27 | ENDIF (NOT Xrandr_FIND_QUIETLY) 28 | ELSE (Xrandr_FOUND) 29 | IF (Xrandr_FIND_REQUIRED) 30 | MESSAGE(FATAL_ERROR "Could not find Xrandr") 31 | ENDIF (Xrandr_FIND_REQUIRED) 32 | ENDIF (Xrandr_FOUND) 33 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_core/include/pangolin/utils/is_streamable.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | namespace pangolin { 9 | 10 | // Provide SFINAE test for if type T is streamable into S 11 | // Example usage: 12 | // template 13 | // typename std::enable_if::value, S>::type 14 | // Example(const S& src) noexcept 15 | // { 16 | // std::cout << src; 17 | // return src; 18 | // } 19 | template 20 | class is_streamable 21 | { 22 | template 23 | static auto test(int) 24 | -> decltype( std::declval() << std::declval(), std::true_type() ); 25 | 26 | template 27 | static auto test(...) -> std::false_type; 28 | 29 | public: 30 | static const bool value = decltype(test(0))::value; 31 | }; 32 | 33 | 34 | 35 | } 36 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_packetstream/src/playback_session.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | namespace pangolin { 4 | 5 | std::shared_ptr PlaybackSession::Default() 6 | { 7 | static std::shared_ptr instance = std::make_shared(); 8 | return instance; 9 | } 10 | 11 | std::shared_ptr PlaybackSession::ChooseFromParams(const ParamReader& reader) 12 | { 13 | return Choose(reader.Get("OrderedPlayback")); 14 | } 15 | 16 | std::shared_ptr PlaybackSession::ChooseFromParams(const Params& params) 17 | { 18 | return Choose(params.Get("OrderedPlayback", false)); 19 | } 20 | 21 | std::shared_ptr PlaybackSession::Choose(bool use_ordered_playback) 22 | { 23 | if(use_ordered_playback) 24 | { 25 | return Default(); 26 | } 27 | else 28 | { 29 | return std::make_shared(); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/pypangoio.cpp: -------------------------------------------------------------------------------- 1 | #include "pypangoio.h" 2 | 3 | namespace py_pangolin 4 | { 5 | 6 | PyPangoIO::PyPangoIO(std::queue& line_queue, InterpreterLineType line_type) 7 | : line_queue(line_queue), line_type(line_type) 8 | { 9 | } 10 | 11 | void PyPangoIO::write(const std::string& text) 12 | { 13 | buffer += text; 14 | size_t nl = buffer.find_first_of('\n'); 15 | while(nl != std::string::npos) { 16 | const std::string line = buffer.substr(0,nl); 17 | line_queue.push(InterpreterLine(line,line_type)); 18 | buffer = buffer.substr(nl+1); 19 | nl = buffer.find_first_of('\n'); 20 | } 21 | } 22 | 23 | void PyPangoIO::flush() 24 | { 25 | // Do nothing 26 | } 27 | 28 | void bind_pango_write_object(pybind11::module& m) 29 | { 30 | pybind11::class_(m, "PyPangoIO") 31 | .def("write", &PyPangoIO::write) 32 | .def("flush", &PyPangoIO::flush); 33 | } 34 | 35 | } 36 | -------------------------------------------------------------------------------- /thirdparty/Sophus/test/ceres/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Make sure Ceres knows where to find Eigen 2 | list(APPEND SEARCH_HEADERS ${EIGEN3_INCLUDE_DIR}) 3 | 4 | # git clone https://ceres-solver.googlesource.com/ceres-solver 5 | find_package(Ceres 2) 6 | 7 | function(add_test_ceres source postfix) 8 | add_executable(${source}_${postfix} ${source}.cpp) 9 | target_link_libraries(${source}_${postfix} sophus Ceres::ceres) 10 | target_compile_definitions(${source}_${postfix} PRIVATE ${ARGN}) 11 | add_test(${source}_${postfix} ${source}_${postfix}) 12 | endfunction() 13 | 14 | if(Ceres_FOUND) 15 | message(STATUS "CERES found") 16 | 17 | # Tests to run 18 | set(TEST_SOURCES 19 | test_ceres_so3 20 | test_ceres_rxso3 21 | test_ceres_se3 22 | test_ceres_sim3 23 | test_ceres_so2 24 | test_ceres_rxso2 25 | test_ceres_se2 26 | test_ceres_sim2) 27 | 28 | foreach(test_src ${TEST_SOURCES}) 29 | add_test_ceres(${test_src} "manifold") 30 | endforeach() 31 | endif(Ceres_FOUND) 32 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/Findzstd.cmake: -------------------------------------------------------------------------------- 1 | ############################################################################### 2 | # Find Toshiba TeliCam 3 | # 4 | # This sets the following variables: 5 | # TeliCam_FOUND - True if TeliCam was found. 6 | # TeliCam_INCLUDE_DIRS - Directories containing the TeliCam include files. 7 | # TeliCam_LIBRARIES - Libraries needed to use TeliCam. 8 | 9 | find_path( 10 | zstd_INCLUDE_DIR zstd.h 11 | PATHS 12 | /opt/local/include 13 | /usr/local/include 14 | /usr/include 15 | PATH_SUFFIXES TeliCam 16 | ) 17 | 18 | find_library( 19 | zstd_LIBRARY 20 | NAMES zstd 21 | PATHS 22 | /opt/local/lib 23 | /user/local/lib 24 | /usr/lib 25 | ) 26 | 27 | # Plural forms 28 | set(zstd_INCLUDE_DIRS ${zstd_INCLUDE_DIR}) 29 | set(zstd_LIBRARIES ${zstd_LIBRARY}) 30 | 31 | include(FindPackageHandleStandardArgs) 32 | find_package_handle_standard_args( zstd 33 | FOUND_VAR zstd_FOUND 34 | REQUIRED_VARS zstd_INCLUDE_DIR zstd_LIBRARY 35 | ) 36 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/FindGLUES.cmake: -------------------------------------------------------------------------------- 1 | # Try to find the GLUES lib and include files 2 | # 3 | # GLUES_INCLUDE_DIR 4 | # GLUES_LIBRARIES 5 | # GLUES_FOUND 6 | 7 | FIND_PATH( GLUES_INCLUDE_DIR glues/glues.h 8 | /usr/include 9 | /usr/local/include 10 | /opt/include 11 | /opt/local/include 12 | ${CMAKE_INSTALL_PREFIX}/include 13 | ) 14 | 15 | FIND_LIBRARY( GLUES_LIBRARY glues 16 | /usr/lib64 17 | /usr/lib 18 | /usr/local/lib 19 | /opt/local/lib 20 | /opt/local/lib64 21 | ${CMAKE_INSTALL_PREFIX}/lib 22 | ) 23 | 24 | IF(GLUES_INCLUDE_DIR AND GLUES_LIBRARY) 25 | SET( GLUES_FOUND TRUE ) 26 | SET( GLUES_LIBRARIES ${GLUES_LIBRARY} ) 27 | ENDIF(GLUES_INCLUDE_DIR AND GLUES_LIBRARY) 28 | 29 | IF(GLUES_FOUND) 30 | IF(NOT GLUES_FIND_QUIETLY) 31 | MESSAGE(STATUS "Found GLUES: ${GLUES_LIBRARY}") 32 | ENDIF(NOT GLUES_FIND_QUIETLY) 33 | ELSE(GLUES_FOUND) 34 | IF(GLUES_FIND_REQUIRED) 35 | MESSAGE(FATAL_ERROR "Could not find GLUES") 36 | ENDIF(GLUES_FIND_REQUIRED) 37 | ENDIF(GLUES_FOUND) 38 | 39 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/Finduvc.cmake: -------------------------------------------------------------------------------- 1 | # - Try to find uvc 2 | # 3 | # uvc_FOUND - system has libuvc 4 | # uvc_INCLUDE_DIRS - the libuvc include directories 5 | # uvc_LIBRARIES - link these to use libuvc 6 | 7 | FIND_PATH( 8 | uvc_INCLUDE_DIRS 9 | NAMES libuvc/libuvc.h 10 | PATHS 11 | ${CMAKE_SOURCE_DIR}/.. 12 | /usr/include/ 13 | /usr/local/include 14 | /opt/local/include 15 | ) 16 | 17 | FIND_LIBRARY( 18 | uvc_LIBRARIES 19 | NAMES uvc 20 | PATHS 21 | ${CMAKE_SOURCE_DIR}/../uvc/build 22 | /usr/lib 23 | /usr/local/lib 24 | /opt/local/lib 25 | ) 26 | 27 | IF (uvc_INCLUDE_DIRS AND uvc_LIBRARIES) 28 | SET(uvc_FOUND TRUE) 29 | ENDIF (uvc_INCLUDE_DIRS AND uvc_LIBRARIES) 30 | 31 | IF (uvc_FOUND) 32 | IF (NOT uvc_FIND_QUIETLY) 33 | MESSAGE(STATUS "Found uvc: ${uvc_LIBRARIES}") 34 | ENDIF (NOT uvc_FIND_QUIETLY) 35 | ELSE (uvc_FOUND) 36 | IF (uvc_FIND_REQUIRED) 37 | MESSAGE(FATAL_ERROR "Could not find uvc") 38 | ENDIF (uvc_FIND_REQUIRED) 39 | ENDIF (uvc_FOUND) 40 | -------------------------------------------------------------------------------- /thirdparty/Sophus/sympy/cpp_gencode/So3_Dx_exp_x.cpp: -------------------------------------------------------------------------------- 1 | Scalar const c0 = pow(omega[0], 2); 2 | Scalar const c1 = pow(omega[1], 2); 3 | Scalar const c2 = pow(omega[2], 2); 4 | Scalar const c3 = c0 + c1 + c2; 5 | Scalar const c4 = sqrt(c3); 6 | Scalar const c5 = 0.5*c4; 7 | Scalar const c6 = sin(c5); 8 | Scalar const c7 = c6/c4; 9 | Scalar const c8 = c6/pow(c3, 3.0/2.0); 10 | Scalar const c9 = 0.5*cos(c5)/c3; 11 | Scalar const c10 = c8*omega[0]; 12 | Scalar const c11 = c9*omega[0]; 13 | Scalar const c12 = -c10*omega[1] + c11*omega[1]; 14 | Scalar const c13 = -c10*omega[2] + c11*omega[2]; 15 | Scalar const c14 = omega[1]*omega[2]; 16 | Scalar const c15 = -c14*c8 + c14*c9; 17 | Scalar const c16 = 0.5*c7; 18 | result[0] = -c0*c8 + c0*c9 + c7; 19 | result[1] = c12; 20 | result[2] = c13; 21 | result[3] = c12; 22 | result[4] = -c1*c8 + c1*c9 + c7; 23 | result[5] = c15; 24 | result[6] = c13; 25 | result[7] = c15; 26 | result[8] = -c2*c8 + c2*c9 + c7; 27 | result[9] = -c16*omega[0]; 28 | result[10] = -c16*omega[1]; 29 | result[11] = -c16*omega[2]; 30 | -------------------------------------------------------------------------------- /thirdparty/ceres-solver/internal/ceres/autodiff_benchmarks/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # TODO: Add support for other compilers 2 | if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") 3 | # Increase the inlining threshold only for those functions marked with an 4 | # inline hint. This is typically far more realistic to significantly increase 5 | # in a large code-base than -inline-threshold as that has a larger scope. 6 | list(APPEND CERES_BENCHMARK_FLAGS "-mllvm" "-inlinehint-threshold=1000000") 7 | endif() 8 | 9 | add_executable(autodiff_benchmarks autodiff_benchmarks.cc) 10 | add_dependencies_to_benchmark(autodiff_benchmarks) 11 | target_compile_options(autodiff_benchmarks PRIVATE ${CERES_BENCHMARK_FLAGS}) 12 | 13 | # All other flags + fast-math 14 | list(APPEND CERES_BENCHMARK_FAST_MATH_FLAGS ${CERES_BENCHMARK_FLAGS} "-ffast-math") 15 | add_executable(autodiff_benchmarks_fast_math autodiff_benchmarks.cc) 16 | add_dependencies_to_benchmark(autodiff_benchmarks_fast_math) 17 | target_compile_options(autodiff_benchmarks_fast_math PRIVATE ${CERES_BENCHMARK_FAST_MATH_FLAGS}) 18 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/sinks/sink.h: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #pragma once 5 | 6 | #include 7 | #include 8 | 9 | namespace spdlog { 10 | 11 | namespace sinks { 12 | class SPDLOG_API sink { 13 | public: 14 | virtual ~sink() = default; 15 | virtual void log(const details::log_msg &msg) = 0; 16 | virtual void flush() = 0; 17 | virtual void set_pattern(const std::string &pattern) = 0; 18 | virtual void set_formatter(std::unique_ptr sink_formatter) = 0; 19 | 20 | void set_level(level::level_enum log_level); 21 | level::level_enum level() const; 22 | bool should_log(level::level_enum msg_level) const; 23 | 24 | protected: 25 | // sink log level - default is all 26 | level_t level_{level::trace}; 27 | }; 28 | 29 | } // namespace sinks 30 | } // namespace spdlog 31 | 32 | #ifdef SPDLOG_HEADER_ONLY 33 | #include "sink-inl.h" 34 | #endif 35 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/BasicOpenGL/2_gl_intro_pango_triangle_vbo.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void sample() 5 | { 6 | pangolin::CreateWindowAndBind("Pango GL Triangle with VBO", 500, 500); 7 | 8 | // Create an OpenGL Buffer containing the vertices of a triangle 9 | pangolin::GlBuffer vbo(pangolin::GlArrayBuffer, 10 | std::vector{ 11 | {-0.5f, -0.5f, 0.0f}, 12 | { 0.5f, -0.5f, 0.0f }, 13 | { 0.0f, 0.5f, 0.0f } 14 | } 15 | ); 16 | 17 | glClearColor(0.64f, 0.5f, 0.81f, 0.0f); 18 | glColor3f(0.29f, 0.71f, 1.0f); 19 | 20 | while( !pangolin::ShouldQuit() ) 21 | { 22 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 23 | 24 | // Connect the first 3 vertices in the GL Buffer to form a triangle! 25 | pangolin::RenderVbo(vbo, GL_TRIANGLES); 26 | 27 | pangolin::FinishFrame(); 28 | } 29 | } 30 | 31 | int main( int /*argc*/, char** /*argv*/ ) 32 | { 33 | sample(); 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_core/include/pangolin/utils/compontent_cast.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #ifdef HAVE_EIGEN 6 | # include 7 | #endif 8 | 9 | namespace pangolin 10 | { 11 | 12 | // Scalar / Vector agnostic static_cast-like thing 13 | // 14 | // e.g. Promote float to double: 15 | // ComponentCast::cast(0.14f); 16 | // 17 | // e.g. Promote Eigen::Vector2f to Eigen::Vector2d: 18 | // ComponentCast::cast(Eigen::Vector2f(0.1,0.2); 19 | 20 | template 21 | struct ComponentCast 22 | { 23 | PANGO_HOST_DEVICE 24 | static To cast(const From& val) 25 | { 26 | return static_cast(val); 27 | } 28 | }; 29 | 30 | #ifdef HAVE_EIGEN 31 | template 32 | struct ComponentCast > 33 | { 34 | PANGO_HOST_DEVICE 35 | static To cast(const Eigen::MatrixBase& val) 36 | { 37 | return val.template cast(); 38 | } 39 | }; 40 | #endif 41 | 42 | } 43 | -------------------------------------------------------------------------------- /thirdparty/spdlog/example/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT) 2 | 3 | cmake_minimum_required(VERSION 3.11) 4 | project(spdlog_examples CXX) 5 | 6 | if(NOT TARGET spdlog) 7 | # Stand-alone build 8 | find_package(spdlog REQUIRED) 9 | endif() 10 | 11 | # --------------------------------------------------------------------------------------- 12 | # Example of using pre-compiled library 13 | # --------------------------------------------------------------------------------------- 14 | add_executable(example example.cpp) 15 | target_link_libraries(example PRIVATE spdlog::spdlog $<$:ws2_32>) 16 | 17 | # --------------------------------------------------------------------------------------- 18 | # Example of using header-only library 19 | # --------------------------------------------------------------------------------------- 20 | if(SPDLOG_BUILD_EXAMPLE_HO) 21 | add_executable(example_header_only example.cpp) 22 | target_link_libraries(example_header_only PRIVATE spdlog::spdlog_header_only) 23 | endif() 24 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/details/log_msg_buffer.h: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #pragma once 5 | 6 | #include 7 | 8 | namespace spdlog { 9 | namespace details { 10 | 11 | // Extend log_msg with internal buffer to store its payload. 12 | // This is needed since log_msg holds string_views that points to stack data. 13 | 14 | class SPDLOG_API log_msg_buffer : public log_msg { 15 | memory_buf_t buffer; 16 | void update_string_views(); 17 | 18 | public: 19 | log_msg_buffer() = default; 20 | explicit log_msg_buffer(const log_msg &orig_msg); 21 | log_msg_buffer(const log_msg_buffer &other); 22 | log_msg_buffer(log_msg_buffer &&other) SPDLOG_NOEXCEPT; 23 | log_msg_buffer &operator=(const log_msg_buffer &other); 24 | log_msg_buffer &operator=(log_msg_buffer &&other) SPDLOG_NOEXCEPT; 25 | }; 26 | 27 | } // namespace details 28 | } // namespace spdlog 29 | 30 | #ifdef SPDLOG_HEADER_ONLY 31 | #include "log_msg_buffer-inl.h" 32 | #endif 33 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/FindLibraw.cmake: -------------------------------------------------------------------------------- 1 | # - Try to find libraw 2 | # 3 | # libraw_FOUND - system has libraw 4 | # libraw_INCLUDE_DIRS - the libraw include directories 5 | # libraw_LIBRARIES - link these to use libraw 6 | 7 | FIND_PATH( 8 | libraw_INCLUDE_DIRS 9 | NAMES libraw/libraw.h 10 | PATHS 11 | ${LIBRAW_DIR} 12 | ${LIBRAW_DIR}/include 13 | /usr/include/ 14 | /usr/local/include 15 | /opt/local/include 16 | ) 17 | 18 | FIND_LIBRARY( 19 | libraw_LIBRARIES 20 | NAMES raw_r 21 | PATHS 22 | ${LIBRAW_DIR} 23 | ${LIBRAW_DIR}/lib 24 | /usr/lib 25 | /usr/local/lib 26 | /opt/local/lib 27 | ) 28 | 29 | IF (libraw_INCLUDE_DIRS AND libraw_LIBRARIES) 30 | SET(libraw_FOUND TRUE) 31 | ENDIF (libraw_INCLUDE_DIRS AND libraw_LIBRARIES) 32 | 33 | IF (libraw_FOUND) 34 | IF (NOT libraw_FIND_QUIETLY) 35 | MESSAGE(STATUS "Found libraw: ${libraw_LIBRARIES}") 36 | ENDIF (NOT libraw_FIND_QUIETLY) 37 | ELSE (libraw_FOUND) 38 | IF (libraw_FIND_REQUIRED) 39 | MESSAGE(FATAL_ERROR "Could not find libraw") 40 | ENDIF (libraw_FIND_REQUIRED) 41 | ENDIF (libraw_FOUND) 42 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_display/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | get_filename_component(COMPONENT ${CMAKE_CURRENT_LIST_DIR} NAME) 2 | 3 | target_sources( ${COMPONENT} 4 | PRIVATE 5 | ${CMAKE_CURRENT_LIST_DIR}/src/display.cpp 6 | ${CMAKE_CURRENT_LIST_DIR}/src/process.cpp 7 | ${CMAKE_CURRENT_LIST_DIR}/src/pangolin_gl.cpp 8 | ${CMAKE_CURRENT_LIST_DIR}/src/handler.cpp 9 | ${CMAKE_CURRENT_LIST_DIR}/src/handler_image.cpp 10 | ${CMAKE_CURRENT_LIST_DIR}/src/handler_glbuffer.cpp 11 | ${CMAKE_CURRENT_LIST_DIR}/src/view.cpp 12 | ${CMAKE_CURRENT_LIST_DIR}/src/widgets.cpp 13 | ${CMAKE_CURRENT_LIST_DIR}/src/image_view.cpp 14 | ${CMAKE_CURRENT_LIST_DIR}/src/ConsoleView.cpp 15 | ${CMAKE_CURRENT_LIST_DIR}/src/default_font.cpp 16 | ) 17 | 18 | target_link_libraries(${COMPONENT} PUBLIC pango_core pango_opengl pango_windowing pango_vars ) 19 | 20 | target_include_directories(${COMPONENT} PUBLIC 21 | $ 22 | $ 23 | ) 24 | install(DIRECTORY "${CMAKE_CURRENT_LIST_DIR}/include" 25 | DESTINATION ${CMAKE_INSTALL_PREFIX} 26 | ) 27 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/details/null_mutex.h: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #pragma once 5 | 6 | #include 7 | #include 8 | // null, no cost dummy "mutex" and dummy "atomic" int 9 | 10 | namespace spdlog { 11 | namespace details { 12 | struct null_mutex { 13 | void lock() const {} 14 | void unlock() const {} 15 | }; 16 | 17 | struct null_atomic_int { 18 | int value; 19 | null_atomic_int() = default; 20 | 21 | explicit null_atomic_int(int new_value) 22 | : value(new_value) {} 23 | 24 | int load(std::memory_order = std::memory_order_relaxed) const { return value; } 25 | 26 | void store(int new_value, std::memory_order = std::memory_order_relaxed) { value = new_value; } 27 | 28 | int exchange(int new_value, std::memory_order = std::memory_order_relaxed) { 29 | std::swap(new_value, value); 30 | return new_value; // return value before the call 31 | } 32 | }; 33 | 34 | } // namespace details 35 | } // namespace spdlog 36 | -------------------------------------------------------------------------------- /thirdparty/spdlog/INSTALL: -------------------------------------------------------------------------------- 1 | Header Only Version 2 | ================================================================== 3 | Just copy the files to your build tree and use a C++11 compiler. 4 | Or use CMake: 5 | ``` 6 | add_executable(example_header_only example.cpp) 7 | target_link_libraries(example_header_only spdlog::spdlog_header_only) 8 | ``` 9 | 10 | Compiled Library Version 11 | ================================================================== 12 | CMake: 13 | ``` 14 | add_executable(example example.cpp) 15 | target_link_libraries(example spdlog::spdlog) 16 | ``` 17 | 18 | Or copy files src/*.cpp to your build tree and pass the -DSPDLOG_COMPILED_LIB to the compiler. 19 | 20 | Important Information for Compilation: 21 | ================================================================== 22 | * If you encounter compilation errors with gcc 4.8.x, please note that gcc 4.8.x does not fully support C++11. In such cases, consider upgrading your compiler or using a different version that fully supports C++11 standards 23 | 24 | Tested on: 25 | gcc 4.8.1 and above 26 | clang 3.5 27 | Visual Studio 2013 -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2025 Seungwon Choi 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. -------------------------------------------------------------------------------- /src/util/StringUtils.h: -------------------------------------------------------------------------------- 1 | /** 2 | * @file StringUtils.h 3 | * @brief Common string utility functions for lightweight VIO. 4 | * @author Seungwon Choi (csw3575@snu.ac.kr) 5 | * @date 2025-11-06 6 | * @copyright Copyright (c) 2025 Seungwon Choi. All rights reserved. 7 | * 8 | * @par License 9 | * This project is released under the MIT License. 10 | */ 11 | 12 | #ifndef LIGHTWEIGHT_VIO_STRING_UTILS_H 13 | #define LIGHTWEIGHT_VIO_STRING_UTILS_H 14 | 15 | #include 16 | #include 17 | 18 | namespace lightweight_vio { 19 | namespace utils { 20 | 21 | /** 22 | * @brief Trim whitespace characters from both ends of a string 23 | * @param str Input string 24 | * @return Trimmed string 25 | */ 26 | std::string trim(const std::string& str); 27 | 28 | /** 29 | * @brief Split a string by delimiter 30 | * @param str Input string 31 | * @param delimiter Delimiter character 32 | * @return Vector of split strings 33 | */ 34 | std::vector split(const std::string& str, char delimiter); 35 | 36 | } // namespace utils 37 | } // namespace lightweight_vio 38 | 39 | #endif // LIGHTWEIGHT_VIO_STRING_UTILS_H 40 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_plot/include/pangolin/plot/loaders/csv_table_loader.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include "table_loader.h" 6 | 7 | namespace pangolin { 8 | 9 | class CsvTableLoader : public TableLoaderInterface 10 | { 11 | public: 12 | /// Construct to read from the set of files \param csv_files such that 13 | /// each row consists of the columns of each file in the provided order 14 | /// 15 | /// \param csv_files a list of CSV files to read from 16 | /// \param delim the field delimiter between columns, normally ',' for CSV 17 | CsvTableLoader(const std::vector& csv_files, char delim = ',', char comment = '#'); 18 | 19 | bool SkipLines(const std::vector& lines_per_input); 20 | 21 | bool ReadRow(std::vector& row) override; 22 | 23 | private: 24 | static bool AppendColumns(std::vector& cols, std::istream& s, char delim, char comment); 25 | 26 | char delim; 27 | char comment; 28 | std::vector streams; 29 | std::vector> owned_streams; 30 | }; 31 | 32 | } 33 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_video/tests/tests_video_loading.cpp: -------------------------------------------------------------------------------- 1 | #define CATCH_CONFIG_MAIN 2 | #include 3 | 4 | #include 5 | #include 6 | 7 | TEST_CASE( "Loading built in video driver" ) { 8 | // If this throws, we've probably messed up the factory loading stuff again... 9 | auto video = pangolin::OpenVideo("test:[size=123x345,n=1,fmt=RGB24]//"); 10 | 11 | REQUIRE(video.get()); 12 | REQUIRE(video->SizeBytes() == 123*345*3); 13 | REQUIRE(video->Streams().size() == 1); 14 | REQUIRE(video->Streams()[0].PixFormat().format == "RGB24"); 15 | REQUIRE(video->Streams()[0].Width() == 123); 16 | REQUIRE(video->Streams()[0].Height() == 345); 17 | 18 | std::unique_ptr image(new unsigned char[video->SizeBytes()]); 19 | const bool success = video->GrabNext(image.get()); 20 | REQUIRE(success); 21 | } 22 | 23 | TEST_CASE( "Error when providing the wrong arguments" ) 24 | { 25 | REQUIRE_THROWS_AS(pangolin::OpenVideo("test:[width=123,height=345,n=3,fmt=RGB24]//"), pangolin::FactoryRegistry::ParameterMismatchException); 26 | } 27 | -------------------------------------------------------------------------------- /src/util/StringUtils.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * @file StringUtils.cpp 3 | * @brief Implementation of common string utility functions. 4 | * @author Seungwon Choi (csw3575@snu.ac.kr) 5 | * @date 2025-11-06 6 | * @copyright Copyright (c) 2025 Seungwon Choi. All rights reserved. 7 | * 8 | * @par License 9 | * This project is released under the MIT License. 10 | */ 11 | 12 | #include "StringUtils.h" 13 | #include 14 | 15 | namespace lightweight_vio { 16 | namespace utils { 17 | 18 | std::string trim(const std::string& str) { 19 | size_t first = str.find_first_not_of(" \t\r\n"); 20 | if (first == std::string::npos) return ""; 21 | size_t last = str.find_last_not_of(" \t\r\n"); 22 | return str.substr(first, (last - first + 1)); 23 | } 24 | 25 | std::vector split(const std::string& str, char delimiter) { 26 | std::vector tokens; 27 | std::stringstream ss(str); 28 | std::string token; 29 | 30 | while (std::getline(ss, token, delimiter)) { 31 | tokens.push_back(token); 32 | } 33 | 34 | return tokens; 35 | } 36 | 37 | } // namespace utils 38 | } // namespace lightweight_vio 39 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_video/include/pangolin/video/drivers/shared_memory.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | #include 8 | #include 9 | 10 | namespace pangolin 11 | { 12 | 13 | class SharedMemoryVideo : public VideoInterface 14 | { 15 | public: 16 | SharedMemoryVideo(size_t w, size_t h, std::string pix_fmt, 17 | const std::shared_ptr& shared_memory, 18 | const std::shared_ptr& buffer_full); 19 | ~SharedMemoryVideo(); 20 | 21 | size_t SizeBytes() const; 22 | const std::vector& Streams() const; 23 | void Start(); 24 | void Stop(); 25 | bool GrabNext(unsigned char *image, bool wait); 26 | bool GrabNewest(unsigned char *image, bool wait); 27 | 28 | private: 29 | PixelFormat _fmt; 30 | size_t _frame_size; 31 | std::vector _streams; 32 | std::shared_ptr _shared_memory; 33 | std::shared_ptr _buffer_full; 34 | }; 35 | 36 | } 37 | -------------------------------------------------------------------------------- /thirdparty/Sophus/LICENSE.txt: -------------------------------------------------------------------------------- 1 | Copyright 2011-2017 Hauke Strasdat 2 | 2012-2017 Steven Lovegrove 3 | 4 | Permission is hereby granted, free of charge, to any person obtaining a copy 5 | of this software and associated documentation files (the "Software"), to 6 | deal in the Software without restriction, including without limitation the 7 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 8 | sell copies of the Software, and to permit persons to whom the Software is 9 | furnished to do so, subject to the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be included in 12 | all copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 17 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 18 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 19 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 20 | IN THE SOFTWARE. -------------------------------------------------------------------------------- /thirdparty/spdlog/cmake/version.rc.in: -------------------------------------------------------------------------------- 1 | #define APSTUDIO_READONLY_SYMBOLS 2 | #include 3 | #undef APSTUDIO_READONLY_SYMBOLS 4 | 5 | LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US 6 | 7 | 8 | VS_VERSION_INFO VERSIONINFO 9 | FILEVERSION @SPDLOG_VERSION_MAJOR@,@SPDLOG_VERSION_MINOR@,@SPDLOG_VERSION_PATCH@,0 10 | PRODUCTVERSION @SPDLOG_VERSION_MAJOR@,@SPDLOG_VERSION_MINOR@,@SPDLOG_VERSION_PATCH@,0 11 | FILEFLAGSMASK 0x3fL 12 | #ifdef _DEBUG 13 | FILEFLAGS 0x1L 14 | #else 15 | FILEFLAGS 0x0L 16 | #endif 17 | FILEOS 0x40004L 18 | FILETYPE 0x2L 19 | FILESUBTYPE 0x0L 20 | BEGIN 21 | BLOCK "StringFileInfo" 22 | BEGIN 23 | BLOCK "040904b0" 24 | BEGIN 25 | VALUE "FileDescription", "spdlog dll\0" 26 | VALUE "FileVersion", "@SPDLOG_VERSION@.0\0" 27 | VALUE "InternalName", "spdlog.dll\0" 28 | VALUE "LegalCopyright", "Copyright (C) spdlog\0" 29 | VALUE "ProductName", "spdlog\0" 30 | VALUE "ProductVersion", "@SPDLOG_VERSION@.0\0" 31 | END 32 | END 33 | BLOCK "VarFileInfo" 34 | BEGIN 35 | VALUE "Translation", 0x409, 1200 36 | END 37 | END 38 | 39 | 40 | 41 | 42 | 43 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/cfg/env.h: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #pragma once 5 | #include 6 | #include 7 | #include 8 | 9 | // 10 | // Init levels and patterns from env variables SPDLOG_LEVEL 11 | // Inspired from Rust's "env_logger" crate (https://crates.io/crates/env_logger). 12 | // Note - fallback to "info" level on unrecognized levels 13 | // 14 | // Examples: 15 | // 16 | // set global level to debug: 17 | // export SPDLOG_LEVEL=debug 18 | // 19 | // turn off all logging except for logger1: 20 | // export SPDLOG_LEVEL="*=off,logger1=debug" 21 | // 22 | 23 | // turn off all logging except for logger1 and logger2: 24 | // export SPDLOG_LEVEL="off,logger1=debug,logger2=info" 25 | 26 | namespace spdlog { 27 | namespace cfg { 28 | inline void load_env_levels(const char* var = "SPDLOG_LEVEL") { 29 | auto env_val = details::os::getenv(var); 30 | if (!env_val.empty()) { 31 | helpers::load_levels(env_val); 32 | } 33 | } 34 | 35 | } // namespace cfg 36 | } // namespace spdlog 37 | -------------------------------------------------------------------------------- /thirdparty/pangolin/LICENCE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2011 Steven Lovegrove and Richard Newcombe 2 | 3 | Permission is hereby granted, free of charge, to any person 4 | obtaining a copy of this software and associated documentation 5 | files (the "Software"), to deal in the Software without 6 | restriction, including without limitation the rights to use, 7 | copy, modify, merge, publish, distribute, sublicense, and/or sell 8 | copies of the Software, and to permit persons to whom the 9 | Software is furnished to do so, subject to the following 10 | conditions: 11 | 12 | The above copyright notice and this permission notice shall be 13 | included in all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 16 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 17 | OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 18 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 19 | HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 20 | WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 | OTHER DEALINGS IN THE SOFTWARE. 23 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_core/include/sigslot/LICENCE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2017 Pierre-Antoine Lacaze 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_core/include/NaturalSort/LICENSE.md: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2016 Gagan Kumar 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /thirdparty/Sophus/examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.24) 2 | 3 | project(SophusExample) 4 | 5 | file(READ "../SOPHUS_VERSION" SOPHUS_VERSION) 6 | find_package(Sophus ${SOPHUS_VERSION} REQUIRED) 7 | set(CMAKE_CXX_STANDARD 17) 8 | 9 | # Release by default Turn on Debug with "-DCMAKE_BUILD_TYPE=Debug" 10 | if(NOT CMAKE_BUILD_TYPE) 11 | set(CMAKE_BUILD_TYPE RelWithDebInfo) 12 | endif() 13 | 14 | # Tests to run 15 | set(EXAMPLE_SOURCES hello_so3 ensure_example) 16 | 17 | option(SOPHUS_ENABLE_ENSURE_HANDLER "Enable the custem ensure handler." OFF) 18 | if(SOPHUS_ENABLE_ENSURE_HANDLER) 19 | add_library(custom_ensure_handler custom_ensure_handler.cpp) 20 | target_link_libraries(custom_ensure_handler PRIVATE Sophus::Sophus) 21 | endif() 22 | 23 | foreach(example_src ${EXAMPLE_SOURCES}) 24 | add_executable(${example_src} ${example_src}.cpp) 25 | if(SOPHUS_ENABLE_ENSURE_HANDLER) 26 | target_compile_definitions(${example_src} 27 | PRIVATE SOPHUS_ENABLE_ENSURE_HANDLER=1) 28 | target_link_libraries(${example_src} Sophus::Sophus custom_ensure_handler) 29 | else() 30 | target_link_libraries(${example_src} Sophus::Sophus) 31 | endif() 32 | endforeach(example_src) 33 | -------------------------------------------------------------------------------- /thirdparty/Sophus/sophus_pybind/SophusPyBind.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "SE3PyBind.h" 4 | #include "SO3PyBind.h" 5 | 6 | #include 7 | // By default, Sophus calls std::abort when a pre-condition fails. Register a 8 | // handler that raises an exception so we don't crash the Python process. 9 | #ifdef SOPHUS_DISABLE_ENSURES 10 | #undef SOPHUS_DISABLE_ENSURES 11 | #endif 12 | #ifndef SOPHUS_ENABLE_ENSURE_HANDLER 13 | #define SOPHUS_ENABLE_ENSURE_HANDLER 14 | #endif 15 | 16 | namespace Sophus { 17 | inline void ensureFailed(char const* function, char const* file, int line, 18 | char const* description) { 19 | std::stringstream message; 20 | message << "'SOPHUS_ENSURE' failed in function '" << function 21 | << "', on line '" << line << "' of file '" << file 22 | << "'. Full description:" << std::endl 23 | << description; 24 | throw std::domain_error(message.str()); 25 | } 26 | 27 | inline void exportSophus(pybind11::module& module) { 28 | exportSO3Group(module, "SO3"); 29 | exportSE3Transformation(module, "SE3"); 30 | 31 | exportSE3Average(module); 32 | exportSE3Interpolate(module); 33 | } 34 | 35 | } // namespace Sophus 36 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/Findlibusb1.cmake: -------------------------------------------------------------------------------- 1 | # - Try to find libusb1 2 | # 3 | # libusb1_FOUND - system has libusb1 4 | # libusb1_INCLUDE_DIRS - the libusb1 include directories 5 | # libusb1_LIBRARIES - link these to use libusb1 6 | 7 | FIND_PATH( 8 | libusb1_INCLUDE_DIRS 9 | NAMES libusb-1.0/libusb.h 10 | PATHS 11 | c:/dev/sysroot32/usr/include 12 | ${CMAKE_SOURCE_DIR}/../libusb1/include 13 | /usr/include/ 14 | /usr/local/include 15 | /opt/local/include 16 | ) 17 | 18 | FIND_LIBRARY( 19 | libusb1_LIBRARIES 20 | NAMES usb-1.0 21 | PATHS 22 | c:/dev/sysroot32/usr/lib 23 | ${CMAKE_SOURCE_DIR}/../libusb1/lib 24 | /usr/lib 25 | /usr/lib64 26 | /usr/local/lib 27 | /opt/local/lib 28 | ) 29 | 30 | IF(libusb1_INCLUDE_DIRS AND libusb1_LIBRARIES) 31 | SET(libusb1_FOUND TRUE) 32 | ENDIF(libusb1_INCLUDE_DIRS AND libusb1_LIBRARIES) 33 | 34 | IF(libusb1_FOUND) 35 | IF(NOT libusb1_FIND_QUIETLY) 36 | MESSAGE(STATUS "Found libusb1: ${libusb1_LIBRARIES}") 37 | ENDIF(NOT libusb1_FIND_QUIETLY) 38 | ELSE(libusb1_FOUND) 39 | message(STATUS "libusb1 NOT found") 40 | IF(libusb1_FIND_REQUIRED) 41 | MESSAGE(FATAL_ERROR "Could not find libusb1") 42 | ENDIF(libusb1_FIND_REQUIRED) 43 | ENDIF(libusb1_FOUND) 44 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_core/include/NaturalSort/README.md: -------------------------------------------------------------------------------- 1 | # NaturalSort 2 | C++ Header File for Natural Comparison and Natural Sort 3 | 4 | 5 | ##### Calling Methods 6 | 7 | * __For Natural Sorting__ 8 | 9 | void SI::natural::sort(Container); 10 | 11 | void SI::natural::sort(IteratorBegin,IteratorEnd); 12 | 13 | void SI::natural::sort(CArray); 14 | 15 | 16 | * __For Natural Comparision__ 17 | 18 | bool SI::natural::compare(String lhs,String rhs); 19 | bool SI::natural::compare(char *const lhs,char *const rhs); 20 | 21 | Here we can have 22 | 23 | std::vector as Container 24 | String as std::string 25 | CArray as std::string[CArraySize] 26 | 27 | 28 | 29 | 30 | 31 | ##### Example 32 | 33 | * __Inputs__ 34 | 35 | Hello 100 36 | Hello 34 37 | Hello 9 38 | Hello 25 39 | Hello 10 40 | Hello 8 41 | 42 | * __Normal Sort Output__ 43 | 44 | Hello 10 45 | Hello 100 46 | Hello 25 47 | Hello 34 48 | Hello 8 49 | Hello 9 50 | 51 | * __Natural Sort Output__ 52 | 53 | Hello 8 54 | Hello 9 55 | Hello 10 56 | Hello 25 57 | Hello 34 58 | Hello 100 59 | 60 | 61 | 62 | -------------------------------------------------------------------------------- /thirdparty/spdlog/tests/includes.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #if defined(__GNUC__) && __GNUC__ == 12 4 | #pragma GCC diagnostic push 5 | #pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // Workaround for GCC 12 6 | #endif 7 | #include 8 | #if defined(__GNUC__) && __GNUC__ == 12 9 | #pragma GCC diagnostic pop 10 | #endif 11 | 12 | #include "utils.h" 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | 24 | #define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG 25 | 26 | #include "spdlog/spdlog.h" 27 | #include "spdlog/async.h" 28 | #include "spdlog/details/fmt_helper.h" 29 | #include "spdlog/details/os.h" 30 | 31 | #ifndef SPDLOG_NO_TLS 32 | #include "spdlog/mdc.h" 33 | #endif 34 | 35 | #include "spdlog/sinks/basic_file_sink.h" 36 | #include "spdlog/sinks/daily_file_sink.h" 37 | #include "spdlog/sinks/null_sink.h" 38 | #include "spdlog/sinks/ostream_sink.h" 39 | #include "spdlog/sinks/rotating_file_sink.h" 40 | #include "spdlog/sinks/stdout_color_sinks.h" 41 | #include "spdlog/sinks/msvc_sink.h" 42 | #include "spdlog/pattern_formatter.h" 43 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_core/include/pangolin/utils/variadic_all.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | namespace pangolin { 6 | 7 | template 8 | bool all_of(TPred pred, const T& i) 9 | { 10 | return pred(i); 11 | } 12 | 13 | template 14 | bool all_of(const TPred& pred, const T& i, const Targs& ... ins) 15 | { 16 | return pred(i) && all_of(pred, ins...); 17 | } 18 | 19 | template 20 | bool any_of(TPred pred, const T& i) 21 | { 22 | return pred(i); 23 | } 24 | 25 | template 26 | bool any_of(const TPred& pred, const T& i, Targs& ... ins) 27 | { 28 | return pred(i) || any_of(pred, ins...); 29 | } 30 | 31 | template 32 | bool all_found(const TContainer& c, const Targs& ... its) 33 | { 34 | using T1 = typename std::tuple_element<0, std::tuple>::type; 35 | return all_of([&c](const T1& it){return it != c.end();}, its...); 36 | } 37 | 38 | template 39 | bool all_equal(const T& v1, const Targs& ... its) 40 | { 41 | return all_of([v1](const T& o){return v1 == o;}, its...); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /thirdparty/spdlog/.github/workflows/macos.yml: -------------------------------------------------------------------------------- 1 | name: macos 2 | 3 | on: [push, pull_request] 4 | 5 | permissions: 6 | contents: read 7 | 8 | jobs: 9 | build: 10 | runs-on: macOS-latest 11 | name: "macOS Clang (C++11, Release)" 12 | strategy: 13 | fail-fast: true 14 | matrix: 15 | config: 16 | - USE_STD_FORMAT: 'ON' 17 | BUILD_EXAMPLE: 'OFF' 18 | - USE_STD_FORMAT: 'OFF' 19 | BUILD_EXAMPLE: 'ON' 20 | 21 | steps: 22 | - uses: actions/checkout@v4 23 | - name: Build 24 | run: | 25 | mkdir -p build && cd build 26 | cmake .. \ 27 | -DCMAKE_BUILD_TYPE=Release \ 28 | -DCMAKE_CXX_STANDARD=11 \ 29 | -DSPDLOG_BUILD_EXAMPLE=${{ matrix.config.BUILD_EXAMPLE }} \ 30 | -DSPDLOG_BUILD_EXAMPLE_HO=${{ matrix.config.BUILD_EXAMPLE }} \ 31 | -DSPDLOG_BUILD_WARNINGS=ON \ 32 | -DSPDLOG_BUILD_BENCH=OFF \ 33 | -DSPDLOG_BUILD_TESTS=ON \ 34 | -DSPDLOG_BUILD_TESTS_HO=OFF \ 35 | -DSPDLOG_USE_STD_FORMAT=${{ matrix.config.USE_STD_FORMAT }} \ 36 | -DSPDLOG_SANITIZE_ADDRESS=OFF 37 | make -j 4 38 | ctest -j 4 --output-on-failure 39 | -------------------------------------------------------------------------------- /thirdparty/spdlog/src/spdlog.cpp: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #ifndef SPDLOG_COMPILED_LIB 5 | #error Please define SPDLOG_COMPILED_LIB to compile this file. 6 | #endif 7 | 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | 21 | #include 22 | 23 | // template instantiate logger constructor with sinks init list 24 | template SPDLOG_API spdlog::logger::logger(std::string name, 25 | sinks_init_list::iterator begin, 26 | sinks_init_list::iterator end); 27 | template class SPDLOG_API spdlog::sinks::base_sink; 28 | template class SPDLOG_API spdlog::sinks::base_sink; 29 | -------------------------------------------------------------------------------- /thirdparty/spdlog/cmake/ide.cmake: -------------------------------------------------------------------------------- 1 | # --------------------------------------------------------------------------------------- 2 | # IDE support for headers 3 | # --------------------------------------------------------------------------------------- 4 | set(SPDLOG_HEADERS_DIR "${CMAKE_CURRENT_LIST_DIR}/../include") 5 | 6 | file(GLOB SPDLOG_TOP_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/*.h") 7 | file(GLOB SPDLOG_DETAILS_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/details/*.h") 8 | file(GLOB SPDLOG_SINKS_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/sinks/*.h") 9 | file(GLOB SPDLOG_FMT_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/fmt/*.h") 10 | file(GLOB SPDLOG_FMT_BUNDELED_HEADERS "${SPDLOG_HEADERS_DIR}/spdlog/fmt/bundled/*.h") 11 | set(SPDLOG_ALL_HEADERS ${SPDLOG_TOP_HEADERS} ${SPDLOG_DETAILS_HEADERS} ${SPDLOG_SINKS_HEADERS} ${SPDLOG_FMT_HEADERS} 12 | ${SPDLOG_FMT_BUNDELED_HEADERS}) 13 | 14 | source_group("Header Files\\spdlog" FILES ${SPDLOG_TOP_HEADERS}) 15 | source_group("Header Files\\spdlog\\details" FILES ${SPDLOG_DETAILS_HEADERS}) 16 | source_group("Header Files\\spdlog\\sinks" FILES ${SPDLOG_SINKS_HEADERS}) 17 | source_group("Header Files\\spdlog\\fmt" FILES ${SPDLOG_FMT_HEADERS}) 18 | source_group("Header Files\\spdlog\\fmt\\bundled\\" FILES ${SPDLOG_FMT_BUNDELED_HEADERS}) 19 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/Findpthread.cmake: -------------------------------------------------------------------------------- 1 | # - Try to find pthread 2 | # 3 | # pthread_FOUND - system has pthread 4 | # pthread_INCLUDE_DIRS - the pthread include directories 5 | # pthread_LIBRARIES - link these to use pthread 6 | 7 | FIND_PATH( 8 | pthread_INCLUDE_DIRS 9 | NAMES pthread.h 10 | PATHS 11 | c:/dev/sysroot32/usr/include 12 | ${CMAKE_SOURCE_DIR}/../pthread/include 13 | /usr/include/ 14 | /usr/local/include 15 | /opt/local/include 16 | ) 17 | 18 | FIND_LIBRARY( 19 | pthread_LIBRARIES 20 | NAMES pthreadVSE2 pthread 21 | PATHS 22 | c:/dev/sysroot32/usr/lib 23 | ${CMAKE_SOURCE_DIR}/../pthread/lib 24 | /usr/lib 25 | /usr/local/lib 26 | /opt/local/lib 27 | ) 28 | 29 | IF(pthread_INCLUDE_DIRS AND pthread_LIBRARIES) 30 | SET(pthread_FOUND TRUE) 31 | ENDIF(pthread_INCLUDE_DIRS AND pthread_LIBRARIES) 32 | 33 | IF(pthread_FOUND) 34 | IF(NOT pthread_FIND_QUIETLY) 35 | MESSAGE(STATUS "Found pthread: ${pthread_LIBRARIES}") 36 | ENDIF(NOT pthread_FIND_QUIETLY) 37 | ELSE(pthread_FOUND) 38 | message(STATUS "pthread NOT found") 39 | IF(pthread_FIND_REQUIRED) 40 | MESSAGE(FATAL_ERROR "Could not find pthread") 41 | ENDIF(pthread_FIND_REQUIRED) 42 | ENDIF(pthread_FOUND) 43 | -------------------------------------------------------------------------------- /thirdparty/spdlog/tests/test_circular_q.cpp: -------------------------------------------------------------------------------- 1 | #include "includes.h" 2 | #include "spdlog/details/circular_q.h" 3 | 4 | using q_type = spdlog::details::circular_q; 5 | TEST_CASE("test_size", "[circular_q]") { 6 | const size_t q_size = 4; 7 | q_type q(q_size); 8 | REQUIRE(q.size() == 0); 9 | REQUIRE(q.empty() == true); 10 | for (size_t i = 0; i < q_size; i++) { 11 | q.push_back(std::move(i)); 12 | } 13 | REQUIRE(q.size() == q_size); 14 | q.push_back(999); 15 | REQUIRE(q.size() == q_size); 16 | } 17 | 18 | TEST_CASE("test_rolling", "[circular_q]") { 19 | const size_t q_size = 4; 20 | q_type q(q_size); 21 | 22 | for (size_t i = 0; i < q_size + 2; i++) { 23 | q.push_back(std::move(i)); 24 | } 25 | 26 | REQUIRE(q.size() == q_size); 27 | 28 | REQUIRE(q.front() == 2); 29 | q.pop_front(); 30 | 31 | REQUIRE(q.front() == 3); 32 | q.pop_front(); 33 | 34 | REQUIRE(q.front() == 4); 35 | q.pop_front(); 36 | 37 | REQUIRE(q.front() == 5); 38 | q.pop_front(); 39 | 40 | REQUIRE(q.empty()); 41 | 42 | q.push_back(6); 43 | REQUIRE(q.front() == 6); 44 | } 45 | 46 | TEST_CASE("test_empty", "[circular_q]") { 47 | q_type q(0); 48 | q.push_back(1); 49 | REQUIRE(q.empty()); 50 | } -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/HelloPangolin/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int main( int /*argc*/, char** /*argv*/ ) 7 | { 8 | pangolin::CreateWindowAndBind("Main",640,480); 9 | glEnable(GL_DEPTH_TEST); 10 | 11 | // Define Projection and initial ModelView matrix 12 | pangolin::OpenGlRenderState s_cam( 13 | pangolin::ProjectionMatrix(640,480,420,420,320,240,0.2,100), 14 | pangolin::ModelViewLookAt(-2,2,-2, 0,0,0, pangolin::AxisY) 15 | ); 16 | 17 | // Create Interactive View in window 18 | pangolin::Handler3D handler(s_cam); 19 | pangolin::View& d_cam = pangolin::CreateDisplay() 20 | .SetBounds(0.0, 1.0, 0.0, 1.0, -640.0f/480.0f) 21 | .SetHandler(&handler); 22 | 23 | while( !pangolin::ShouldQuit() ) 24 | { 25 | // Clear screen and activate view to render into 26 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 27 | d_cam.Activate(s_cam); 28 | 29 | // Render OpenGL Cube 30 | pangolin::glDrawColouredCube(); 31 | 32 | // Swap frames and Process Events 33 | pangolin::FinishFrame(); 34 | } 35 | 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/PythonExamples/SimplePlot.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | import sys 3 | sys.path.append('../build/src') 4 | 5 | from OpenGL.GL import * 6 | import pypangolin as pango 7 | import math 8 | 9 | def main(): 10 | win = pango.CreateWindowAndBind("main py_pangolin", 640, 480) 11 | log = pango.DataLog() 12 | log.SetLabels(["sin(t)", "cos(t)", "sin(t)+cos(t)"]) 13 | 14 | t=0; 15 | tinc=0.01 16 | 17 | plotter = pango.Plotter(log,0,4*math.pi/tinc,-2,2,math.pi/(4*tinc),0.5); 18 | plotter.Track("$i") 19 | plotter.AddMarker(pango.Marker.Vertical, -1000, pango.Marker.LessThan, pango.Colour.Blue().WithAlpha(0.2)) 20 | plotter.AddMarker(pango.Marker.Horizontal, 100, pango.Marker.GreaterThan, pango.Colour.Red().WithAlpha(0.2)) 21 | plotter.AddMarker(pango.Marker.Horizontal, 10, pango.Marker.Equal, pango.Colour.Green().WithAlpha(0.2)) 22 | plotter.SetBounds(pango.Attach(0), pango.Attach(1), 23 | pango.Attach(0), pango.Attach(1)) 24 | 25 | pango.DisplayBase().AddDisplay(plotter) 26 | 27 | while not pango.ShouldQuit(): 28 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) 29 | 30 | log.Log(math.sin(t), math.cos(t), math.sin(t)+math.cos(t)) 31 | t+=tinc 32 | 33 | pango.FinishFrame() 34 | 35 | if __name__ == "__main__": 36 | main() 37 | -------------------------------------------------------------------------------- /Dockerfile: -------------------------------------------------------------------------------- 1 | # Use Ubuntu 22.04 as base image 2 | FROM ubuntu:20.04 3 | 4 | # Prevent interactive prompts during package installation 5 | ENV DEBIAN_FRONTEND=noninteractive 6 | ENV TZ=Asia/Seoul 7 | 8 | # Set working directory 9 | WORKDIR /workspace 10 | 11 | # Install system dependencies 12 | RUN apt-get update && apt-get install -y \ 13 | cmake \ 14 | build-essential \ 15 | libopencv-dev \ 16 | libeigen3-dev \ 17 | libgl1-mesa-dev \ 18 | libglu1-mesa-dev \ 19 | libglew-dev \ 20 | libyaml-cpp-dev \ 21 | libgflags-dev \ 22 | libgoogle-glog-dev \ 23 | libatlas-base-dev \ 24 | libsuitesparse-dev \ 25 | git \ 26 | wget \ 27 | && rm -rf /var/lib/apt/lists/* 28 | 29 | # Copy project files 30 | COPY . /workspace/ 31 | 32 | # Make build script executable 33 | RUN chmod +x build.sh 34 | 35 | # Build the project (skip apt install since dependencies are already installed) 36 | RUN sed -i '/sudo apt update/,/echo "System dependencies installed successfully!"/c\echo "Skipping system dependencies (already installed in Docker image)"' build.sh && \ 37 | ./build.sh 38 | 39 | # Set the entry point to a helper script 40 | COPY docker_entrypoint.sh /usr/local/bin/ 41 | RUN chmod +x /usr/local/bin/docker_entrypoint.sh 42 | ENTRYPOINT ["docker_entrypoint.sh"] 43 | 44 | # Default command (can be overridden) 45 | CMD ["--help"] 46 | -------------------------------------------------------------------------------- /thirdparty/Sophus/sophus/interpolate.hpp: -------------------------------------------------------------------------------- 1 | /// @file 2 | /// Interpolation for Lie groups. 3 | 4 | #pragma once 5 | 6 | #include 7 | 8 | #include "interpolate_details.hpp" 9 | 10 | namespace Sophus { 11 | 12 | /// This function interpolates between two Lie group elements ``foo_T_bar`` 13 | /// and ``foo_T_baz`` with an interpolation factor of ``alpha`` in [0, 1]. 14 | /// 15 | /// It returns a pose ``foo_T_quiz`` with ``quiz`` being a frame between ``bar`` 16 | /// and ``baz``. If ``alpha=0`` it returns ``foo_T_bar``. If it is 1, it returns 17 | /// ``foo_T_baz``. 18 | /// 19 | /// (Since interpolation on Lie groups is inverse-invariant, we can equivalently 20 | /// think of the input arguments as being ``bar_T_foo``, ``baz_T_foo`` and the 21 | /// return value being ``quiz_T_foo``.) 22 | /// 23 | /// Precondition: ``p`` must be in [0, 1]. 24 | /// 25 | template 26 | std::enable_if_t::supported, G> interpolate( 27 | G const& foo_T_bar, G const& foo_T_baz, Scalar2 p = Scalar2(0.5f)) { 28 | using Scalar = typename G::Scalar; 29 | Scalar inter_p(p); 30 | SOPHUS_ENSURE(inter_p >= Scalar(0) && inter_p <= Scalar(1), 31 | "p ({}) must in [0, 1].", (inter_p)); 32 | return foo_T_bar * G::exp(inter_p * (foo_T_bar.inverse() * foo_T_baz).log()); 33 | } 34 | 35 | } // namespace Sophus 36 | -------------------------------------------------------------------------------- /thirdparty/pangolin/tools/VideoJson/main-print.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | int main( int argc, char* argv[] ) 8 | { 9 | if( argc == 2) { 10 | const std::string filename = std::string(argv[1]); 11 | pangolin::PacketStreamReader reader(filename); 12 | 13 | // Extract JSON 14 | picojson::value all_properties; 15 | 16 | for(size_t i=0; i < reader.Sources().size(); ++i) { 17 | picojson::value source_props; 18 | 19 | const pangolin::PacketStreamSource& src = reader.Sources()[i]; 20 | source_props["device_properties"] = src.info["device"]; 21 | 22 | // Seek through index, loading frame properties 23 | for(size_t framenum=0; framenum < src.index.size(); ++framenum) { 24 | reader.Seek(src.id, framenum); 25 | pangolin::Packet pkt = reader.NextFrame(); 26 | source_props["frame_properties"].push_back(pkt.meta); 27 | } 28 | 29 | all_properties.push_back(source_props); 30 | } 31 | 32 | std::cout << all_properties.serialize(true) << std::endl; 33 | }else{ 34 | std::cout << "Usage: \n\tPangolinVideoJson filename.pango" << std::endl; 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/FindDepthSense.cmake: -------------------------------------------------------------------------------- 1 | # Try to find the DepthSense SDK For SoftKinetic Cameras 2 | # 3 | # DepthSense_INCLUDE_DIRS 4 | # DepthSense_LIBRARIES 5 | # DepthSense_FOUND 6 | 7 | FIND_PATH( DepthSense_INCLUDE_DIR DepthSense.hxx 8 | PATHS 9 | "${PROGRAM_FILES}/SoftKinetic/DepthSenseSDK/include" 10 | "${PROGRAM_FILES}/Meta/DepthSenseSDK/include" 11 | /usr/include 12 | /usr/local/include 13 | /opt/local/include 14 | /opt/softkinetic/DepthSenseSDK/include 15 | ) 16 | 17 | FIND_LIBRARY( DepthSense_LIBRARY DepthSense 18 | PATHS 19 | "${PROGRAM_FILES}/SoftKinetic/DepthSenseSDK/lib" 20 | "${PROGRAM_FILES}/Meta/DepthSenseSDK/lib" 21 | /usr/lib64 22 | /usr/lib 23 | /usr/local/lib 24 | /opt/local/lib 25 | /opt/softkinetic/DepthSenseSDK/lib 26 | ) 27 | 28 | IF(DepthSense_INCLUDE_DIR AND DepthSense_LIBRARY) 29 | SET( DepthSense_FOUND TRUE ) 30 | SET( DepthSense_LIBRARIES ${DepthSense_LIBRARY} ) 31 | SET( DepthSense_INCLUDE_DIRS ${DepthSense_INCLUDE_DIR} ) 32 | ENDIF() 33 | 34 | IF(DepthSense_FOUND) 35 | IF(NOT DepthSense_FIND_QUIETLY) 36 | MESSAGE(STATUS "Found DepthSense: ${DepthSense_LIBRARY}") 37 | ENDIF() 38 | ELSE() 39 | IF(DepthSense_FIND_REQUIRED) 40 | MESSAGE(FATAL_ERROR "Could not find DepthSense") 41 | ENDIF() 42 | ENDIF() 43 | 44 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/FindRealSense.cmake: -------------------------------------------------------------------------------- 1 | # -*- mode: cmake; -*- 2 | ############################################################################### 3 | # Find realsense https://github.com/IntelRealSense/librealsense 4 | # 5 | # This sets the following variables: 6 | # REALSENSE_FOUND - True if RealSense was found. 7 | # REALSENSE_INCLUDE_DIRS - Directories containing the RealSense include files. 8 | # REALSENSE_LIBRARIES - Libraries needed to use RealSense. 9 | # REALSENSE_DEFINITIONS - Compiler flags for RealSense. 10 | # 11 | # File forked from augmented_dev, project of alantrrs 12 | # (https://github.com/alantrrs/augmented_dev). 13 | 14 | find_package(PkgConfig) 15 | if(${CMAKE_VERSION} VERSION_LESS 2.8.2) 16 | endif() 17 | 18 | #add a hint so that it can find it without the pkg-config 19 | find_path(REALSENSE_INCLUDE_DIR librealsense/rs.h 20 | HINTS /usr/include/ /usr/local/include) 21 | #add a hint so that it can find it without the pkg-config 22 | find_library(REALSENSE_LIBRARY 23 | NAMES realsense 24 | HINTS /usr/lib /usr/local/lib ) 25 | 26 | set(REALSENSE_INCLUDE_DIRS ${REALSENSE_INCLUDE_DIR}) 27 | set(REALSENSE_LIBRARIES ${REALSENSE_LIBRARY}) 28 | 29 | include(FindPackageHandleStandardArgs) 30 | find_package_handle_standard_args(RealSense DEFAULT_MSG 31 | REALSENSE_LIBRARY REALSENSE_INCLUDE_DIR) 32 | 33 | mark_as_advanced(REALSENSE_LIBRARY REALSENSE_INCLUDE_DIR) 34 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_scene/include/pangolin/scene/tree.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace pangolin { 7 | 8 | template 9 | struct TreeNode 10 | { 11 | struct Edge 12 | { 13 | TEdge parent_child; 14 | TreeNode node; 15 | }; 16 | 17 | T item; 18 | std::vector edges; 19 | }; 20 | 21 | template 22 | using NodeFunction = std::function&,const TEdge&)>; 23 | 24 | //template 25 | //void VisitDepthFirst(TreeNode& node, const NodeFunction& func, const TEdge& T_root_node = TEdge()) 26 | //{ 27 | // func(node, T_root_node); 28 | // for(auto& e : node.edges) { 29 | // const TEdge T_root_child = T_root_node * e.parent_child; 30 | // VisitDepthFirst(e.node, func, T_root_child); 31 | // } 32 | //} 33 | 34 | //void Eg() 35 | //{ 36 | // using RenderNode = TreeNode,OpenGlMatrix>; 37 | 38 | // RenderNode root; 39 | // VisitDepthFirst,OpenGlMatrix>( 40 | // root, [](RenderNode& node, const OpenGlMatrix& T_root_node) { 41 | // if(node.item) { 42 | // node.item->DoRender(); 43 | // } 44 | // }, IdentityMatrix()); 45 | 46 | //} 47 | 48 | 49 | } 50 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/VBODisplay/kernal.cu: -------------------------------------------------------------------------------- 1 | // Colour Sine wave Kernal 2 | // Based on kernal_colour in kernelVBO.cpp by Rob Farber 3 | __global__ void kernel(float4* dVertexArray, uchar4 *dColorArray, 4 | unsigned int width, unsigned int height, float time) 5 | { 6 | unsigned int x = blockIdx.x*blockDim.x + threadIdx.x; 7 | unsigned int y = blockIdx.y*blockDim.y + threadIdx.y; 8 | 9 | // Each thread is unique point (u,v) in interval [-1,1],[-1,1] 10 | const float u = 2.0f* (x/(float)width) - 1.0f; 11 | const float v = 2.0f* (y/(float)height) - 1.0f; 12 | const float w = 0.5f * sinf(4.0f*u + time) * cosf(4.0f*v + time); 13 | 14 | // Update vertex array for point 15 | dVertexArray[y*width+x] = make_float4(u, w, v, 1.0f); 16 | 17 | // Update colour array for point 18 | dColorArray[y*width+x].w = 0.0f; 19 | dColorArray[y*width+x].x = 255.0f *0.5f*(1.f+sinf(w+x)); 20 | dColorArray[y*width+x].y = 255.0f *0.5f*(1.f+sinf(x)*cosf(y)); 21 | dColorArray[y*width+x].z = 255.0f *0.5f*(1.f+sinf(w+time/10.0f)); 22 | } 23 | 24 | extern "C" void launch_kernel(float4* dVertexArray, uchar4* dColourArray, 25 | unsigned int width, unsigned int height, float time) 26 | { 27 | dim3 block(8, 8, 1); 28 | dim3 grid(width / block.x, height / block.y, 1); 29 | kernel<<< grid, block>>>(dVertexArray, dColourArray, width, height, time); 30 | } 31 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/details/backtracer.h: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #pragma once 5 | 6 | #include 7 | #include 8 | 9 | #include 10 | #include 11 | #include 12 | 13 | // Store log messages in circular buffer. 14 | // Useful for storing debug data in case of error/warning happens. 15 | 16 | namespace spdlog { 17 | namespace details { 18 | class SPDLOG_API backtracer { 19 | mutable std::mutex mutex_; 20 | std::atomic enabled_{false}; 21 | circular_q messages_; 22 | 23 | public: 24 | backtracer() = default; 25 | backtracer(const backtracer &other); 26 | 27 | backtracer(backtracer &&other) SPDLOG_NOEXCEPT; 28 | backtracer &operator=(backtracer other); 29 | 30 | void enable(size_t size); 31 | void disable(); 32 | bool enabled() const; 33 | void push_back(const log_msg &msg); 34 | bool empty() const; 35 | 36 | // pop all items in the q and apply the given fun on each of them. 37 | void foreach_pop(std::function fun); 38 | }; 39 | 40 | } // namespace details 41 | } // namespace spdlog 42 | 43 | #ifdef SPDLOG_HEADER_ONLY 44 | #include "backtracer-inl.h" 45 | #endif 46 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_core/include/pangolin/utils/memstreambuf.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | #include 5 | 6 | namespace pangolin { 7 | 8 | // A simple streambuf wrapper around std::vector for memory buffer use 9 | struct memstreambuf : public std::streambuf 10 | { 11 | public: 12 | memstreambuf(size_t initial_buffer_size) 13 | { 14 | buffer.reserve(initial_buffer_size); 15 | } 16 | 17 | // Avoiding use of std::streambuf's move constructor, since it is missing for old GCC 18 | memstreambuf(memstreambuf&& o) 19 | : buffer(std::move(o.buffer)) 20 | { 21 | pubseekpos(o.pubseekoff(0, std::ios_base::cur)); 22 | } 23 | 24 | size_t size() const 25 | { 26 | return buffer.size(); 27 | } 28 | 29 | const unsigned char* data() const 30 | { 31 | return buffer.data(); 32 | } 33 | 34 | void clear() 35 | { 36 | buffer.clear(); 37 | } 38 | 39 | std::vector buffer; 40 | 41 | protected: 42 | std::streamsize xsputn(const char_type* __s, std::streamsize __n) override 43 | { 44 | buffer.insert(buffer.end(), __s, __s + __n); 45 | return __n; 46 | } 47 | 48 | int_type overflow(int_type __c) override 49 | { 50 | buffer.push_back( static_cast(__c) ); 51 | return __c; 52 | } 53 | }; 54 | 55 | } 56 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/details/log_msg.h: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #pragma once 5 | 6 | #include 7 | #include 8 | 9 | namespace spdlog { 10 | namespace details { 11 | struct SPDLOG_API log_msg { 12 | log_msg() = default; 13 | log_msg(log_clock::time_point log_time, 14 | source_loc loc, 15 | string_view_t logger_name, 16 | level::level_enum lvl, 17 | string_view_t msg); 18 | log_msg(source_loc loc, string_view_t logger_name, level::level_enum lvl, string_view_t msg); 19 | log_msg(string_view_t logger_name, level::level_enum lvl, string_view_t msg); 20 | log_msg(const log_msg &other) = default; 21 | log_msg &operator=(const log_msg &other) = default; 22 | 23 | string_view_t logger_name; 24 | level::level_enum level{level::off}; 25 | log_clock::time_point time; 26 | size_t thread_id{0}; 27 | 28 | // wrapping the formatted text with color (updated by pattern_formatter). 29 | mutable size_t color_range_start{0}; 30 | mutable size_t color_range_end{0}; 31 | 32 | source_loc source; 33 | string_view_t payload; 34 | }; 35 | } // namespace details 36 | } // namespace spdlog 37 | 38 | #ifdef SPDLOG_HEADER_ONLY 39 | #include "log_msg-inl.h" 40 | #endif 41 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/FindRealSense2.cmake: -------------------------------------------------------------------------------- 1 | # -*- mode: cmake; -*- 2 | ############################################################################### 3 | # Find realsense2 https://github.com/IntelRealSense/librealsense 4 | # 5 | # This sets the following variables: 6 | # REALSENSE2_FOUND - True if REALSENSE2 was found. 7 | # REALSENSE2_INCLUDE_DIRS - Directories containing the REALSENSE2 include files. 8 | # REALSENSE2_LIBRARIES - Libraries needed to use REALSENSE2. 9 | # REALSENSE2_DEFINITIONS - Compiler flags for REALSENSE2. 10 | # 11 | # File forked from augmented_dev, project of alantrrs 12 | # (https://github.com/alantrrs/augmented_dev). 13 | 14 | find_package(PkgConfig) 15 | if(${CMAKE_VERSION} VERSION_LESS 2.8.2) 16 | endif() 17 | 18 | #add a hint so that it can find it without the pkg-config 19 | find_path(REALSENSE2_INCLUDE_DIR librealsense2/rs.h 20 | HINTS /usr/include/ /usr/local/include) 21 | #add a hint so that it can find it without the pkg-config 22 | find_library(REALSENSE2_LIBRARY 23 | NAMES realsense2 24 | HINTS /usr/lib /usr/local/lib ) 25 | 26 | set(REALSENSE2_INCLUDE_DIRS ${REALSENSE2_INCLUDE_DIR}) 27 | set(REALSENSE2_LIBRARIES ${REALSENSE2_LIBRARY}) 28 | 29 | include(FindPackageHandleStandardArgs) 30 | find_package_handle_standard_args(RealSense2 DEFAULT_MSG 31 | REALSENSE2_LIBRARY REALSENSE2_INCLUDE_DIR) 32 | 33 | mark_as_advanced(REALSENSE2_LIBRARY REALSENSE2_INCLUDE_DIR) 34 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/cfg/argv.h: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #pragma once 5 | #include 6 | #include 7 | 8 | // 9 | // Init log levels using each argv entry that starts with "SPDLOG_LEVEL=" 10 | // 11 | // set all loggers to debug level: 12 | // example.exe "SPDLOG_LEVEL=debug" 13 | 14 | // set logger1 to trace level 15 | // example.exe "SPDLOG_LEVEL=logger1=trace" 16 | 17 | // turn off all logging except for logger1 and logger2: 18 | // example.exe "SPDLOG_LEVEL=off,logger1=debug,logger2=info" 19 | 20 | namespace spdlog { 21 | namespace cfg { 22 | 23 | // search for SPDLOG_LEVEL= in the args and use it to init the levels 24 | inline void load_argv_levels(int argc, const char **argv) { 25 | const std::string spdlog_level_prefix = "SPDLOG_LEVEL="; 26 | for (int i = 1; i < argc; i++) { 27 | std::string arg = argv[i]; 28 | if (arg.find(spdlog_level_prefix) == 0) { 29 | auto levels_string = arg.substr(spdlog_level_prefix.size()); 30 | helpers::load_levels(levels_string); 31 | } 32 | } 33 | } 34 | 35 | inline void load_argv_levels(int argc, char **argv) { 36 | load_argv_levels(argc, const_cast(argv)); 37 | } 38 | 39 | } // namespace cfg 40 | } // namespace spdlog 41 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/SetPlatformVars.cmake: -------------------------------------------------------------------------------- 1 | ## Compiler configuration 2 | IF(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_COMPILER_IS_GNUCC) 3 | SET(_GCC_ 1) 4 | ENDIF() 5 | 6 | IF(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang") 7 | SET(_CLANG_ 1) 8 | ENDIF() 9 | 10 | IF(MSVC) 11 | SET(_MSVC_ 1) 12 | ENDIF() 13 | 14 | ## Platform configuration 15 | 16 | IF(WIN32 OR WIN64) 17 | SET(_WIN_ 1) 18 | ENDIF() 19 | 20 | IF(UNIX) 21 | SET(_UNIX_ 1) 22 | ENDIF() 23 | 24 | IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin") 25 | SET(_OSX_ 1) 26 | ENDIF() 27 | 28 | IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux") 29 | SET(_LINUX_ 1) 30 | ENDIF() 31 | 32 | IF(ANDROID) 33 | SET(_ANDROID_ 1) 34 | ENDIF() 35 | 36 | IF(IOS) 37 | SET(_APPLE_IOS_ 1) 38 | ENDIF() 39 | 40 | 41 | 42 | ## Default search paths 43 | 44 | IF(_WIN_) 45 | IF(${CMAKE_CL_64}) 46 | LIST(APPEND CMAKE_INCLUDE_PATH "c:/dev/sysroot64/usr/include") 47 | LIST(APPEND CMAKE_LIBRARY_PATH "c:/dev/sysroot64/usr/lib") 48 | LIST(APPEND CMAKE_LIBRARY_PATH "c:/dev/sysroot64/usr/bin") 49 | set(PROGRAM_FILES "$ENV{PROGRAMW6432}" ) 50 | ELSE() 51 | LIST(APPEND CMAKE_INCLUDE_PATH "c:/dev/sysroot32/usr/include") 52 | LIST(APPEND CMAKE_LIBRARY_PATH "c:/dev/sysroot32/usr/lib") 53 | LIST(APPEND CMAKE_LIBRARY_PATH "c:/dev/sysroot32/usr/bin") 54 | set(PROGRAM_FILES "$ENV{PROGRAMFILES}" ) 55 | ENDIF() 56 | ENDIF() 57 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/sinks/ostream_sink.h: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #pragma once 5 | 6 | #include 7 | #include 8 | 9 | #include 10 | #include 11 | 12 | namespace spdlog { 13 | namespace sinks { 14 | template 15 | class ostream_sink final : public base_sink { 16 | public: 17 | explicit ostream_sink(std::ostream &os, bool force_flush = false) 18 | : ostream_(os), 19 | force_flush_(force_flush) {} 20 | ostream_sink(const ostream_sink &) = delete; 21 | ostream_sink &operator=(const ostream_sink &) = delete; 22 | 23 | protected: 24 | void sink_it_(const details::log_msg &msg) override { 25 | memory_buf_t formatted; 26 | base_sink::formatter_->format(msg, formatted); 27 | ostream_.write(formatted.data(), static_cast(formatted.size())); 28 | if (force_flush_) { 29 | ostream_.flush(); 30 | } 31 | } 32 | 33 | void flush_() override { ostream_.flush(); } 34 | 35 | std::ostream &ostream_; 36 | bool force_flush_; 37 | }; 38 | 39 | using ostream_sink_mt = ostream_sink; 40 | using ostream_sink_st = ostream_sink; 41 | 42 | } // namespace sinks 43 | } // namespace spdlog 44 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_core/include/pangolin/factory/factory_help.h: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | namespace pangolin { 6 | 7 | /// The level of detail to use when printing 8 | enum HelpVerbosity{ 9 | SUMMARY = 0, // Short description 10 | SYNOPSIS, // + examples, aliases 11 | PARAMS // + list all arguments 12 | }; 13 | 14 | /// Print to \p out general guidance on how to use Pangolin factory URL's 15 | /// \p out the stream to stream the help message to 16 | /// \p color whether ANSI Color codes should be used for formatting 17 | void PrintSchemeHelp(std::ostream& out = std::cout, bool color = true); 18 | 19 | /// Print to \p out Factories registered to \p registry that match \p scheme_filter. 20 | /// \p out the stream to stream the help message to 21 | /// \p registry the registy to use 22 | /// \p factory_type the typeid(T) of the FactoryInterface T to list 23 | /// \p scheme_filter a constraint on schemes to print, or empty if all should be listed 24 | /// \p level the level of detail to use when printing (see enum above) 25 | /// \p color whether ANSI Color codes should be used for formatting 26 | void PrintFactoryRegistryDetails( 27 | std::ostream& out, const pangolin::FactoryRegistry& registry, std::type_index factory_type, 28 | const std::string& scheme_filter = "", HelpVerbosity level = HelpVerbosity::SYNOPSIS, bool color = true 29 | ); 30 | 31 | } 32 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/tinyobj/src/tinyobj.cpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) 2011 Steven Lovegrove 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #define TINYOBJLOADER_IMPLEMENTATION 29 | #include 30 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/sinks/null_sink.h: -------------------------------------------------------------------------------- 1 | // Copyright(c) 2015-present, Gabi Melman & spdlog contributors. 2 | // Distributed under the MIT License (http://opensource.org/licenses/MIT) 3 | 4 | #pragma once 5 | 6 | #include 7 | #include 8 | #include 9 | 10 | #include 11 | 12 | namespace spdlog { 13 | namespace sinks { 14 | 15 | template 16 | class null_sink final : public base_sink { 17 | protected: 18 | void sink_it_(const details::log_msg &) override {} 19 | void flush_() override {} 20 | }; 21 | 22 | using null_sink_mt = null_sink; 23 | using null_sink_st = null_sink; 24 | 25 | } // namespace sinks 26 | 27 | template 28 | inline std::shared_ptr null_logger_mt(const std::string &logger_name) { 29 | auto null_logger = Factory::template create(logger_name); 30 | null_logger->set_level(level::off); 31 | return null_logger; 32 | } 33 | 34 | template 35 | inline std::shared_ptr null_logger_st(const std::string &logger_name) { 36 | auto null_logger = Factory::template create(logger_name); 37 | null_logger->set_level(level::off); 38 | return null_logger; 39 | } 40 | 41 | } // namespace spdlog 42 | -------------------------------------------------------------------------------- /thirdparty/spdlog/LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2016 Gabi Melman. 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in 13 | all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | THE SOFTWARE. 22 | 23 | -- NOTE: Third party dependency used by this software -- 24 | This software depends on the fmt lib (MIT License), 25 | and users must comply to its license: https://raw.githubusercontent.com/fmtlib/fmt/master/LICENSE 26 | 27 | -------------------------------------------------------------------------------- /thirdparty/spdlog/bench/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT) 2 | 3 | cmake_minimum_required(VERSION 3.11) 4 | project(spdlog_bench CXX) 5 | 6 | if(NOT TARGET spdlog) 7 | # Stand-alone build 8 | find_package(spdlog CONFIG REQUIRED) 9 | endif() 10 | 11 | find_package(Threads REQUIRED) 12 | find_package(benchmark CONFIG) 13 | if(NOT benchmark_FOUND) 14 | message(STATUS "Using CMake Version ${CMAKE_VERSION}") 15 | # User can fetch googlebenchmark 16 | message(STATUS "Downloading GoogleBenchmark") 17 | include(FetchContent) 18 | 19 | # disable tests 20 | set(BENCHMARK_ENABLE_TESTING OFF CACHE INTERNAL "") 21 | # Do not build and run googlebenchmark tests 22 | FetchContent_Declare(googlebenchmark GIT_REPOSITORY https://github.com/google/benchmark.git GIT_TAG v1.6.0) 23 | FetchContent_MakeAvailable(googlebenchmark) 24 | endif() 25 | 26 | add_executable(bench bench.cpp) 27 | spdlog_enable_warnings(bench) 28 | target_link_libraries(bench PRIVATE spdlog::spdlog) 29 | 30 | add_executable(async_bench async_bench.cpp) 31 | target_link_libraries(async_bench PRIVATE spdlog::spdlog) 32 | 33 | add_executable(latency latency.cpp) 34 | target_link_libraries(latency PRIVATE benchmark::benchmark spdlog::spdlog) 35 | 36 | add_executable(formatter-bench formatter-bench.cpp) 37 | target_link_libraries(formatter-bench PRIVATE benchmark::benchmark spdlog::spdlog) 38 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/image.cpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #include "image.hpp" 29 | #include 30 | 31 | namespace py_pangolin { 32 | 33 | } // py_pangolin 34 | 35 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin_embed.cpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Steven Lovegrove 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #include "pypangolin/pypangolin.h" 29 | 30 | PYBIND11_EMBEDDED_MODULE(pypangolin, m) { 31 | pypangolin::PopulateModule(m); 32 | } 33 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin_module.cpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Steven Lovegrove 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #include "pypangolin/pypangolin.h" 29 | 30 | PYBIND11_MODULE(pypangolin, m) { 31 | pypangolin::PopulateModule(m); 32 | } 33 | 34 | -------------------------------------------------------------------------------- /thirdparty/pangolin/cmake/EmscriptenUtils.cmake: -------------------------------------------------------------------------------- 1 | if(EMSCRIPTEN) 2 | macro( create_host_index_html filename prog_name) 3 | file( WRITE ${filename} 4 | " 5 | 6 | 7 | ${prog_name} 8 | 9 | 10 | 11 | 26 | 27 | 28 | ") 29 | endmacro() 30 | 31 | # Override add_executable to make webpage instead 32 | macro( add_executable prog_name) 33 | # Create manifest required for APK 34 | create_host_index_html("${CMAKE_CURRENT_BINARY_DIR}/index.html" "${prog_name}") 35 | _add_executable(${prog_name} ${ARGN}) 36 | endmacro() 37 | endif() 38 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_video/include/pangolin/video/video_record_repeat.h: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) 2011 Steven Lovegrove 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | // VideoInput subsumes the previous VideoRecordRepeat class. 31 | #include 32 | -------------------------------------------------------------------------------- /thirdparty/pangolin/examples/HelloPangolinOffscreen/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | int main( int /*argc*/, char** /*argv*/ ) 7 | { 8 | static const int w = 640; 9 | static const int h = 480; 10 | 11 | pangolin::CreateWindowAndBind("Main",w,h,pangolin::Params({{"scheme", "headless"}})); 12 | glEnable(GL_DEPTH_TEST); 13 | 14 | // Define Projection and initial ModelView matrix 15 | pangolin::OpenGlRenderState s_cam( 16 | pangolin::ProjectionMatrix(w,h,420,420,320,240,0.2,100), 17 | pangolin::ModelViewLookAt(-2,2,-2, 0,0,0, pangolin::AxisY) 18 | ); 19 | 20 | // create a frame buffer object with colour and depth buffer 21 | pangolin::GlTexture color_buffer(w,h); 22 | pangolin::GlRenderBuffer depth_buffer(w,h); 23 | pangolin::GlFramebuffer fbo_buffer(color_buffer, depth_buffer); 24 | 25 | fbo_buffer.Bind(); 26 | { 27 | // Clear screen and activate view to render into 28 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 29 | glViewport(0,0,w,h); 30 | s_cam.Apply(); 31 | 32 | // Render OpenGL Cube 33 | pangolin::glDrawColouredCube(); 34 | 35 | // Swap frames and Process Events 36 | pangolin::FinishFrame(); 37 | } 38 | fbo_buffer.Unbind(); 39 | 40 | // download and save the colour buffer 41 | color_buffer.Save("fbo.png", false); 42 | 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_opengl/include/pangolin/gl/compat/gl_es_compat.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | #define GLdouble GLfloat 6 | #define glClearDepth glClearDepthf 7 | #define glFrustum glFrustumf 8 | 9 | #define glColor4fv(a) glColor4f(a[0], a[1], a[2], a[3]) 10 | #define glColor3fv(a) glColor4f(a[0], a[1], a[2], 1.0f) 11 | #define glColor3f(a,b,c) glColor4f(a, b, c, 1.0f) 12 | 13 | #define glGenFramebuffersEXT glGenFramebuffers 14 | #define glDeleteFramebuffersEXT glDeleteFramebuffers 15 | #define glBindFramebufferEXT glBindFramebuffer 16 | #define glFramebufferTexture2DEXT glFramebufferTexture2D 17 | 18 | #define glGetDoublev glGetFloatv 19 | 20 | #include 21 | 22 | inline void glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) 23 | { 24 | GLfloat verts[] = { x1,y1, x2,y1, x2,y2, x1,y2 }; 25 | glEnableClientState(GL_VERTEX_ARRAY); 26 | glVertexPointer(2, GL_FLOAT, 0, verts); 27 | glDrawArrays(GL_TRIANGLE_FAN, 0, 4); 28 | glDisableClientState(GL_VERTEX_ARRAY); 29 | } 30 | 31 | inline void glRecti(int x1, int y1, int x2, int y2) 32 | { 33 | GLfloat verts[] = { (float)x1,(float)y1, (float)x2,(float)y1, 34 | (float)x2,(float)y2, (float)x1,(float)y2 }; 35 | glEnableClientState(GL_VERTEX_ARRAY); 36 | glVertexPointer(2, GL_FLOAT, 0, verts); 37 | glDrawArrays(GL_TRIANGLE_FAN, 0, 4); 38 | glDisableClientState(GL_VERTEX_ARRAY); 39 | } 40 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/gl.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | namespace py_pangolin { 33 | 34 | void bind_gl(pybind11::module &m); 35 | 36 | } // py_pangolin 37 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/glsl.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | namespace py_pangolin { 33 | 34 | void bind_glsl(pybind11::module &m); 35 | 36 | } // py_pangolin 37 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/glvbo.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | namespace py_pangolin { 33 | 34 | void bind_glvbo(pybind11::module &m); 35 | 36 | } // py_pangolin 37 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/colour.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | namespace py_pangolin { 33 | 34 | void bind_colour(pybind11::module& m); 35 | 36 | } // py_pangolin 37 | 38 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/display.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | namespace py_pangolin { 33 | 34 | void bind_display(pybind11::module &m); 35 | 36 | } // py_pangolin 37 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/video.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | namespace py_pangolin { 33 | 34 | void bind_video(pybind11::module& m); 35 | 36 | } // py_pangolin 37 | 38 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/view.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | namespace py_pangolin { 33 | 34 | void bind_view(pybind11::module &m); 35 | 36 | } // py_pangolin 37 | 38 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_geometry/include/pangolin/geometry/geometry_obj.h: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) 2011 Steven Lovegrove 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #include 29 | 30 | namespace pangolin { 31 | 32 | pangolin::Geometry LoadGeometryObj(const std::string& filename); 33 | 34 | } 35 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_opengl/src/gltexturecache.cpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) 2013 Steven Lovegrove 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #include 29 | 30 | namespace pangolin 31 | { 32 | 33 | TextureCache& TextureCache::I() { 34 | static TextureCache instance; 35 | return instance; 36 | } 37 | 38 | } -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/attach.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | namespace py_pangolin { 33 | 34 | void bind_attach(pybind11::module &m); 35 | 36 | } // py_pangolin 37 | 38 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/datalog.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | namespace py_pangolin { 33 | 34 | void bind_datalog(pybind11::module& m); 35 | 36 | } // py_pangolin 37 | 38 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/gl_draw.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | namespace py_pangolin { 33 | 34 | void bind_gl_draw(pybind11::module &m); 35 | 36 | } // py_pangolin 37 | 38 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/image_view.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Steven Lovegrove 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | 33 | namespace py_pangolin{ 34 | 35 | void bind_image_view(pybind11::module &m); 36 | 37 | } // py_pangolin 38 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/params.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | namespace py_pangolin { 33 | 34 | void bind_params(pybind11::module &m); 35 | 36 | } // py_pangolin 37 | 38 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/plotter.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | namespace py_pangolin { 33 | 34 | void bind_plotter(pybind11::module& m); 35 | 36 | } // py_pangolin 37 | 38 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/widget.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | namespace py_pangolin { 33 | 34 | void bind_widget(pybind11::module &m); 35 | 36 | } // py_pangolin 37 | 38 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/window.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | namespace py_pangolin { 33 | 34 | void bind_window(pybind11::module &m); 35 | 36 | } // py_pangolin 37 | 38 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/viewport.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | 33 | namespace py_pangolin{ 34 | 35 | void bind_viewport(pybind11::module &m); 36 | 37 | } // py_pangolin 38 | 39 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_video/src/video_help.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include 5 | #include 6 | 7 | namespace pangolin 8 | { 9 | 10 | void PrintPixelFormats(std::ostream& out, bool color) 11 | { 12 | const std::string c_normal = color ? "\033[0m" : ""; 13 | const std::string c_alias = color ? "\033[32m" : ""; 14 | 15 | out << "Supported pixel format codes (and their respective bits-per-pixel):" << std::endl; 16 | std::vector pixelFormats = pangolin::GetSupportedPixelFormats(); 17 | for(const auto& format: pixelFormats ){ 18 | out << c_alias << format.format << c_normal << " (" << format.bpp << "), "; 19 | } 20 | out << std::endl; 21 | } 22 | 23 | void VideoHelp( std::ostream& out, const std::string& scheme_filter, HelpVerbosity verbosity) 24 | { 25 | RegisterFactoriesVideoInterface(); 26 | 27 | #ifndef _WIN32_ 28 | const bool use_color = true; 29 | #else 30 | const bool use_color = false; 31 | #endif 32 | 33 | if( verbosity >= HelpVerbosity::SYNOPSIS ) { 34 | PrintSchemeHelp(out, use_color); 35 | out << std::endl; 36 | } 37 | 38 | PrintFactoryRegistryDetails(out, *FactoryRegistry::I(), typeid(VideoInterface), scheme_filter, verbosity, use_color); 39 | 40 | if( verbosity >= HelpVerbosity::PARAMS ) { 41 | PrintPixelFormats(out, use_color); 42 | } 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_opengl/src/compat/gl2engine.cpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) 2014 Steven Lovegrove 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #include 29 | 30 | namespace pangolin 31 | { 32 | 33 | GlEngine& glEngine() 34 | { 35 | static GlEngine engine; 36 | return engine; 37 | } 38 | 39 | } 40 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/pixel_format.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | namespace py_pangolin { 33 | 34 | void bind_pixel_format(pybind11::module& m); 35 | 36 | } // py_pangolin 37 | 38 | -------------------------------------------------------------------------------- /thirdparty/spdlog/include/spdlog/fmt/bundled/fmt.license.rst: -------------------------------------------------------------------------------- 1 | Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining 4 | a copy of this software and associated documentation files (the 5 | "Software"), to deal in the Software without restriction, including 6 | without limitation the rights to use, copy, modify, merge, publish, 7 | distribute, sublicense, and/or sell copies of the Software, and to 8 | permit persons to whom the Software is furnished to do so, subject to 9 | the following conditions: 10 | 11 | The above copyright notice and this permission notice shall be 12 | included in all copies or substantial portions of the Software. 13 | 14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 15 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 16 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 17 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 18 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 19 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 20 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 21 | 22 | --- Optional exception to the license --- 23 | 24 | As an exception, if, as a result of your compiling your source code, portions 25 | of this Software are embedded into a machine-executable object form of such 26 | source code, you may redistribute such embedded portions in such object form 27 | without including the above copyright and permission notices. 28 | -------------------------------------------------------------------------------- /thirdparty/pangolin/components/pango_python/src/pypangolin/opengl_render_state.hpp: -------------------------------------------------------------------------------- 1 | /* This file is part of the Pangolin Project. 2 | * http://github.com/stevenlovegrove/Pangolin 3 | * 4 | * Copyright (c) Andrey Mnatsakanov 5 | * 6 | * Permission is hereby granted, free of charge, to any person 7 | * obtaining a copy of this software and associated documentation 8 | * files (the "Software"), to deal in the Software without 9 | * restriction, including without limitation the rights to use, 10 | * copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | * copies of the Software, and to permit persons to whom the 12 | * Software is furnished to do so, subject to the following 13 | * conditions: 14 | * 15 | * The above copyright notice and this permission notice shall be 16 | * included in all copies or substantial portions of the Software. 17 | * 18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 19 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 20 | * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 21 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 22 | * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 23 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 24 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 25 | * OTHER DEALINGS IN THE SOFTWARE. 26 | */ 27 | 28 | #pragma once 29 | 30 | #include 31 | 32 | namespace py_pangolin { 33 | 34 | void bind_opengl_render_state(pybind11::module &m); 35 | 36 | } // py_pangolin 37 | 38 | --------------------------------------------------------------------------------