Full Code of ashishkumar822/Jetson-SLAM for AI

gitextract_tv5cnj3x/

├── .gitignore
├── CMakeLists.txt
├── Examples/
│   ├── Monocular/
│   │   ├── EuRoC.yaml
│   │   ├── EuRoC_TimeStamps/
│   │   │   ├── MH01.txt
│   │   │   ├── MH02.txt
│   │   │   ├── MH03.txt
│   │   │   ├── MH04.txt
│   │   │   ├── MH05.txt
│   │   │   ├── V101.txt
│   │   │   ├── V102.txt
│   │   │   ├── V103.txt
│   │   │   ├── V201.txt
│   │   │   ├── V202.txt
│   │   │   └── V203.txt
│   │   ├── KITTI00-02.yaml
│   │   ├── KITTI03.yaml
│   │   ├── KITTI04-12.yaml
│   │   ├── TUM1.yaml
│   │   ├── TUM2.yaml
│   │   ├── TUM3.yaml
│   │   ├── mono_euroc
│   │   ├── mono_euroc.cpp
│   │   ├── mono_kitti
│   │   ├── mono_kitti.cpp
│   │   ├── mono_live
│   │   ├── mono_live.cpp
│   │   ├── mono_tum
│   │   └── mono_tum.cpp
│   ├── RGB-D/
│   │   ├── TUM1.yaml
│   │   ├── TUM1_GPU.yaml
│   │   ├── TUM2.yaml
│   │   ├── TUM3.yaml
│   │   ├── associations/
│   │   │   ├── fr1_desk.txt
│   │   │   ├── fr1_desk2.txt
│   │   │   ├── fr1_room.txt
│   │   │   ├── fr1_xyz.txt
│   │   │   ├── fr2_desk.txt
│   │   │   ├── fr2_xyz.txt
│   │   │   ├── fr3_nstr_tex_near.txt
│   │   │   ├── fr3_office.txt
│   │   │   ├── fr3_office_val.txt
│   │   │   ├── fr3_str_tex_far.txt
│   │   │   └── fr3_str_tex_near.txt
│   │   ├── kinect.yaml
│   │   ├── rgbd_live
│   │   ├── rgbd_live.cpp
│   │   ├── rgbd_live.yaml
│   │   ├── rgbd_tum
│   │   └── rgbd_tum.cpp
│   └── Stereo/
│       ├── EuRoC.yaml
│       ├── EuRoC_TimeStamps/
│       │   ├── MH01.txt
│       │   ├── MH02.txt
│       │   ├── MH03.txt
│       │   ├── MH04.txt
│       │   ├── MH05.txt
│       │   ├── V101.txt
│       │   ├── V102.txt
│       │   ├── V103.txt
│       │   ├── V201.txt
│       │   ├── V202.txt
│       │   └── V203.txt
│       ├── KITTI00-02.yaml
│       ├── KITTI00-02_custom.yaml
│       ├── KITTI03.yaml
│       ├── KITTI04-12.yaml
│       ├── euroc_old/
│       │   ├── CameraTrajectory_MH01.txt
│       │   ├── CameraTrajectory_MH02.txt
│       │   ├── CameraTrajectory_MH03.txt
│       │   ├── CameraTrajectory_MH04.txt
│       │   └── CameraTrajectory_MH05.txt
│       ├── kaist_vio_dataset.yaml
│       ├── stereo_euroc
│       ├── stereo_euroc.cpp
│       ├── stereo_kitti
│       ├── stereo_kitti.cpp
│       ├── stereo_live
│       ├── stereo_live.cpp
│       └── stereo_rig_realsense.yaml
├── README.md
├── Thirdparty/
│   ├── DBoW2/
│   │   ├── CMakeLists.txt
│   │   ├── DBoW2/
│   │   │   ├── BowVector.cpp
│   │   │   ├── BowVector.h
│   │   │   ├── FClass.h
│   │   │   ├── FORB.cpp
│   │   │   ├── FORB.h
│   │   │   ├── FeatureVector.cpp
│   │   │   ├── FeatureVector.h
│   │   │   ├── ScoringObject.cpp
│   │   │   ├── ScoringObject.h
│   │   │   └── TemplatedVocabulary.h
│   │   ├── DUtils/
│   │   │   ├── Random.cpp
│   │   │   ├── Random.h
│   │   │   ├── Timestamp.cpp
│   │   │   └── Timestamp.h
│   │   ├── LICENSE.txt
│   │   └── README.txt
│   ├── g2o/
│   │   ├── CMakeLists.txt
│   │   ├── README.txt
│   │   ├── cmake_modules/
│   │   │   ├── FindBLAS.cmake
│   │   │   ├── FindEigen3.cmake
│   │   │   └── FindLAPACK.cmake
│   │   ├── config.h
│   │   ├── config.h.in
│   │   ├── g2o/
│   │   │   ├── core/
│   │   │   │   ├── base_binary_edge.h
│   │   │   │   ├── base_binary_edge.hpp
│   │   │   │   ├── base_edge.h
│   │   │   │   ├── base_multi_edge.h
│   │   │   │   ├── base_multi_edge.hpp
│   │   │   │   ├── base_unary_edge.h
│   │   │   │   ├── base_unary_edge.hpp
│   │   │   │   ├── base_vertex.h
│   │   │   │   ├── base_vertex.hpp
│   │   │   │   ├── batch_stats.cpp
│   │   │   │   ├── batch_stats.h
│   │   │   │   ├── block_solver.h
│   │   │   │   ├── block_solver.hpp
│   │   │   │   ├── cache.cpp
│   │   │   │   ├── cache.h
│   │   │   │   ├── creators.h
│   │   │   │   ├── eigen_types.h
│   │   │   │   ├── estimate_propagator.cpp
│   │   │   │   ├── estimate_propagator.h
│   │   │   │   ├── factory.cpp
│   │   │   │   ├── factory.h
│   │   │   │   ├── hyper_dijkstra.cpp
│   │   │   │   ├── hyper_dijkstra.h
│   │   │   │   ├── hyper_graph.cpp
│   │   │   │   ├── hyper_graph.h
│   │   │   │   ├── hyper_graph_action.cpp
│   │   │   │   ├── hyper_graph_action.h
│   │   │   │   ├── jacobian_workspace.cpp
│   │   │   │   ├── jacobian_workspace.h
│   │   │   │   ├── linear_solver.h
│   │   │   │   ├── marginal_covariance_cholesky.cpp
│   │   │   │   ├── marginal_covariance_cholesky.h
│   │   │   │   ├── matrix_operations.h
│   │   │   │   ├── matrix_structure.cpp
│   │   │   │   ├── matrix_structure.h
│   │   │   │   ├── openmp_mutex.h
│   │   │   │   ├── optimizable_graph.cpp
│   │   │   │   ├── optimizable_graph.h
│   │   │   │   ├── optimization_algorithm.cpp
│   │   │   │   ├── optimization_algorithm.h
│   │   │   │   ├── optimization_algorithm_dogleg.cpp
│   │   │   │   ├── optimization_algorithm_dogleg.h
│   │   │   │   ├── optimization_algorithm_factory.cpp
│   │   │   │   ├── optimization_algorithm_factory.h
│   │   │   │   ├── optimization_algorithm_gauss_newton.cpp
│   │   │   │   ├── optimization_algorithm_gauss_newton.h
│   │   │   │   ├── optimization_algorithm_levenberg.cpp
│   │   │   │   ├── optimization_algorithm_levenberg.h
│   │   │   │   ├── optimization_algorithm_property.h
│   │   │   │   ├── optimization_algorithm_with_hessian.cpp
│   │   │   │   ├── optimization_algorithm_with_hessian.h
│   │   │   │   ├── parameter.cpp
│   │   │   │   ├── parameter.h
│   │   │   │   ├── parameter_container.cpp
│   │   │   │   ├── parameter_container.h
│   │   │   │   ├── robust_kernel.cpp
│   │   │   │   ├── robust_kernel.h
│   │   │   │   ├── robust_kernel_factory.cpp
│   │   │   │   ├── robust_kernel_factory.h
│   │   │   │   ├── robust_kernel_impl.cpp
│   │   │   │   ├── robust_kernel_impl.h
│   │   │   │   ├── solver.cpp
│   │   │   │   ├── solver.h
│   │   │   │   ├── sparse_block_matrix.h
│   │   │   │   ├── sparse_block_matrix.hpp
│   │   │   │   ├── sparse_block_matrix_ccs.h
│   │   │   │   ├── sparse_block_matrix_diagonal.h
│   │   │   │   ├── sparse_block_matrix_test.cpp
│   │   │   │   ├── sparse_optimizer.cpp
│   │   │   │   └── sparse_optimizer.h
│   │   │   ├── solvers/
│   │   │   │   ├── linear_solver_dense.h
│   │   │   │   └── linear_solver_eigen.h
│   │   │   ├── stuff/
│   │   │   │   ├── color_macros.h
│   │   │   │   ├── macros.h
│   │   │   │   ├── misc.h
│   │   │   │   ├── os_specific.c
│   │   │   │   ├── os_specific.h
│   │   │   │   ├── property.cpp
│   │   │   │   ├── property.h
│   │   │   │   ├── string_tools.cpp
│   │   │   │   ├── string_tools.h
│   │   │   │   ├── timeutil.cpp
│   │   │   │   └── timeutil.h
│   │   │   └── types/
│   │   │       ├── se3_ops.h
│   │   │       ├── se3_ops.hpp
│   │   │       ├── se3quat.h
│   │   │       ├── sim3.h
│   │   │       ├── types_sba.cpp
│   │   │       ├── types_sba.h
│   │   │       ├── types_seven_dof_expmap.cpp
│   │   │       ├── types_seven_dof_expmap.h
│   │   │       ├── types_six_dof_expmap.cpp
│   │   │       └── types_six_dof_expmap.h
│   │   └── license-bsd.txt
│   └── g2o_new/
│       ├── CMakeLists.txt
│       ├── Makefile
│       ├── README.md
│       ├── benchmarks/
│       │   ├── CMakeLists.txt
│       │   └── jacobian_timing_tests.cpp
│       ├── cmake_modules/
│       │   ├── CheckIfUnderscorePrefixedBesselFunctionsExist.cmake
│       │   ├── Config.cmake.in
│       │   ├── FindCSparse.cmake
│       │   ├── FindEigen3.cmake
│       │   ├── FindG2O.cmake
│       │   ├── FindMETIS.cmake
│       │   ├── FindQGLViewer.cmake
│       │   └── FindSuiteSparse.cmake
│       ├── codecov.yml
│       ├── config.h
│       ├── config.h.in
│       ├── doc/
│       │   ├── .gitignore
│       │   ├── Makefile
│       │   ├── README_IF_IT_WAS_WORKING_AND_IT_DOES_NOT.txt
│       │   ├── doxygen/
│       │   │   ├── doxy.config
│       │   │   └── readme.txt
│       │   ├── g2o.tex
│       │   ├── license-bsd.txt
│       │   ├── license-gpl.txt
│       │   ├── license-lgpl.txt
│       │   ├── pics/
│       │   │   ├── classes.fig
│       │   │   ├── hgraph.fig
│       │   │   └── slam.fig
│       │   └── robots.bib
│       ├── g2o/
│       │   ├── .gitignore
│       │   ├── CMakeLists.txt
│       │   ├── EXTERNAL/
│       │   │   ├── CMakeLists.txt
│       │   │   └── freeglut/
│       │   │       ├── CMakeLists.txt
│       │   │       ├── COPYING
│       │   │       ├── freeglut_font.cpp
│       │   │       ├── freeglut_minimal.h
│       │   │       ├── freeglut_stroke_mono_roman.cpp
│       │   │       └── freeglut_stroke_roman.cpp
│       │   ├── apps/
│       │   │   ├── CMakeLists.txt
│       │   │   ├── g2o_cli/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── dl_wrapper.cpp
│       │   │   │   ├── dl_wrapper.h
│       │   │   │   ├── g2o.cpp
│       │   │   │   ├── g2o_cli_api.h
│       │   │   │   ├── g2o_common.cpp
│       │   │   │   ├── g2o_common.h
│       │   │   │   ├── output_helper.cpp
│       │   │   │   └── output_helper.h
│       │   │   ├── g2o_simulator/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── g2o_simulator_api.h
│       │   │   │   ├── pointsensorparameters.cpp
│       │   │   │   ├── pointsensorparameters.h
│       │   │   │   ├── sensor_line3d.cpp
│       │   │   │   ├── sensor_line3d.h
│       │   │   │   ├── sensor_odometry.h
│       │   │   │   ├── sensor_odometry2d.cpp
│       │   │   │   ├── sensor_odometry2d.h
│       │   │   │   ├── sensor_odometry3d.cpp
│       │   │   │   ├── sensor_odometry3d.h
│       │   │   │   ├── sensor_pointxy.cpp
│       │   │   │   ├── sensor_pointxy.h
│       │   │   │   ├── sensor_pointxy_bearing.cpp
│       │   │   │   ├── sensor_pointxy_bearing.h
│       │   │   │   ├── sensor_pointxy_offset.cpp
│       │   │   │   ├── sensor_pointxy_offset.h
│       │   │   │   ├── sensor_pointxyz.cpp
│       │   │   │   ├── sensor_pointxyz.h
│       │   │   │   ├── sensor_pointxyz_depth.cpp
│       │   │   │   ├── sensor_pointxyz_depth.h
│       │   │   │   ├── sensor_pointxyz_disparity.cpp
│       │   │   │   ├── sensor_pointxyz_disparity.h
│       │   │   │   ├── sensor_pose2d.cpp
│       │   │   │   ├── sensor_pose2d.h
│       │   │   │   ├── sensor_pose3d.cpp
│       │   │   │   ├── sensor_pose3d.h
│       │   │   │   ├── sensor_pose3d_offset.cpp
│       │   │   │   ├── sensor_pose3d_offset.h
│       │   │   │   ├── sensor_se3_prior.cpp
│       │   │   │   ├── sensor_se3_prior.h
│       │   │   │   ├── sensor_segment2d.cpp
│       │   │   │   ├── sensor_segment2d.h
│       │   │   │   ├── sensor_segment2d_line.cpp
│       │   │   │   ├── sensor_segment2d_line.h
│       │   │   │   ├── sensor_segment2d_pointline.cpp
│       │   │   │   ├── sensor_segment2d_pointline.h
│       │   │   │   ├── simulator.cpp
│       │   │   │   ├── simulator.h
│       │   │   │   ├── simulator2d.h
│       │   │   │   ├── simulator2d_base.h
│       │   │   │   ├── simulator2d_segment.cpp
│       │   │   │   ├── simulator3d.h
│       │   │   │   ├── simulator3d_base.h
│       │   │   │   ├── simutils.cpp
│       │   │   │   ├── simutils.h
│       │   │   │   ├── test_simulator2d.cpp
│       │   │   │   └── test_simulator3d.cpp
│       │   │   ├── g2o_viewer/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── base_main_window.ui
│       │   │   │   ├── base_properties_widget.ui
│       │   │   │   ├── g2o_qglviewer.cpp
│       │   │   │   ├── g2o_qglviewer.h
│       │   │   │   ├── g2o_viewer.cpp
│       │   │   │   ├── g2o_viewer_api.h
│       │   │   │   ├── gui_hyper_graph_action.cpp
│       │   │   │   ├── gui_hyper_graph_action.h
│       │   │   │   ├── main_window.cpp
│       │   │   │   ├── main_window.h
│       │   │   │   ├── properties_widget.cpp
│       │   │   │   ├── properties_widget.h
│       │   │   │   ├── run_g2o_viewer.cpp
│       │   │   │   ├── run_g2o_viewer.h
│       │   │   │   ├── stream_redirect.cpp
│       │   │   │   ├── stream_redirect.h
│       │   │   │   ├── viewer_properties_widget.cpp
│       │   │   │   └── viewer_properties_widget.h
│       │   │   └── linked_binaries/
│       │   │       └── CMakeLists.txt
│       │   ├── autodiff/
│       │   │   ├── CMakeLists.txt
│       │   │   ├── LICENSE
│       │   │   ├── array_selector.h
│       │   │   ├── autodiff.h
│       │   │   ├── disable_warnings.h
│       │   │   ├── eigen.h
│       │   │   ├── fixed_array.h
│       │   │   ├── integer_sequence_algorithm.h
│       │   │   ├── jet.h
│       │   │   ├── memory.h
│       │   │   ├── parameter_dims.h
│       │   │   ├── reenable_warnings.h
│       │   │   ├── types.h
│       │   │   └── variadic_evaluate.h
│       │   ├── core/
│       │   │   ├── CMakeLists.txt
│       │   │   ├── auto_differentiation.h
│       │   │   ├── base_binary_edge.h
│       │   │   ├── base_dynamic_vertex.h
│       │   │   ├── base_edge.h
│       │   │   ├── base_fixed_sized_edge.h
│       │   │   ├── base_fixed_sized_edge.hpp
│       │   │   ├── base_multi_edge.h
│       │   │   ├── base_unary_edge.h
│       │   │   ├── base_variable_sized_edge.h
│       │   │   ├── base_variable_sized_edge.hpp
│       │   │   ├── base_vertex.h
│       │   │   ├── base_vertex.hpp
│       │   │   ├── batch_stats.cpp
│       │   │   ├── batch_stats.h
│       │   │   ├── block_solver.h
│       │   │   ├── block_solver.hpp
│       │   │   ├── cache.cpp
│       │   │   ├── cache.h
│       │   │   ├── creators.h
│       │   │   ├── dynamic_aligned_buffer.hpp
│       │   │   ├── eigen_types.h
│       │   │   ├── estimate_propagator.cpp
│       │   │   ├── estimate_propagator.h
│       │   │   ├── factory.cpp
│       │   │   ├── factory.h
│       │   │   ├── g2o_core_api.h
│       │   │   ├── hyper_dijkstra.cpp
│       │   │   ├── hyper_dijkstra.h
│       │   │   ├── hyper_graph.cpp
│       │   │   ├── hyper_graph.h
│       │   │   ├── hyper_graph_action.cpp
│       │   │   ├── hyper_graph_action.h
│       │   │   ├── io_helper.h
│       │   │   ├── jacobian_workspace.cpp
│       │   │   ├── jacobian_workspace.h
│       │   │   ├── linear_solver.h
│       │   │   ├── marginal_covariance_cholesky.cpp
│       │   │   ├── marginal_covariance_cholesky.h
│       │   │   ├── matrix_operations.h
│       │   │   ├── matrix_structure.cpp
│       │   │   ├── matrix_structure.h
│       │   │   ├── openmp_mutex.h
│       │   │   ├── optimizable_graph.cpp
│       │   │   ├── optimizable_graph.h
│       │   │   ├── optimization_algorithm.cpp
│       │   │   ├── optimization_algorithm.h
│       │   │   ├── optimization_algorithm_dogleg.cpp
│       │   │   ├── optimization_algorithm_dogleg.h
│       │   │   ├── optimization_algorithm_factory.cpp
│       │   │   ├── optimization_algorithm_factory.h
│       │   │   ├── optimization_algorithm_gauss_newton.cpp
│       │   │   ├── optimization_algorithm_gauss_newton.h
│       │   │   ├── optimization_algorithm_levenberg.cpp
│       │   │   ├── optimization_algorithm_levenberg.h
│       │   │   ├── optimization_algorithm_property.h
│       │   │   ├── optimization_algorithm_with_hessian.cpp
│       │   │   ├── optimization_algorithm_with_hessian.h
│       │   │   ├── ownership.h
│       │   │   ├── parameter.cpp
│       │   │   ├── parameter.h
│       │   │   ├── parameter_container.cpp
│       │   │   ├── parameter_container.h
│       │   │   ├── robust_kernel.cpp
│       │   │   ├── robust_kernel.h
│       │   │   ├── robust_kernel_factory.cpp
│       │   │   ├── robust_kernel_factory.h
│       │   │   ├── robust_kernel_impl.cpp
│       │   │   ├── robust_kernel_impl.h
│       │   │   ├── solver.cpp
│       │   │   ├── solver.h
│       │   │   ├── sparse_block_matrix.h
│       │   │   ├── sparse_block_matrix.hpp
│       │   │   ├── sparse_block_matrix_ccs.h
│       │   │   ├── sparse_block_matrix_diagonal.h
│       │   │   ├── sparse_optimizer.cpp
│       │   │   ├── sparse_optimizer.h
│       │   │   ├── sparse_optimizer_terminate_action.cpp
│       │   │   └── sparse_optimizer_terminate_action.h
│       │   ├── examples/
│       │   │   ├── CMakeLists.txt
│       │   │   ├── anonymize_observations/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   └── g2o_anonymize_observations.cpp
│       │   │   ├── ba/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   └── ba_demo.cpp
│       │   │   ├── ba_anchored_inverse_depth/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   └── ba_anchored_inverse_depth_demo.cpp
│       │   │   ├── bal/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   └── bal_example.cpp
│       │   │   ├── calibration_odom_laser/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── closed_form_calibration.cpp
│       │   │   │   ├── closed_form_calibration.h
│       │   │   │   ├── edge_se2_pure_calib.cpp
│       │   │   │   ├── edge_se2_pure_calib.h
│       │   │   │   ├── g2o_calibration_odom_laser_api.h
│       │   │   │   ├── gm2dl_io.cpp
│       │   │   │   ├── gm2dl_io.h
│       │   │   │   ├── motion_information.h
│       │   │   │   ├── sclam_helpers.cpp
│       │   │   │   ├── sclam_helpers.h
│       │   │   │   ├── sclam_laser_calib.cpp
│       │   │   │   ├── sclam_odom_laser.cpp
│       │   │   │   └── sclam_pure_calibration.cpp
│       │   │   ├── convert_segment_line/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   └── convertSegmentLine.cpp
│       │   │   ├── data_convert/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   └── convert_sba_slam3d.cpp
│       │   │   ├── data_fitting/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── circle_fit.cpp
│       │   │   │   └── curve_fit.cpp
│       │   │   ├── dynamic_vertex/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── polynomial_fit.cpp
│       │   │   │   └── static_dynamic_function_fit.cpp
│       │   │   ├── g2o_hierarchical/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── backbone_tree_action.cpp
│       │   │   │   ├── backbone_tree_action.h
│       │   │   │   ├── edge_creator.cpp
│       │   │   │   ├── edge_creator.h
│       │   │   │   ├── edge_labeler.cpp
│       │   │   │   ├── edge_labeler.h
│       │   │   │   ├── edge_types_cost_function.cpp
│       │   │   │   ├── edge_types_cost_function.h
│       │   │   │   ├── g2o_hierarchical.cpp
│       │   │   │   ├── g2o_hierarchical_api.h
│       │   │   │   ├── simple_star_ops.cpp
│       │   │   │   ├── simple_star_ops.h
│       │   │   │   ├── star.cpp
│       │   │   │   └── star.h
│       │   │   ├── icp/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── gicp_demo.cpp
│       │   │   │   └── gicp_sba_demo.cpp
│       │   │   ├── interactive_slam/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── README.txt
│       │   │   │   ├── g2o_incremental/
│       │   │   │   │   ├── CMakeLists.txt
│       │   │   │   │   ├── README.txt
│       │   │   │   │   ├── g2o_incremental.cpp
│       │   │   │   │   ├── g2o_incremental_api.h
│       │   │   │   │   ├── graph_optimizer_sparse_incremental.cpp
│       │   │   │   │   ├── graph_optimizer_sparse_incremental.h
│       │   │   │   │   ├── linear_solver_cholmod_online.h
│       │   │   │   │   └── protocol.txt
│       │   │   │   ├── g2o_interactive/
│       │   │   │   │   ├── CMakeLists.txt
│       │   │   │   │   ├── fast_output.h
│       │   │   │   │   ├── g2o_interactive_api.h
│       │   │   │   │   ├── g2o_online.cpp
│       │   │   │   │   ├── g2o_slam_interface.cpp
│       │   │   │   │   ├── g2o_slam_interface.h
│       │   │   │   │   ├── generate_commands.cpp
│       │   │   │   │   ├── graph_optimizer_sparse_online.cpp
│       │   │   │   │   ├── graph_optimizer_sparse_online.h
│       │   │   │   │   ├── protocol.txt
│       │   │   │   │   ├── types_online.cpp
│       │   │   │   │   ├── types_slam2d_online.h
│       │   │   │   │   └── types_slam3d_online.h
│       │   │   │   └── slam_parser/
│       │   │   │       ├── CMakeLists.txt
│       │   │   │       ├── example/
│       │   │   │       │   ├── CMakeLists.txt
│       │   │   │       │   ├── example_slam_interface.cpp
│       │   │   │       │   ├── example_slam_interface.h
│       │   │   │       │   └── test_slam_interface.cpp
│       │   │   │       ├── interface/
│       │   │   │       │   ├── CMakeLists.txt
│       │   │   │       │   ├── abstract_slam_interface.h
│       │   │   │       │   ├── parser_interface.cpp
│       │   │   │       │   ├── parser_interface.h
│       │   │   │       │   ├── slam_context_interface.cpp
│       │   │   │       │   └── slam_context_interface.h
│       │   │   │       └── parser/
│       │   │   │           ├── CMakeLists.txt
│       │   │   │           ├── FlexLexer.h
│       │   │   │           ├── bison_parser.cpp
│       │   │   │           ├── bison_parser.h
│       │   │   │           ├── commands.h
│       │   │   │           ├── driver.cpp
│       │   │   │           ├── driver.h
│       │   │   │           ├── flex_scanner.cpp
│       │   │   │           ├── grammar.sh
│       │   │   │           ├── location.hh
│       │   │   │           ├── parser.yy
│       │   │   │           ├── position.hh
│       │   │   │           ├── scanner.h
│       │   │   │           ├── scanner.l
│       │   │   │           ├── slam_context.cpp
│       │   │   │           ├── slam_context.h
│       │   │   │           └── test_slam_parser.cpp
│       │   │   ├── line_slam/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── line_test.cpp
│       │   │   │   └── simulator_3d_line.cpp
│       │   │   ├── logging/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   └── logging.cpp
│       │   │   ├── plane_slam/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── plane_test.cpp
│       │   │   │   └── simulator_3d_plane.cpp
│       │   │   ├── sba/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   └── sba_demo.cpp
│       │   │   ├── sim3/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   └── optimize_sphere_by_sim3.cpp
│       │   │   ├── simple_optimize/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   └── simple_optimize.cpp
│       │   │   ├── slam2d/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── base_main_window.ui
│       │   │   │   ├── main_window.cpp
│       │   │   │   ├── main_window.h
│       │   │   │   ├── slam2d_g2o.cpp
│       │   │   │   ├── slam2d_viewer.cpp
│       │   │   │   └── slam2d_viewer.h
│       │   │   ├── sphere/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   └── create_sphere.cpp
│       │   │   ├── target/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── constant_velocity_target.cpp
│       │   │   │   ├── continuous_to_discrete.h
│       │   │   │   ├── static_target.cpp
│       │   │   │   ├── targetTypes3D.hpp
│       │   │   │   └── targetTypes6D.hpp
│       │   │   └── tutorial_slam2d/
│       │   │       ├── CMakeLists.txt
│       │   │       ├── edge_se2.cpp
│       │   │       ├── edge_se2.h
│       │   │       ├── edge_se2_pointxy.cpp
│       │   │       ├── edge_se2_pointxy.h
│       │   │       ├── g2o_tutorial_slam2d_api.h
│       │   │       ├── parameter_se2_offset.cpp
│       │   │       ├── parameter_se2_offset.h
│       │   │       ├── se2.h
│       │   │       ├── simulator.cpp
│       │   │       ├── simulator.h
│       │   │       ├── tutorial_slam2d.cpp
│       │   │       ├── types_tutorial_slam2d.cpp
│       │   │       ├── types_tutorial_slam2d.h
│       │   │       ├── vertex_point_xy.cpp
│       │   │       ├── vertex_point_xy.h
│       │   │       ├── vertex_se2.cpp
│       │   │       └── vertex_se2.h
│       │   ├── solvers/
│       │   │   ├── CMakeLists.txt
│       │   │   ├── cholmod/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── cholmod_ext.h
│       │   │   │   ├── cholmod_wrapper.cpp
│       │   │   │   ├── cholmod_wrapper.h
│       │   │   │   ├── linear_solver_cholmod.h
│       │   │   │   └── solver_cholmod.cpp
│       │   │   ├── csparse/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── csparse_extension.cpp
│       │   │   │   ├── csparse_extension.h
│       │   │   │   ├── csparse_helper.cpp
│       │   │   │   ├── csparse_helper.h
│       │   │   │   ├── csparse_wrapper.cpp
│       │   │   │   ├── csparse_wrapper.h
│       │   │   │   ├── g2o_csparse_api.h
│       │   │   │   ├── g2o_csparse_extension_api.h
│       │   │   │   ├── linear_solver_csparse.h
│       │   │   │   └── solver_csparse.cpp
│       │   │   ├── dense/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── linear_solver_dense.h
│       │   │   │   └── solver_dense.cpp
│       │   │   ├── eigen/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── linear_solver_eigen.h
│       │   │   │   └── solver_eigen.cpp
│       │   │   ├── pcg/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── linear_solver_pcg.h
│       │   │   │   ├── linear_solver_pcg.hpp
│       │   │   │   └── solver_pcg.cpp
│       │   │   ├── slam2d_linear/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── g2o_slam2d_linear_api.h
│       │   │   │   ├── slam2d_linear.cpp
│       │   │   │   ├── solver_slam2d_linear.cpp
│       │   │   │   └── solver_slam2d_linear.h
│       │   │   └── structure_only/
│       │   │       ├── CMakeLists.txt
│       │   │       ├── structure_only.cpp
│       │   │       └── structure_only_solver.h
│       │   ├── stuff/
│       │   │   ├── CMakeLists.txt
│       │   │   ├── color_macros.h
│       │   │   ├── command_args.cpp
│       │   │   ├── command_args.h
│       │   │   ├── filesys_tools.cpp
│       │   │   ├── filesys_tools.h
│       │   │   ├── g2o_stuff_api.h
│       │   │   ├── logger.cpp
│       │   │   ├── logger.h
│       │   │   ├── logger_format.h
│       │   │   ├── macros.h
│       │   │   ├── misc.h
│       │   │   ├── opengl_primitives.cpp
│       │   │   ├── opengl_primitives.h
│       │   │   ├── opengl_wrapper.h
│       │   │   ├── property.cpp
│       │   │   ├── property.h
│       │   │   ├── sampler.cpp
│       │   │   ├── sampler.h
│       │   │   ├── sparse_helper.cpp
│       │   │   ├── sparse_helper.h
│       │   │   ├── string_tools.cpp
│       │   │   ├── string_tools.h
│       │   │   ├── tictoc.cpp
│       │   │   ├── tictoc.h
│       │   │   ├── timeutil.cpp
│       │   │   ├── timeutil.h
│       │   │   ├── tuple_tools.h
│       │   │   └── unscented.h
│       │   ├── types/
│       │   │   ├── CMakeLists.txt
│       │   │   ├── data/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── data_queue.cpp
│       │   │   │   ├── data_queue.h
│       │   │   │   ├── g2o_types_data_api.h
│       │   │   │   ├── laser_parameters.cpp
│       │   │   │   ├── laser_parameters.h
│       │   │   │   ├── raw_laser.cpp
│       │   │   │   ├── raw_laser.h
│       │   │   │   ├── robot_data.cpp
│       │   │   │   ├── robot_data.h
│       │   │   │   ├── robot_laser.cpp
│       │   │   │   ├── robot_laser.h
│       │   │   │   ├── types_data.cpp
│       │   │   │   ├── types_data.h
│       │   │   │   ├── vertex_ellipse.cpp
│       │   │   │   ├── vertex_ellipse.h
│       │   │   │   ├── vertex_tag.cpp
│       │   │   │   └── vertex_tag.h
│       │   │   ├── icp/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── g2o_types_icp_api.h
│       │   │   │   ├── types_icp.cpp
│       │   │   │   └── types_icp.h
│       │   │   ├── sba/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── edge_project_p2mc.cpp
│       │   │   │   ├── edge_project_p2mc.h
│       │   │   │   ├── edge_project_p2sc.cpp
│       │   │   │   ├── edge_project_p2sc.h
│       │   │   │   ├── edge_project_psi2uv.cpp
│       │   │   │   ├── edge_project_psi2uv.h
│       │   │   │   ├── edge_project_stereo_xyz.cpp
│       │   │   │   ├── edge_project_stereo_xyz.h
│       │   │   │   ├── edge_project_stereo_xyz_onlypose.cpp
│       │   │   │   ├── edge_project_stereo_xyz_onlypose.h
│       │   │   │   ├── edge_project_xyz.cpp
│       │   │   │   ├── edge_project_xyz.h
│       │   │   │   ├── edge_project_xyz2uv.cpp
│       │   │   │   ├── edge_project_xyz2uv.h
│       │   │   │   ├── edge_project_xyz2uvu.cpp
│       │   │   │   ├── edge_project_xyz2uvu.h
│       │   │   │   ├── edge_project_xyz_onlypose.cpp
│       │   │   │   ├── edge_project_xyz_onlypose.h
│       │   │   │   ├── edge_sba_cam.cpp
│       │   │   │   ├── edge_sba_cam.h
│       │   │   │   ├── edge_sba_scale.cpp
│       │   │   │   ├── edge_sba_scale.h
│       │   │   │   ├── edge_se3_expmap.cpp
│       │   │   │   ├── edge_se3_expmap.h
│       │   │   │   ├── g2o_types_sba_api.h
│       │   │   │   ├── parameter_cameraparameters.cpp
│       │   │   │   ├── parameter_cameraparameters.h
│       │   │   │   ├── sba_utils.h
│       │   │   │   ├── sbacam.cpp
│       │   │   │   ├── sbacam.h
│       │   │   │   ├── types_sba.cpp
│       │   │   │   ├── types_sba.h
│       │   │   │   ├── types_six_dof_expmap.cpp
│       │   │   │   ├── types_six_dof_expmap.h
│       │   │   │   ├── vertex_cam.cpp
│       │   │   │   ├── vertex_cam.h
│       │   │   │   ├── vertex_intrinsics.cpp
│       │   │   │   ├── vertex_intrinsics.h
│       │   │   │   ├── vertex_se3_expmap.cpp
│       │   │   │   └── vertex_se3_expmap.h
│       │   │   ├── sclam2d/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── edge_se2_odom_differential_calib.cpp
│       │   │   │   ├── edge_se2_odom_differential_calib.h
│       │   │   │   ├── edge_se2_sensor_calib.cpp
│       │   │   │   ├── edge_se2_sensor_calib.h
│       │   │   │   ├── g2o_types_sclam2d_api.h
│       │   │   │   ├── odometry_measurement.cpp
│       │   │   │   ├── odometry_measurement.h
│       │   │   │   ├── types_sclam2d.cpp
│       │   │   │   ├── types_sclam2d.h
│       │   │   │   ├── vertex_odom_differential_params.cpp
│       │   │   │   └── vertex_odom_differential_params.h
│       │   │   ├── sim3/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── sim3.h
│       │   │   │   ├── types_seven_dof_expmap.cpp
│       │   │   │   └── types_seven_dof_expmap.h
│       │   │   ├── slam2d/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── edge_pointxy.cpp
│       │   │   │   ├── edge_pointxy.h
│       │   │   │   ├── edge_se2.cpp
│       │   │   │   ├── edge_se2.h
│       │   │   │   ├── edge_se2_lotsofxy.cpp
│       │   │   │   ├── edge_se2_lotsofxy.h
│       │   │   │   ├── edge_se2_offset.cpp
│       │   │   │   ├── edge_se2_offset.h
│       │   │   │   ├── edge_se2_pointxy.cpp
│       │   │   │   ├── edge_se2_pointxy.h
│       │   │   │   ├── edge_se2_pointxy_bearing.cpp
│       │   │   │   ├── edge_se2_pointxy_bearing.h
│       │   │   │   ├── edge_se2_pointxy_calib.cpp
│       │   │   │   ├── edge_se2_pointxy_calib.h
│       │   │   │   ├── edge_se2_pointxy_offset.cpp
│       │   │   │   ├── edge_se2_pointxy_offset.h
│       │   │   │   ├── edge_se2_prior.cpp
│       │   │   │   ├── edge_se2_prior.h
│       │   │   │   ├── edge_se2_twopointsxy.cpp
│       │   │   │   ├── edge_se2_twopointsxy.h
│       │   │   │   ├── edge_se2_xyprior.cpp
│       │   │   │   ├── edge_se2_xyprior.h
│       │   │   │   ├── edge_xy_prior.cpp
│       │   │   │   ├── edge_xy_prior.h
│       │   │   │   ├── g2o_types_slam2d_api.h
│       │   │   │   ├── parameter_se2_offset.cpp
│       │   │   │   ├── parameter_se2_offset.h
│       │   │   │   ├── se2.h
│       │   │   │   ├── types_slam2d.cpp
│       │   │   │   ├── types_slam2d.h
│       │   │   │   ├── vertex_point_xy.cpp
│       │   │   │   ├── vertex_point_xy.h
│       │   │   │   ├── vertex_se2.cpp
│       │   │   │   └── vertex_se2.h
│       │   │   ├── slam2d_addons/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── edge_line2d.cpp
│       │   │   │   ├── edge_line2d.h
│       │   │   │   ├── edge_line2d_pointxy.cpp
│       │   │   │   ├── edge_line2d_pointxy.h
│       │   │   │   ├── edge_se2_line2d.cpp
│       │   │   │   ├── edge_se2_line2d.h
│       │   │   │   ├── edge_se2_segment2d.cpp
│       │   │   │   ├── edge_se2_segment2d.h
│       │   │   │   ├── edge_se2_segment2d_line.cpp
│       │   │   │   ├── edge_se2_segment2d_line.h
│       │   │   │   ├── edge_se2_segment2d_pointLine.cpp
│       │   │   │   ├── edge_se2_segment2d_pointLine.h
│       │   │   │   ├── g2o_types_slam2d_addons_api.h
│       │   │   │   ├── line_2d.h
│       │   │   │   ├── types_slam2d_addons.cpp
│       │   │   │   ├── types_slam2d_addons.h
│       │   │   │   ├── vertex_line2d.cpp
│       │   │   │   ├── vertex_line2d.h
│       │   │   │   ├── vertex_segment2d.cpp
│       │   │   │   └── vertex_segment2d.h
│       │   │   ├── slam3d/
│       │   │   │   ├── CMakeLists.txt
│       │   │   │   ├── dquat2mat.cpp
│       │   │   │   ├── dquat2mat.h
│       │   │   │   ├── dquat2mat.wxm
│       │   │   │   ├── dquat2mat_maxima_generated.cpp
│       │   │   │   ├── edge_pointxyz.cpp
│       │   │   │   ├── edge_pointxyz.h
│       │   │   │   ├── edge_se3.cpp
│       │   │   │   ├── edge_se3.h
│       │   │   │   ├── edge_se3_lotsofxyz.cpp
│       │   │   │   ├── edge_se3_lotsofxyz.h
│       │   │   │   ├── edge_se3_offset.cpp
│       │   │   │   ├── edge_se3_offset.h
│       │   │   │   ├── edge_se3_pointxyz.cpp
│       │   │   │   ├── edge_se3_pointxyz.h
│       │   │   │   ├── edge_se3_pointxyz_depth.cpp
│       │   │   │   ├── edge_se3_pointxyz_depth.h
│       │   │   │   ├── edge_se3_pointxyz_disparity.cpp
│       │   │   │   ├── edge_se3_pointxyz_disparity.h
│       │   │   │   ├── edge_se3_prior.cpp
│       │   │   │   ├── edge_se3_prior.h
│       │   │   │   ├── edge_se3_xyzprior.cpp
│       │   │   │   ├── edge_se3_xyzprior.h
│       │   │   │   ├── edge_xyz_prior.cpp
│       │   │   │   ├── edge_xyz_prior.h
│       │   │   │   ├── g2o_types_slam3d_api.h
│       │   │   │   ├── isometry3d_gradients.cpp
│       │   │   │   ├── isometry3d_gradients.h
│       │   │   │   ├── isometry3d_mappings.cpp
│       │   │   │   ├── isometry3d_mappings.h
│       │   │   │   ├── parameter_camera.cpp
│       │   │   │   ├── parameter_camera.h
│       │   │   │   ├── parameter_se3_offset.cpp
│       │   │   │   ├── parameter_se3_offset.h
│       │   │   │   ├── parameter_stereo_camera.cpp
│       │   │   │   ├── parameter_stereo_camera.h
│       │   │   │   ├── se3_ops.h
│       │   │   │   ├── se3_ops.hpp
│       │   │   │   ├── se3quat.h
│       │   │   │   ├── types_slam3d.cpp
│       │   │   │   ├── types_slam3d.h
│       │   │   │   ├── vertex_pointxyz.cpp
│       │   │   │   ├── vertex_pointxyz.h
│       │   │   │   ├── vertex_se3.cpp
│       │   │   │   └── vertex_se3.h
│       │   │   └── slam3d_addons/
│       │   │       ├── CMakeLists.txt
│       │   │       ├── edge_plane.cpp
│       │   │       ├── edge_plane.h
│       │   │       ├── edge_se3_calib.cpp
│       │   │       ├── edge_se3_calib.h
│       │   │       ├── edge_se3_euler.cpp
│       │   │       ├── edge_se3_euler.h
│       │   │       ├── edge_se3_line.cpp
│       │   │       ├── edge_se3_line.h
│       │   │       ├── edge_se3_plane_calib.cpp
│       │   │       ├── edge_se3_plane_calib.h
│       │   │       ├── g2o_types_slam3d_addons_api.h
│       │   │       ├── line3d.cpp
│       │   │       ├── line3d.h
│       │   │       ├── plane3d.h
│       │   │       ├── types_slam3d_addons.cpp
│       │   │       ├── types_slam3d_addons.h
│       │   │       ├── vertex_line3d.cpp
│       │   │       ├── vertex_line3d.h
│       │   │       ├── vertex_plane.cpp
│       │   │       ├── vertex_plane.h
│       │   │       ├── vertex_se3_euler.cpp
│       │   │       └── vertex_se3_euler.h
│       │   └── what_is_in_these_directories.txt
│       ├── script/
│       │   ├── android.toolchain.cmake
│       │   ├── install-additional-deps-windows.bat
│       │   ├── install-deps-linux.sh
│       │   ├── install-deps-osx.sh
│       │   └── install-deps-windows.bat
│       └── unit_test/
│           ├── CMakeLists.txt
│           ├── data/
│           │   ├── CMakeLists.txt
│           │   ├── data_queue_tests.cpp
│           │   └── io_data.cpp
│           ├── general/
│           │   ├── CMakeLists.txt
│           │   ├── allocate_optimizer.cpp
│           │   ├── allocate_optimizer.h
│           │   ├── auto_diff.cpp
│           │   ├── base_fixed_sized_edge.cpp
│           │   ├── batch_statistics.cpp
│           │   ├── clear_and_redo.cpp
│           │   ├── graph_operations.cpp
│           │   ├── robust_kernel_tests.cpp
│           │   └── sparse_block_matrix.cpp
│           ├── sba/
│           │   ├── CMakeLists.txt
│           │   ├── io_sba.cpp
│           │   └── io_six_dof_expmap.cpp
│           ├── sclam2d/
│           │   ├── CMakeLists.txt
│           │   ├── io_sclam2d.cpp
│           │   └── odom_convert_sclam2d.cpp
│           ├── sim3/
│           │   ├── CMakeLists.txt
│           │   ├── allocate_sim3.cpp
│           │   ├── io_sim3.cpp
│           │   └── jacobians_sim3.cpp
│           ├── slam2d/
│           │   ├── CMakeLists.txt
│           │   ├── io_slam2d.cpp
│           │   ├── jacobians_slam2d.cpp
│           │   └── mappings_se2.cpp
│           ├── slam2d_addons/
│           │   ├── CMakeLists.txt
│           │   └── io_slam2d_addons.cpp
│           ├── slam3d/
│           │   ├── CMakeLists.txt
│           │   ├── io_slam3d.cpp
│           │   ├── jacobians_slam3d.cpp
│           │   ├── mappings_slam3d.cpp
│           │   ├── optimization_slam3d.cpp
│           │   └── orthogonal_matrix.cpp
│           ├── slam3d_addons/
│           │   ├── CMakeLists.txt
│           │   └── io_slam3d_addons.cpp
│           ├── solver/
│           │   ├── CMakeLists.txt
│           │   ├── allocate_algorithm_test.cpp
│           │   ├── linear_solver_test.cpp
│           │   ├── sparse_system_helper.cpp
│           │   └── sparse_system_helper.h
│           ├── stuff/
│           │   ├── CMakeLists.txt
│           │   ├── command_args_tests.cpp
│           │   ├── filesys_tools_tests.cpp
│           │   ├── misc_tests.cpp
│           │   ├── property_tests.cpp
│           │   ├── string_tools_tests.cpp
│           │   ├── tuple_tools_tests.cpp
│           │   └── unscented_tests.cpp
│           └── test_helper/
│               ├── eigen_matcher.h
│               ├── evaluate_jacobian.h
│               ├── io.h
│               ├── random_state.h
│               └── test_main.cpp
├── build.sh
├── cmake_modules/
│   └── FindEigen3.cmake
├── include/
│   ├── Converter.h
│   ├── Frame.h
│   ├── FrameDrawer.h
│   ├── Initializer.h
│   ├── KeyFrame.h
│   ├── KeyFrameDatabase.h
│   ├── LocalMapping.h
│   ├── LoopClosing.h
│   ├── Map.h
│   ├── MapDrawer.h
│   ├── MapPoint.h
│   ├── ORBVocabulary.h
│   ├── ORBextractor.h
│   ├── ORBmatcher.h
│   ├── Optimizer.h
│   ├── PnPsolver.h
│   ├── Sim3Solver.h
│   ├── System.h
│   ├── Tracking.h
│   ├── Viewer.h
│   ├── cuda/
│   │   ├── orb_gpu.hpp
│   │   ├── orb_matcher.hpp
│   │   ├── synced_mem_holder.hpp
│   │   └── tracking_gpu.hpp
│   ├── tictoc.hpp
│   └── tictoc_cuda.hpp
└── src/
    ├── Converter.cpp
    ├── Frame.cpp
    ├── FrameDrawer.cpp
    ├── Initializer.cpp
    ├── KeyFrame.cpp
    ├── KeyFrameDatabase.cpp
    ├── LocalMapping.cpp
    ├── LoopClosing.cpp
    ├── Map.cpp
    ├── MapDrawer.cpp
    ├── MapPoint.cpp
    ├── ORBextractor.cpp
    ├── ORBmatcher.cpp
    ├── Optimizer.cpp
    ├── PnPsolver.cpp
    ├── Sim3Solver.cpp
    ├── System.cpp
    ├── Tracking.cpp
    ├── Viewer.cpp
    └── cuda/
        ├── orb_FAST_apply_NMS_G.cu
        ├── orb_FAST_apply_NMS_L.cu
        ├── orb_FAST_apply_NMS_MS.cpp
        ├── orb_FAST_apply_NMS_MS.cu
        ├── orb_FAST_compute_score.cu
        ├── orb_FAST_obtain_keypoints.cpp
        ├── orb_FAST_orientation.cu
        ├── orb_bitpattern.cpp
        ├── orb_copy_output.cu
        ├── orb_descriptor.cu
        ├── orb_gaussian.cu
        ├── orb_gpu.cpp
        ├── orb_matcher.cu
        ├── orb_pyramid.cu
        ├── orb_stereo_match.cu
        ├── synced_mem_holder.cpp
        └── tracking_isinfrustum.cu

SYMBOL INDEX (1760 symbols across 680 files)

FILE: Examples/Monocular/mono_euroc.cpp
  function main (line 38) | int main(int argc, char **argv)
  function LoadImages (line 135) | void LoadImages(const string &strImagePath, const string &strPathTimes,

FILE: Examples/Monocular/mono_kitti.cpp
  function main (line 39) | int main(int argc, char **argv)
  function LoadImages (line 129) | void LoadImages(const string &strPathToSequence, vector<string> &vstrIma...

FILE: Examples/Monocular/mono_live.cpp
  function main (line 18) | int main(int argc, char **argv)

FILE: Examples/Monocular/mono_tum.cpp
  function main (line 38) | int main(int argc, char **argv)
  function LoadImages (line 130) | void LoadImages(const string &strFile, vector<string> &vstrImageFilename...

FILE: Examples/RGB-D/rgbd_live.cpp
  function main (line 18) | int main(int argc, char **argv)

FILE: Examples/RGB-D/rgbd_tum.cpp
  function main (line 40) | int main(int argc, char **argv)
  function LoadImages (line 155) | void LoadImages(const string &strAssociationFilename, vector<string> &vs...

FILE: Examples/Stereo/stereo_euroc.cpp
  function main (line 39) | int main(int argc, char **argv)
  function LoadImages (line 203) | void LoadImages(const string &strPathLeft, const string &strPathRight, c...

FILE: Examples/Stereo/stereo_kitti.cpp
  function main (line 41) | int main(int argc, char **argv)
  function LoadImages_VO_seq (line 205) | void LoadImages_VO_seq(const string &strPathToSequence, vector<string> &...
  function LoadImages (line 242) | void LoadImages(const string &strPathToSequence, vector<string> &vstrIma...

FILE: Examples/Stereo/stereo_live.cpp
  function main (line 38) | int main(int argc, char **argv)

FILE: Thirdparty/DBoW2/DBoW2/BowVector.cpp
  type DBoW2 (line 18) | namespace DBoW2 {

FILE: Thirdparty/DBoW2/DBoW2/BowVector.h
  function namespace (line 17) | namespace DBoW2 {

FILE: Thirdparty/DBoW2/DBoW2/FClass.h
  function namespace (line 17) | namespace DBoW2 {

FILE: Thirdparty/DBoW2/DBoW2/FORB.cpp
  type DBoW2 (line 22) | namespace DBoW2 {

FILE: Thirdparty/DBoW2/DBoW2/FORB.h
  function namespace (line 19) | namespace DBoW2 {

FILE: Thirdparty/DBoW2/DBoW2/FeatureVector.cpp
  type DBoW2 (line 15) | namespace DBoW2 {

FILE: Thirdparty/DBoW2/DBoW2/FeatureVector.h
  function namespace (line 18) | namespace DBoW2 {

FILE: Thirdparty/DBoW2/DBoW2/ScoringObject.h
  function namespace (line 15) | namespace DBoW2 {

FILE: Thirdparty/DBoW2/DBoW2/TemplatedVocabulary.h
  function namespace (line 38) | namespace DBoW2 {
  function m_scoring_object (line 519) | m_scoring_object(NULL)

FILE: Thirdparty/DBoW2/DUtils/Random.h
  function namespace (line 18) | namespace DUtils {

FILE: Thirdparty/DBoW2/DUtils/Timestamp.cpp
  type __timeb32 (line 59) | struct __timeb32
  type timeval (line 65) | struct timeval
  function string (line 97) | string Timestamp::getStringTime() const {
  function Timestamp (line 107) | Timestamp& Timestamp::operator+= (double s)
  function Timestamp (line 113) | Timestamp& Timestamp::operator-= (double s)
  function Timestamp (line 119) | Timestamp Timestamp::operator+ (double s) const
  function Timestamp (line 127) | Timestamp Timestamp::plus(unsigned long secs, unsigned long usecs) const
  function Timestamp (line 141) | Timestamp Timestamp::operator- (double s) const
  function Timestamp (line 149) | Timestamp Timestamp::minus(unsigned long secs, unsigned long usecs) const
  function string (line 197) | string Timestamp::Format(bool machine_friendly) const
  function string (line 223) | string Timestamp::Format(double s) {

FILE: Thirdparty/DBoW2/DUtils/Timestamp.h
  function namespace (line 16) | namespace DUtils {

FILE: Thirdparty/g2o/g2o/core/base_binary_edge.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/base_edge.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/base_multi_edge.hpp
  type internal (line 27) | namespace internal {
    function computeUpperTriangleIndex (line 28) | inline int computeUpperTriangleIndex(int i, int j)

FILE: Thirdparty/g2o/g2o/core/base_unary_edge.h
  function namespace (line 38) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/base_vertex.h
  function namespace (line 40) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/batch_stats.cpp
  type g2o (line 30) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/batch_stats.h
  function namespace (line 34) | namespace g2o {
  type std (line 80) | typedef std::vector<G2OBatchStatistics> BatchStatisticsContainer;

FILE: Thirdparty/g2o/g2o/core/block_solver.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/block_solver.hpp
  type g2o (line 36) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/cache.cpp
  type g2o (line 33) | namespace g2o {
    function OptimizableGraph (line 65) | OptimizableGraph* Cache::graph() {
    function CacheContainer (line 71) | CacheContainer* Cache::container() {
    function ParameterVector (line 75) | ParameterVector& Cache::parameters() {
    function Cache (line 95) | Cache* Cache::installDependency(const std::string& type_, const std::v...
    function Cache (line 122) | Cache* CacheContainer::findCache(const Cache::CacheKey& key) {
    function Cache (line 129) | Cache* CacheContainer::createCache(const Cache::CacheKey& key){
    function OptimizableGraph (line 157) | OptimizableGraph* CacheContainer::graph(){

FILE: Thirdparty/g2o/g2o/core/cache.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/creators.h
  function namespace (line 35) | namespace g2o

FILE: Thirdparty/g2o/g2o/core/eigen_types.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/estimate_propagator.cpp
  type g2o (line 40) | namespace g2o {
    type FrontierLevelCmp (line 43) | struct FrontierLevelCmp {

FILE: Thirdparty/g2o/g2o/core/estimate_propagator.h
  function namespace (line 43) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/factory.cpp
  type g2o (line 41) | namespace g2o {
    function Factory (line 61) | Factory* Factory::instance()

FILE: Thirdparty/g2o/g2o/core/factory.h
  function namespace (line 42) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/hyper_dijkstra.cpp
  type g2o (line 35) | namespace g2o{

FILE: Thirdparty/g2o/g2o/core/hyper_dijkstra.h
  function namespace (line 36) | namespace g2o{
  type std (line 70) | typedef std::map<HyperGraph::Vertex*, AdjacencyMapEntry> AdjacencyMap;
  function HyperGraph (line 74) | HyperGraph* graph() {return _graph;}
  type UniformCostFunction (line 107) | struct  UniformCostFunction

FILE: Thirdparty/g2o/g2o/core/hyper_graph.cpp
  type g2o (line 32) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/hyper_graph.h
  function namespace (line 47) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/hyper_graph_action.cpp
  type g2o (line 34) | namespace g2o {
    function HyperGraphAction (line 53) | HyperGraphAction* HyperGraphAction::operator()(const HyperGraph*, Para...
    function HyperGraphElementAction (line 73) | HyperGraphElementAction* HyperGraphElementAction::operator()(HyperGrap...
    function HyperGraphElementAction (line 78) | HyperGraphElementAction* HyperGraphElementAction::operator()(const Hyp...
    function HyperGraphElementAction (line 99) | HyperGraphElementAction* HyperGraphElementActionCollection::operator()...
    function HyperGraphElementAction (line 109) | HyperGraphElementAction* HyperGraphElementActionCollection::operator()...
    function HyperGraphActionLibrary (line 145) | HyperGraphActionLibrary* HyperGraphActionLibrary::instance()
    function HyperGraphElementAction (line 166) | HyperGraphElementAction* HyperGraphActionLibrary::actionByName(const s...
    function applyAction (line 253) | void applyAction(HyperGraph* graph, HyperGraphElementAction* action, H...

FILE: Thirdparty/g2o/g2o/core/hyper_graph_action.h
  function namespace (line 43) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/jacobian_workspace.cpp
  type g2o (line 35) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/jacobian_workspace.h
  function namespace (line 38) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/linear_solver.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/marginal_covariance_cholesky.cpp
  type g2o (line 33) | namespace g2o {
    type MatrixElem (line 35) | struct MatrixElem
      method MatrixElem (line 38) | MatrixElem(int r_, int c_) : r(r_), c(c_) {}

FILE: Thirdparty/g2o/g2o/core/marginal_covariance_cholesky.h
  function namespace (line 43) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/matrix_operations.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/matrix_structure.cpp
  type g2o (line 35) | namespace g2o {
    type ColSort (line 37) | struct ColSort

FILE: Thirdparty/g2o/g2o/core/matrix_structure.h
  function namespace (line 31) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/openmp_mutex.h
  function namespace (line 38) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/optimizable_graph.cpp
  type g2o (line 49) | namespace g2o {
    function CacheContainer (line 70) | CacheContainer* OptimizableGraph::Vertex::cacheContainer(){
    function OptimizableGraph (line 143) | OptimizableGraph* OptimizableGraph::Edge::graph(){
    function OptimizableGraph (line 152) | const OptimizableGraph* OptimizableGraph::Edge::graph() const{

FILE: Thirdparty/g2o/g2o/core/optimizable_graph.h
  function namespace (line 45) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/optimization_algorithm.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/optimization_algorithm.h
  function namespace (line 39) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/optimization_algorithm_dogleg.cpp
  type g2o (line 39) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/optimization_algorithm_dogleg.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/optimization_algorithm_factory.cpp
  type g2o (line 35) | namespace g2o {
    function OptimizationAlgorithmFactory (line 54) | OptimizationAlgorithmFactory* OptimizationAlgorithmFactory::instance()
    function OptimizationAlgorithm (line 84) | OptimizationAlgorithm* OptimizationAlgorithmFactory::construct(const s...

FILE: Thirdparty/g2o/g2o/core/optimization_algorithm_factory.h
  function namespace (line 42) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/optimization_algorithm_gauss_newton.cpp
  type g2o (line 39) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/optimization_algorithm_gauss_newton.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/optimization_algorithm_levenberg.cpp
  type g2o (line 41) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/optimization_algorithm_levenberg.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/optimization_algorithm_property.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/optimization_algorithm_with_hessian.cpp
  type g2o (line 36) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/optimization_algorithm_with_hessian.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/parameter.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/parameter.h
  function namespace (line 34) | namespace g2o {
  type std (line 52) | typedef std::vector<Parameter*> ParameterVector;

FILE: Thirdparty/g2o/g2o/core/parameter_container.cpp
  type g2o (line 38) | namespace g2o {
    function Parameter (line 70) | Parameter* ParameterContainer::getParameter(int id) {
    function Parameter (line 77) | Parameter* ParameterContainer::detachParameter(int id){

FILE: Thirdparty/g2o/g2o/core/parameter_container.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/robust_kernel.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/robust_kernel.h
  function namespace (line 38) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/robust_kernel_factory.cpp
  type g2o (line 34) | namespace g2o {
    function RobustKernelFactory (line 50) | RobustKernelFactory* RobustKernelFactory::instance()
    function RobustKernel (line 80) | RobustKernel* RobustKernelFactory::construct(const std::string& tag) c...
    function AbstractRobustKernelCreator (line 89) | AbstractRobustKernelCreator* RobustKernelFactory::creator(const std::s...

FILE: Thirdparty/g2o/g2o/core/robust_kernel_factory.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/robust_kernel_impl.cpp
  type g2o (line 32) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/robust_kernel_impl.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/solver.cpp
  type g2o (line 32) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/solver.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/sparse_block_matrix.h
  function namespace (line 43) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/sparse_block_matrix.hpp
  type g2o (line 27) | namespace g2o {
    type TripletEntry (line 31) | struct TripletEntry
      method TripletEntry (line 35) | TripletEntry(int r_, int c_, double x_) : r(r_), c(c_), x(x_) {}
    type TripletColSort (line 37) | struct TripletColSort
    type CmpPairFirst (line 46) | struct CmpPairFirst {

FILE: Thirdparty/g2o/g2o/core/sparse_block_matrix_ccs.h
  function namespace (line 43) | namespace g2o {
  type std (line 226) | typedef std::tr1::unordered_map<int, MatrixType*> SparseColumn;
  function rowsOfBlock (line 233) | int rowsOfBlock(int r) const { return r ? _rowBlockIndices[r] - _rowBloc...
  function colsOfBlock (line 236) | int colsOfBlock(int c) const { return c ? _colBlockIndices[c] - _colBloc...
  function rowBaseOfBlock (line 239) | int rowBaseOfBlock(int r) const { return r ? _rowBlockIndices[r-1] : 0 ; }
  function colBaseOfBlock (line 242) | int colBaseOfBlock(int c) const { return c ? _colBlockIndices[c-1] : 0 ; }

FILE: Thirdparty/g2o/g2o/core/sparse_block_matrix_diagonal.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o/g2o/core/sparse_block_matrix_test.cpp
  function main (line 46) | int main (int argc, char** argv){

FILE: Thirdparty/g2o/g2o/core/sparse_optimizer.cpp
  type g2o (line 46) | namespace g2o{

FILE: Thirdparty/g2o/g2o/core/sparse_optimizer.h
  function namespace (line 38) | namespace g2o {

FILE: Thirdparty/g2o/g2o/solvers/linear_solver_dense.h
  function namespace (line 40) | namespace g2o {

FILE: Thirdparty/g2o/g2o/solvers/linear_solver_eigen.h
  function namespace (line 42) | namespace g2o {

FILE: Thirdparty/g2o/g2o/stuff/misc.h
  function namespace (line 46) | namespace g2o {
  type ForceLinker (line 196) | struct ForceLinker

FILE: Thirdparty/g2o/g2o/stuff/os_specific.c
  function vasprintf (line 31) | int vasprintf(char** strp, const char* fmt, va_list ap)

FILE: Thirdparty/g2o/g2o/stuff/property.cpp
  type g2o (line 37) | namespace g2o {

FILE: Thirdparty/g2o/g2o/stuff/property.h
  function class (line 38) | class  BaseProperty {

FILE: Thirdparty/g2o/g2o/stuff/string_tools.cpp
  type g2o (line 44) | namespace g2o {
    function trim (line 48) | std::string trim(const std::string& s)
    function trimLeft (line 59) | std::string trimLeft(const std::string& s)
    function trimRight (line 70) | std::string trimRight(const std::string& s)
    function strToLower (line 81) | std::string strToLower(const std::string& s)
    function strToUpper (line 88) | std::string strToUpper(const std::string& s)
    function formatString (line 95) | std::string formatString(const char* fmt, ...)
    function strPrintf (line 112) | int strPrintf(std::string& str, const char* fmt, ...)
    function strExpandFilename (line 124) | std::string strExpandFilename(const std::string& filename)
    function strSplit (line 143) | std::vector<std::string> strSplit(const std::string& str, const std::s...
    function strStartsWith (line 158) | bool strStartsWith(const std::string& s, const std::string& start)
    function strEndsWith (line 165) | bool strEndsWith(const std::string& s, const std::string& end)
    function readLine (line 172) | int readLine(std::istream& is, std::stringstream& currentLine)

FILE: Thirdparty/g2o/g2o/stuff/string_tools.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o/g2o/stuff/timeutil.cpp
  type g2o (line 39) | namespace g2o {
    type timezone (line 48) | struct timezone
    function gettimeofday (line 54) | int gettimeofday(struct timeval *tv, struct timezone *tz)
    function get_monotonic_time (line 113) | double get_monotonic_time()

FILE: Thirdparty/g2o/g2o/stuff/timeutil.h
  function namespace (line 78) | namespace g2o {

FILE: Thirdparty/g2o/g2o/types/se3_ops.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o/g2o/types/se3_ops.hpp
  function Matrix3d (line 27) | Matrix3d skew(const Vector3d&v)
  function Vector3d (line 40) | Vector3d deltaR(const Matrix3d& R)
  function Vector2d (line 49) | Vector2d project(const Vector3d& v)
  function Vector3d (line 57) | Vector3d project(const Vector4d& v)
  function Vector3d (line 66) | Vector3d unproject(const Vector2d& v)
  function Vector4d (line 75) | Vector4d unproject(const Vector3d& v)

FILE: Thirdparty/g2o/g2o/types/se3quat.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o/g2o/types/sim3.h
  function namespace (line 33) | namespace g2o
  function Vector3d (line 144) | Vector3d map (const Vector3d& xyz) const {
  function Vector7d (line 148) | Vector7d log() const
  function const (line 239) | double operator[](int i) const
  function Vector3d (line 282) | inline Vector3d& translation() {return t;}
  function Quaterniond (line 286) | inline Quaterniond& rotation() {return r;}
  function scale (line 290) | inline double& scale() {return s;}

FILE: Thirdparty/g2o/g2o/types/types_sba.cpp
  type g2o (line 30) | namespace g2o {

FILE: Thirdparty/g2o/g2o/types/types_sba.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o/g2o/types/types_seven_dof_expmap.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o/g2o/types/types_seven_dof_expmap.h
  function virtual (line 56) | virtual void setToOriginImpl() {
  function virtual (line 60) | virtual void oplusImpl(const double* update_)
  function Vector2d (line 74) | Vector2d cam_map1(const Vector2d & v) const
  function Vector2d (line 82) | Vector2d cam_map2(const Vector2d & v) const
  function virtual (line 105) | virtual bool write(std::ostream& os) const;
  function virtual (line 116) | virtual double initialEstimatePossible(const OptimizableGraph::VertexSet...
  function virtual (line 117) | virtual void initialEstimate(const OptimizableGraph::VertexSet& from, Op...
  function computeError (line 138) | void computeError()
  function computeError (line 160) | void computeError()

FILE: Thirdparty/g2o/g2o/types/types_six_dof_expmap.cpp
  type g2o (line 32) | namespace g2o {
    function Vector2d (line 37) | Vector2d project2d(const Vector3d& v)  {
    function Vector3d (line 44) | Vector3d unproject2d(const Vector2d& v)  {
    function Vector2d (line 141) | Vector2d EdgeSE3ProjectXYZ::cam_project(const Vector3d & trans_xyz) co...
    function Vector3d (line 150) | Vector3d EdgeStereoSE3ProjectXYZ::cam_project(const Vector3d & trans_x...
    function Vector2d (line 290) | Vector2d EdgeSE3ProjectXYZOnlyPose::cam_project(const Vector3d & trans...
    function Vector3d (line 299) | Vector3d EdgeStereoSE3ProjectXYZOnlyPose::cam_project(const Vector3d &...

FILE: Thirdparty/g2o/g2o/types/types_six_dof_expmap.h
  function namespace (line 45) | namespace g2o {

FILE: Thirdparty/g2o_new/benchmarks/jacobian_timing_tests.cpp
  function BM_FixedArray (line 10) | void BM_FixedArray(benchmark::State& state) {
  function BM_FixedArrayPointer (line 22) | void BM_FixedArrayPointer(benchmark::State& state) {
  function BM_VariableArray (line 35) | void BM_VariableArray(benchmark::State& state) {
  function BM_VariableArrayPointer (line 55) | void BM_VariableArrayPointer(benchmark::State& state) {
  function BM_StaticEigenMatrix (line 73) | void BM_StaticEigenMatrix(benchmark::State& state) {
  function BM_StaticEigenMatrixPointer (line 85) | void BM_StaticEigenMatrixPointer(benchmark::State& state) {
  function BM_DynamicEigenMatrix (line 98) | void BM_DynamicEigenMatrix(benchmark::State& state) {
  function BM_DynamicEigenMatrixPointer (line 112) | void BM_DynamicEigenMatrixPointer(benchmark::State& state) {
  function BM_DynamicAlignedBuffer (line 127) | void BM_DynamicAlignedBuffer(benchmark::State& state) {
  function BM_DynamicAlignedBufferPointer (line 142) | void BM_DynamicAlignedBufferPointer(benchmark::State& state) {
  function BM_StaticDynamicDynamicAlignedBufferHybrid (line 159) | void BM_StaticDynamicDynamicAlignedBufferHybrid(benchmark::State& state) {
  function BM_ClassFixedArrayStatic (line 183) | void BM_ClassFixedArrayStatic(benchmark::State& state) {
  function BM_ClassFixedArrayDynamic (line 196) | void BM_ClassFixedArrayDynamic(benchmark::State& state) {

FILE: Thirdparty/g2o_new/g2o/EXTERNAL/freeglut/freeglut_font.cpp
  type freeglut_minimal (line 37) | namespace freeglut_minimal {
    function SFG_StrokeFont (line 43) | static SFG_StrokeFont* fghStrokeByID(FontID font) {
    function glutStrokeString (line 52) | void glutStrokeString(FontID fontID, const char* string_) {
    function glutStrokeLength (line 97) | int glutStrokeLength(FontID fontID, const char* string_) {
    function GLfloat (line 127) | GLfloat glutStrokeHeight(FontID fontID) {

FILE: Thirdparty/g2o_new/g2o/EXTERNAL/freeglut/freeglut_minimal.h
  function namespace (line 59) | namespace freeglut_minimal {

FILE: Thirdparty/g2o_new/g2o/EXTERNAL/freeglut/freeglut_stroke_mono_roman.cpp
  type freeglut_minimal (line 34) | namespace freeglut_minimal {

FILE: Thirdparty/g2o_new/g2o/EXTERNAL/freeglut/freeglut_stroke_roman.cpp
  type freeglut_minimal (line 34) | namespace freeglut_minimal {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_cli/dl_wrapper.cpp
  type g2o (line 41) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_cli/dl_wrapper.h
  function namespace (line 42) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_cli/g2o.cpp
  type IncrementalEdgesCompare (line 66) | struct IncrementalEdgesCompare {
  function sigquit_handler (line 89) | void sigquit_handler(int sig) {
  function main (line 100) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_cli/g2o_common.cpp
  function fakeFunctionForWindows (line 63) | static void fakeFunctionForWindows() {}
  function HMODULE (line 65) | HMODULE getMyInstance() {
  type g2o (line 79) | namespace g2o {
    function findArguments (line 81) | void findArguments(const std::string& option, std::vector<std::string>...
    function loadStandardTypes (line 91) | void loadStandardTypes(DlWrapper& dlTypesWrapper, int argc, char** arg...
    function loadStandardSolver (line 126) | void loadStandardSolver(DlWrapper& dlSolverWrapper, int argc, char** a...

FILE: Thirdparty/g2o_new/g2o/apps/g2o_cli/g2o_common.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_cli/output_helper.cpp
  type g2o (line 38) | namespace g2o {
    function edgeAllVertsSameDim (line 40) | bool edgeAllVertsSameDim(OptimizableGraph::Edge* e, int dim) {
    function saveGnuplot (line 49) | bool saveGnuplot(const std::string& gnudump,
    function saveGnuplot (line 60) | bool saveGnuplot(const std::string& gnudump,
    function dumpEdges (line 183) | bool dumpEdges(std::ostream& os, const OptimizableGraph& optimizer) {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_cli/output_helper.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/pointsensorparameters.cpp
  type g2o (line 32) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/pointsensorparameters.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_line3d.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_line3d.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_odometry.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_odometry2d.cpp
  type g2o (line 32) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_odometry2d.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_odometry3d.cpp
  type g2o (line 32) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_odometry3d.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pointxy.cpp
  type g2o (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pointxy.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pointxy_bearing.cpp
  type g2o (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pointxy_bearing.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pointxy_offset.cpp
  type g2o (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pointxy_offset.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pointxyz.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pointxyz.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pointxyz_depth.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pointxyz_depth.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pointxyz_disparity.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pointxyz_disparity.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pose2d.cpp
  type g2o (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pose2d.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pose3d.cpp
  type g2o (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pose3d.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pose3d_offset.cpp
  type g2o (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_pose3d_offset.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_se3_prior.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_se3_prior.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_segment2d.cpp
  type g2o (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_segment2d.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_segment2d_line.cpp
  type g2o (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_segment2d_line.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_segment2d_pointline.cpp
  type g2o (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/sensor_segment2d_pointline.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/simulator.cpp
  type g2o (line 31) | namespace g2o {
    function OptimizableGraph (line 36) | OptimizableGraph* BaseWorldObject::graph() {
    function OptimizableGraph (line 46) | OptimizableGraph* BaseRobot::graph() const {
    function World (line 71) | World* BaseSensor::world() const {
    function OptimizableGraph (line 76) | OptimizableGraph* BaseSensor::graph() const {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/simulator.h
  function namespace (line 39) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/simulator2d_base.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/simulator2d_segment.cpp
  function main (line 40) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/simulator3d_base.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/simutils.cpp
  type g2o (line 29) | namespace g2o {
    function clipSegmentCircle (line 37) | int clipSegmentCircle(Eigen::Vector2d& p1, Eigen::Vector2d& p2, double...
    function clipSegmentLine (line 81) | int clipSegmentLine(Eigen::Vector2d& p1, Eigen::Vector2d& p2, double a,
    function clipSegmentFov (line 107) | int clipSegmentFov(Eigen::Vector2d& p1, Eigen::Vector2d& p2, double min,
    function computeLineParameters (line 148) | Eigen::Vector2d computeLineParameters(const Eigen::Vector2d& p1,

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/simutils.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/test_simulator2d.cpp
  function main (line 41) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_simulator/test_simulator3d.cpp
  function main (line 43) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_viewer/g2o_qglviewer.cpp
  type g2o (line 54) | namespace g2o {
    class StandardCamera (line 61) | class StandardCamera : public qglviewer::Camera {
      method StandardCamera (line 63) | StandardCamera() : _standard(true) {}
      method qglv_real (line 65) | qglv_real zNear() const {
      method qglv_real (line 72) | qglv_real zFar() const {
      method standard (line 79) | bool standard() const { return _standard; }
      method setStandard (line 80) | void setStandard(bool s) { _standard = s; }

FILE: Thirdparty/g2o_new/g2o/apps/g2o_viewer/g2o_qglviewer.h
  function namespace (line 26) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_viewer/g2o_viewer.cpp
  function main (line 29) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_viewer/gui_hyper_graph_action.cpp
  type g2o (line 26) | namespace g2o {
    function HyperGraphAction (line 33) | HyperGraphAction* GuiHyperGraphAction::operator()(const HyperGraph* gr...

FILE: Thirdparty/g2o_new/g2o/apps/g2o_viewer/gui_hyper_graph_action.h
  function namespace (line 25) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_viewer/main_window.h
  function namespace (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_viewer/properties_widget.h
  function namespace (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_viewer/run_g2o_viewer.cpp
  type g2o (line 31) | namespace g2o {
    class SleepThread (line 36) | class SleepThread : public QThread {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_viewer/run_g2o_viewer.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_viewer/viewer_properties_widget.cpp
  function demangleName (line 39) | static std::string demangleName(const std::string& fullPropName) {

FILE: Thirdparty/g2o_new/g2o/apps/g2o_viewer/viewer_properties_widget.h
  function namespace (line 25) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/autodiff/array_selector.h
  function namespace (line 41) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/autodiff/autodiff.h
  function namespace (line 167) | namespace g2o {
  function Apply (line 230) | void Apply(T const* const* /* NOT USED */, JetT* /* NOT USED */) {}
  function Take0thOrderPart (line 236) | void Take0thOrderPart(int M, const JetT* src, T dst) {
  function Take1stOrderPart (line 245) | void Take1stOrderPart(const int M, const JetT* src, T* dst) {
  function Apply (line 276) | void Apply(int num_outputs, JetT* output, T** jacobians) {
  function Apply (line 289) | void Apply(int /* NOT USED*/, JetT* /* NOT USED*/,
  function AutoDifferentiate (line 295) | bool AutoDifferentiate(const Functor& functor,

FILE: Thirdparty/g2o_new/g2o/autodiff/eigen.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/autodiff/fixed_array.h
  function namespace (line 43) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/autodiff/integer_sequence_algorithm.h
  function namespace (line 40) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/autodiff/jet.h
  function namespace (line 168) | namespace g2o {
  function BesselJ0 (line 599) | inline double BesselJ0(double x) {
  function BesselJ1 (line 606) | inline double BesselJ1(double x) {
  function BesselJn (line 613) | inline double BesselJn(int n, double x) {
  function isfinite (line 663) | bool isfinite(const Jet<T, N>& f) {
  function isinf (line 675) | bool isinf(const Jet<T, N>& f) {
  function isnan (line 685) | bool isnan(const Jet<T, N>& f) {
  function isnormal (line 695) | bool isnormal(const Jet<T, N>& f) {
  function IsFinite (line 705) | bool IsFinite(const Jet<T, N>& f) {
  function IsNaN (line 710) | bool IsNaN(const Jet<T, N>& f) {
  function IsNormal (line 715) | bool IsNormal(const Jet<T, N>& f) {
  function IsInfinite (line 721) | bool IsInfinite(const Jet<T, N>& f) {
  function namespace (line 876) | namespace std {
  function namespace (line 938) | namespace Eigen {
  function Real (line 953) | static inline Real epsilon() {
  function digits10 (line 957) | static inline int digits10() { return NumTraits<T>::digits10(); }
  function Real (line 986) | static inline Real highest() { return Real(std::numeric_limits<T>::max()...
  function Real (line 987) | static inline Real lowest() { return Real(-std::numeric_limits<T>::max()...

FILE: Thirdparty/g2o_new/g2o/autodiff/memory.h
  function namespace (line 43) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/autodiff/parameter_dims.h
  function namespace (line 39) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/autodiff/types.h
  function namespace (line 44) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/autodiff/variadic_evaluate.h
  function namespace (line 43) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/auto_differentiation.h
  function computeError (line 166) | static void computeError(Edge* that) {
  function linearize (line 179) | static void linearize(Edge* that) {
  function override (line 189) | static_assert(

FILE: Thirdparty/g2o_new/g2o/core/base_binary_edge.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/base_dynamic_vertex.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/base_edge.h
  function QuadraticFormLock (line 43) | struct QuadraticFormLock {
  type QuadraticFormLock (line 54) | struct QuadraticFormLock {
  type BaseEdgeTraits (line 76) | struct BaseEdgeTraits
  type Eigen (line 78) | typedef Eigen::Matrix<double, Eigen::Dynamic, 1, Eigen::ColMajor> ErrorV...
  type Eigen (line 79) | typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::Col...
  type E (line 89) | typedef E Measurement;
  type typename (line 90) | typedef typename internal::BaseEdgeTraits<D>::ErrorVector ErrorVector;
  type typename (line 91) | typedef typename internal::BaseEdgeTraits<D>::InformationType Informatio...
  function virtual (line 97) | virtual ~BaseEdge() {}
  function virtual (line 101) | virtual const double* errorData() const { return _error.data(); }
  function virtual (line 102) | virtual double* errorData() { return _error.data(); }
  function EIGEN_STRONG_INLINE (line 110) | EIGEN_STRONG_INLINE InformationType& information() { return _information; }
  function setInformation (line 111) | void setInformation(const InformationType& information) {
  function virtual (line 115) | virtual const double* informationData() const { return _information.data...
  function virtual (line 116) | virtual double* informationData() { return _information.data(); }
  function virtual (line 122) | virtual void setMeasurement(const Measurement& m) { _measurement = m; }
  function virtual (line 126) | virtual void initialEstimate(const OptimizableGraph::VertexSet&,
  function InformationType (line 156) | InformationType robustInformation(const Vector3& rho) const {
  function writeInformationMatrix (line 165) | bool writeInformationMatrix(std::ostream& os) const {
  function readInformationMatrix (line 173) | bool readInformationMatrix(std::istream& is) {
  function writeParamIds (line 182) | bool writeParamIds(std::ostream& os) const {

FILE: Thirdparty/g2o_new/g2o/core/base_fixed_sized_edge.h
  function namespace (line 44) | namespace internal {
  type HessianTupleType (line 195) | struct HessianTupleType<std::index_sequence<Ints...>> {
  function Vertex (line 220) | Vertex* createVertex(int i, CtorArgs... args) {

FILE: Thirdparty/g2o_new/g2o/core/base_fixed_sized_edge.hpp
  type MapHessianMemoryK (line 215) | struct MapHessianMemoryK {

FILE: Thirdparty/g2o_new/g2o/core/base_multi_edge.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/base_unary_edge.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/base_variable_sized_edge.hpp
  type internal (line 29) | namespace internal {
    function computeUpperTriangleIndex (line 30) | inline int computeUpperTriangleIndex(int i, int j) {

FILE: Thirdparty/g2o_new/g2o/core/base_vertex.h
  function namespace (line 38) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/batch_stats.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/batch_stats.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/block_solver.h
  function namespace (line 41) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/block_solver.hpp
  type g2o (line 39) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/cache.cpp
  type g2o (line 33) | namespace g2o {
    function OptimizableGraph (line 60) | OptimizableGraph* Cache::graph() {
    function CacheContainer (line 65) | CacheContainer* Cache::container() { return _container; }
    function ParameterVector (line 67) | ParameterVector& Cache::parameters() { return _parameters; }
    function Cache (line 84) | Cache* Cache::installDependency(const std::string& type_,
    function Cache (line 110) | Cache* CacheContainer::findCache(const Cache::CacheKey& key) {
    function Cache (line 116) | Cache* CacheContainer::createCache(const Cache::CacheKey& key) {
    function OptimizableGraph (line 141) | OptimizableGraph* CacheContainer::graph() {

FILE: Thirdparty/g2o_new/g2o/core/cache.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/creators.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/dynamic_aligned_buffer.hpp
  type g2o (line 7) | namespace g2o {
    function Type (line 10) | Type* allocate_aligned(size_t n) {
    function Type (line 15) | Type* reallocate_aligned(Type* ptr, size_t newSize, size_t oldSize) {
    function free_aligned (line 21) | void free_aligned(Type* block) {
    type dynamic_aligned_buffer (line 26) | struct dynamic_aligned_buffer {
      method dynamic_aligned_buffer (line 27) | explicit dynamic_aligned_buffer(size_t size) : m_size{0}, m_ptr{null...
      method Type (line 33) | Type* request(size_t n) {
      method allocate (line 43) | void allocate(size_t size) {
      method free (line 48) | void free() {
    type aligned_deleter (line 61) | struct aligned_deleter {

FILE: Thirdparty/g2o_new/g2o/core/eigen_types.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/estimate_propagator.cpp
  type g2o (line 43) | namespace g2o {
    type FrontierLevelCmp (line 46) | struct FrontierLevelCmp {

FILE: Thirdparty/g2o_new/g2o/core/estimate_propagator.h
  function class (line 47) | class G2O_CORE_API EstimatePropagatorCost {
  function name (line 69) | double operator()(OptimizableGraph::Edge* edge,

FILE: Thirdparty/g2o_new/g2o/core/factory.cpp
  type g2o (line 42) | namespace g2o {
    function Factory (line 46) | Factory* Factory::instance() {

FILE: Thirdparty/g2o_new/g2o/core/factory.h
  function namespace (line 43) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/hyper_dijkstra.cpp
  type g2o (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/hyper_dijkstra.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/hyper_graph.cpp
  type g2o (line 37) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/hyper_graph.h
  function namespace (line 41) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/hyper_graph_action.cpp
  type g2o (line 35) | namespace g2o {
    function HyperGraphAction (line 48) | HyperGraphAction* HyperGraphAction::operator()(const HyperGraph*, Para...
    function HyperGraphElementAction (line 61) | HyperGraphElementAction* HyperGraphElementAction::operator()(
    function HyperGraphElementAction (line 66) | HyperGraphElementAction* HyperGraphElementAction::operator()(
    function HyperGraphElementAction (line 79) | HyperGraphElementAction* HyperGraphElementActionCollection::operator()(
    function HyperGraphElementAction (line 88) | HyperGraphElementAction* HyperGraphElementActionCollection::operator()(
    function HyperGraphActionLibrary (line 124) | HyperGraphActionLibrary* HyperGraphActionLibrary::instance() {
    function HyperGraphElementAction (line 137) | HyperGraphElementAction* HyperGraphActionLibrary::actionByName(
    function applyAction (line 256) | void applyAction(HyperGraph* graph, HyperGraphElementAction* action,

FILE: Thirdparty/g2o_new/g2o/core/hyper_graph_action.h
  function namespace (line 43) | namespace g2o {
  function class (line 150) | class G2O_CORE_API HyperGraphActionLibrary {
  type G2O_CORE_API (line 191) | struct G2O_CORE_API

FILE: Thirdparty/g2o_new/g2o/core/io_helper.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/jacobian_workspace.cpp
  type g2o (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/jacobian_workspace.h
  function namespace (line 38) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/linear_solver.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/marginal_covariance_cholesky.cpp
  type g2o (line 36) | namespace g2o {
    type MatrixElem (line 38) | struct MatrixElem {
      method MatrixElem (line 40) | MatrixElem(int r_, int c_) : r(r_), c(c_) {}

FILE: Thirdparty/g2o_new/g2o/core/marginal_covariance_cholesky.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/matrix_operations.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/matrix_structure.cpp
  type g2o (line 36) | namespace g2o {
    type ColSort (line 38) | struct ColSort {

FILE: Thirdparty/g2o_new/g2o/core/matrix_structure.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/openmp_mutex.h
  function namespace (line 38) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/optimizable_graph.cpp
  type g2o (line 47) | namespace g2o {
    function CacheContainer (line 61) | CacheContainer* OptimizableGraph::Vertex::cacheContainer() {
    function OptimizableGraph (line 105) | OptimizableGraph* OptimizableGraph::Edge::graph() {
    function OptimizableGraph (line 112) | const OptimizableGraph* OptimizableGraph::Edge::graph() const {

FILE: Thirdparty/g2o_new/g2o/core/optimizable_graph.h
  function namespace (line 44) | namespace g2o {
  function Vertex (line 576) | inline Vertex* vertex(int id) {
  function Vertex (line 581) | inline const Vertex* vertex(int id) const {
  function virtual (line 595) | virtual bool addVertex(HyperGraph::Vertex* v) { return addVertex(v, 0); }
  function addVertex (line 597) | bool addVertex(OptimizableGraph::Vertex* v) { return addVertex(v, 0); }
  function recomputeJacobianWorkspaceSize (line 626) | void recomputeJacobianWorkspaceSize() {
  function addParameter (line 715) | bool addParameter(Parameter* p) { return _parameters.addParameter(p); }
  function Parameter (line 717) | Parameter* parameter(int id) { return _parameters.getParameter(id); }
  function ParameterContainer (line 753) | inline ParameterContainer& parameters() { return _parameters; }

FILE: Thirdparty/g2o_new/g2o/core/optimization_algorithm.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/optimization_algorithm.h
  function namespace (line 39) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/optimization_algorithm_dogleg.cpp
  type g2o (line 39) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/optimization_algorithm_dogleg.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/optimization_algorithm_factory.cpp
  type g2o (line 37) | namespace g2o {
    function OptimizationAlgorithmFactory (line 46) | OptimizationAlgorithmFactory* OptimizationAlgorithmFactory::instance() {
    function OptimizationAlgorithm (line 74) | OptimizationAlgorithm* OptimizationAlgorithmFactory::construct(

FILE: Thirdparty/g2o_new/g2o/core/optimization_algorithm_factory.h
  function namespace (line 42) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/optimization_algorithm_gauss_newton.cpp
  type g2o (line 39) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/optimization_algorithm_gauss_newton.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/optimization_algorithm_levenberg.cpp
  type g2o (line 40) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/optimization_algorithm_levenberg.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/optimization_algorithm_property.h
  function OptimizationAlgorithmProperty (line 39) | struct G2O_CORE_API OptimizationAlgorithmProperty {

FILE: Thirdparty/g2o_new/g2o/core/optimization_algorithm_with_hessian.cpp
  type g2o (line 37) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/optimization_algorithm_with_hessian.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/ownership.h
  function namespace (line 6) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/parameter.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/parameter.h
  function namespace (line 34) | namespace g2o {
  type std (line 54) | typedef std::vector<Parameter*> ParameterVector;

FILE: Thirdparty/g2o_new/g2o/core/parameter_container.cpp
  type g2o (line 37) | namespace g2o {
    function Parameter (line 62) | Parameter* ParameterContainer::getParameter(int id) {
    function Parameter (line 68) | const Parameter* ParameterContainer::getParameter(int id) const {
    function Parameter (line 74) | Parameter* ParameterContainer::detachParameter(int id) {

FILE: Thirdparty/g2o_new/g2o/core/parameter_container.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/robust_kernel.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/robust_kernel.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/robust_kernel_factory.cpp
  type g2o (line 35) | namespace g2o {
    function RobustKernelFactory (line 39) | RobustKernelFactory* RobustKernelFactory::instance() {
    function RobustKernel (line 66) | RobustKernel* RobustKernelFactory::construct(const std::string& tag) c...
    function AbstractRobustKernelCreator (line 74) | AbstractRobustKernelCreator* RobustKernelFactory::creator(

FILE: Thirdparty/g2o_new/g2o/core/robust_kernel_factory.h
  function namespace (line 39) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/robust_kernel_impl.cpp
  type g2o (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/robust_kernel_impl.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/solver.cpp
  type g2o (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/solver.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/sparse_block_matrix.h
  function namespace (line 45) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/sparse_block_matrix.hpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/sparse_block_matrix_ccs.h
  function namespace (line 38) | namespace g2o {
  type std (line 231) | typedef std::unordered_map<int, MatrixType*> SparseColumn;
  function rowsOfBlock (line 238) | int rowsOfBlock(int r) const {
  function colsOfBlock (line 244) | int colsOfBlock(int c) const {
  function rowBaseOfBlock (line 250) | int rowBaseOfBlock(int r) const { return r ? _rowBlockIndices[r - 1] : 0; }
  function colBaseOfBlock (line 253) | int colBaseOfBlock(int c) const { return c ? _colBlockIndices[c - 1] : 0; }

FILE: Thirdparty/g2o_new/g2o/core/sparse_block_matrix_diagonal.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/sparse_optimizer.cpp
  function arrayHasNaN (line 51) | bool arrayHasNaN(const double* array, int size, int* nanIndex = 0) {
  type g2o (line 62) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/sparse_optimizer.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/core/sparse_optimizer_terminate_action.cpp
  type g2o (line 34) | namespace g2o {
    function HyperGraphAction (line 47) | HyperGraphAction* SparseOptimizerTerminateAction::operator()(

FILE: Thirdparty/g2o_new/g2o/core/sparse_optimizer_terminate_action.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/anonymize_observations/g2o_anonymize_observations.cpp
  function anonymizeLandmarkEdge (line 41) | bool anonymizeLandmarkEdge(HyperGraph::Edge* e_, OptimizableGraph& g) {
  function anonymizePoseEdge (line 49) | bool anonymizePoseEdge(HyperGraph::Edge* e_, OptimizableGraph& g) {
  function main (line 68) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/ba/ba_demo.cpp
  class Sample (line 51) | class Sample {
    method uniform (line 53) | static int uniform(int from, int to) {
  function main (line 58) | int main(int argc, const char* argv[]) {

FILE: Thirdparty/g2o_new/g2o/examples/ba_anchored_inverse_depth/ba_anchored_inverse_depth_demo.cpp
  class Sample (line 52) | class Sample {
    method uniform (line 54) | static int uniform(int from, int to) {
  function Vector2d (line 59) | Vector2d project2d(const Vector3d& v) {
  function Vector3d (line 66) | Vector3d unproject2d(const Vector2d& v) {
  function Vector3d (line 74) | inline Vector3d invert_depth(const Vector3d& x) {
  function main (line 78) | int main(int argc, const char* argv[]) {

FILE: Thirdparty/g2o_new/g2o/examples/bal/bal_example.cpp
  type g2o (line 54) | namespace g2o {
    type bal (line 55) | namespace bal {
  class VertexCameraBAL (line 70) | class VertexCameraBAL : public g2o::BaseVertex<9, g2o::bal::Vector9> {
    method VertexCameraBAL (line 73) | VertexCameraBAL() {}
    method read (line 75) | bool read(std::istream& /*is*/) override {
    method write (line 80) | bool write(std::ostream& /*os*/) const override {
    method setToOriginImpl (line 85) | void setToOriginImpl() override { G2O_ERROR("not implemented yet"); }
    method oplusImpl (line 87) | void oplusImpl(const double* update) override {
  class VertexPointBAL (line 98) | class VertexPointBAL : public g2o::BaseVertex<3, g2o::Vector3> {
    method VertexPointBAL (line 101) | VertexPointBAL() {}
    method read (line 103) | bool read(std::istream& /*is*/) override {
    method write (line 108) | bool write(std::ostream& /*os*/) const override {
    method setToOriginImpl (line 113) | void setToOriginImpl() override { G2O_ERROR("not implemented yet"); }
    method oplusImpl (line 115) | void oplusImpl(const double* update) override {
  function EdgeObservationBAL (line 148) | EdgeObservationBAL() {}
  function read (line 149) | bool read(std::istream& /*is*/) override {
  function write (line 153) | bool write(std::ostream& /*os*/) const override {
  function main (line 209) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/calibration_odom_laser/closed_form_calibration.cpp
  type g2o (line 40) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/calibration_odom_laser/closed_form_calibration.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/calibration_odom_laser/edge_se2_pure_calib.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/calibration_odom_laser/edge_se2_pure_calib.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/calibration_odom_laser/gm2dl_io.cpp
  type g2o (line 41) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/calibration_odom_laser/gm2dl_io.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/calibration_odom_laser/motion_information.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/calibration_odom_laser/sclam_helpers.cpp
  type g2o (line 46) | namespace g2o {
    function addOdometryCalibLinksDifferential (line 50) | void addOdometryCalibLinksDifferential(SparseOptimizer& optimizer,
    function allocateSolverForSclam (line 113) | void allocateSolverForSclam(SparseOptimizer& optimizer, bool levenberg) {

FILE: Thirdparty/g2o_new/g2o/examples/calibration_odom_laser/sclam_helpers.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/calibration_odom_laser/sclam_laser_calib.cpp
  function sigquit_handler (line 50) | void sigquit_handler(int sig) {
  function main (line 61) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/calibration_odom_laser/sclam_odom_laser.cpp
  function sigquit_handler (line 52) | void sigquit_handler(int sig) {
  function main (line 63) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/calibration_odom_laser/sclam_pure_calibration.cpp
  class VertexBaseline (line 57) | class VertexBaseline : public BaseVertex<1, double> {
    method VertexBaseline (line 59) | VertexBaseline() {}
    method setToOriginImpl (line 61) | virtual void setToOriginImpl() { _estimate = 1.; }
    method oplusImpl (line 62) | virtual void oplusImpl(const double* update) { _estimate += update[0]; }
    method read (line 63) | virtual bool read(std::istream&) { return false; }
    method write (line 64) | virtual bool write(std::ostream&) const { return false; }
  class EdgeCalib (line 67) | class EdgeCalib
    method EdgeCalib (line 71) | EdgeCalib() {}
    method computeError (line 73) | void computeError() {
    method read (line 97) | virtual bool read(std::istream&) { return false; }
    method write (line 98) | virtual bool write(std::ostream&) const { return false; }
  function main (line 101) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/convert_segment_line/convertSegmentLine.cpp
  function computeLine (line 59) | Eigen::Vector2d computeLine(const Eigen::Vector2d& p1,
  type LineInfo (line 69) | struct LineInfo {
    method LineInfo (line 70) | explicit LineInfo(VertexSegment2D* s) {
  function main (line 86) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/data_convert/convert_sba_slam3d.cpp
  function main (line 41) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/data_fitting/circle_fit.cpp
  function errorOfSolution (line 44) | double errorOfSolution(int numPoints, Eigen::Vector2d* points,
  class VertexCircle (line 59) | class VertexCircle : public g2o::BaseVertex<3, Eigen::Vector3d> {
    method VertexCircle (line 62) | VertexCircle() {}
    method read (line 64) | bool read(std::istream& /*is*/) override { return false; }
    method write (line 66) | bool write(std::ostream& /*os*/) const override { return false; }
    method setToOriginImpl (line 68) | void setToOriginImpl() override { G2O_ERROR("not implemented yet"); }
    method oplusImpl (line 70) | void oplusImpl(const double* update) override {
  function EIGEN_MAKE_ALIGNED_OPERATOR_NEW (line 86) | EIGEN_MAKE_ALIGNED_OPERATOR_NEW
  function read (line 88) | bool read(std::istream& /*is*/) override { return false; }
  function write (line 89) | bool write(std::ostream& /*os*/) const override { return false; }
  function main (line 103) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/data_fitting/curve_fit.cpp
  class VertexParams (line 46) | class VertexParams : public g2o::BaseVertex<3, Eigen::Vector3d> {
    method VertexParams (line 49) | VertexParams() {}
    method read (line 51) | bool read(std::istream& /*is*/) override { return false; }
    method write (line 53) | bool write(std::ostream& /*os*/) const override { return false; }
    method setToOriginImpl (line 55) | void setToOriginImpl() override {}
    method oplusImpl (line 57) | void oplusImpl(const double* update) override {
  function EIGEN_MAKE_ALIGNED_OPERATOR_NEW (line 73) | EIGEN_MAKE_ALIGNED_OPERATOR_NEW
  function read (line 75) | bool read(std::istream& /*is*/) override {
  function write (line 79) | bool write(std::ostream& /*os*/) const override {
  function main (line 97) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/dynamic_vertex/polynomial_fit.cpp
  class PolynomialCoefficientVertex (line 26) | class PolynomialCoefficientVertex
    method PolynomialCoefficientVertex (line 32) | PolynomialCoefficientVertex() {}
    method read (line 35) | virtual bool read(std::istream& is) {
    method write (line 52) | virtual bool write(std::ostream& os) const {
    method setToOriginImpl (line 58) | virtual void setToOriginImpl() { _estimate.setZero(); }
    method oplusImpl (line 61) | virtual void oplusImpl(const double* update) {
    method setDimensionImpl (line 69) | virtual bool setDimensionImpl(int newDimension) {
  class PolynomialSingleValueEdge (line 95) | class PolynomialSingleValueEdge
    method PolynomialSingleValueEdge (line 100) | PolynomialSingleValueEdge(
    method read (line 109) | virtual bool read(std::istream& is) {
    method write (line 116) | virtual bool write(std::ostream& os) const {
    method computeError (line 122) | virtual void computeError() {
  function main (line 133) | int main(int argc, const char* argv[]) {

FILE: Thirdparty/g2o_new/g2o/examples/dynamic_vertex/static_dynamic_function_fit.cpp
  class FPolynomialCoefficientVertex (line 34) | class FPolynomialCoefficientVertex
    method FPolynomialCoefficientVertex (line 40) | FPolynomialCoefficientVertex() { setToOrigin(); }
    method read (line 43) | virtual bool read(std::istream& is) {
    method write (line 49) | virtual bool write(std::ostream& os) const {
    method setToOriginImpl (line 54) | virtual void setToOriginImpl() { _estimate.setZero(); }
    method oplusImpl (line 57) | virtual void oplusImpl(const double* update) {
  class PPolynomialCoefficientVertex (line 66) | class PPolynomialCoefficientVertex
    method PPolynomialCoefficientVertex (line 72) | PPolynomialCoefficientVertex() {}
    method read (line 75) | virtual bool read(std::istream& is) {
    method write (line 92) | virtual bool write(std::ostream& os) const {
    method setToOriginImpl (line 98) | virtual void setToOriginImpl() { _estimate.setZero(); }
    method oplusImpl (line 101) | virtual void oplusImpl(const double* update) {
    method setDimensionImpl (line 108) | virtual bool setDimensionImpl(int newDimension) {
  type FunctionObservation (line 117) | struct FunctionObservation {
  class MultipleValueEdge (line 124) | class MultipleValueEdge
    method MultipleValueEdge (line 131) | MultipleValueEdge(const FunctionObservation& obs, double omega) : _x(o...
    method read (line 138) | virtual bool read(std::istream& is) {
    method write (line 147) | virtual bool write(std::ostream& os) const {
    method computeError (line 154) | virtual void computeError() {
  function main (line 172) | int main(int argc, const char* argv[]) {

FILE: Thirdparty/g2o_new/g2o/examples/g2o_hierarchical/backbone_tree_action.cpp
  type g2o (line 33) | namespace g2o {
    function Star (line 92) | Star* BackBoneTreeAction::getStar(HyperGraph::Vertex* v_) {

FILE: Thirdparty/g2o_new/g2o/examples/g2o_hierarchical/backbone_tree_action.h
  function namespace (line 38) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/g2o_hierarchical/edge_creator.cpp
  type g2o (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/g2o_hierarchical/edge_creator.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/g2o_hierarchical/edge_labeler.cpp
  type g2o (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/g2o_hierarchical/edge_labeler.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/g2o_hierarchical/edge_types_cost_function.cpp
  type g2o (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/g2o_hierarchical/edge_types_cost_function.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/g2o_hierarchical/g2o_hierarchical.cpp
  function sigquit_handler (line 63) | void sigquit_handler(int sig) {
  function main (line 89) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/g2o_hierarchical/simple_star_ops.cpp
  type g2o (line 39) | namespace g2o {
    function activeVertexChi (line 44) | double activeVertexChi(const OptimizableGraph::Vertex* v) {
    function constructEdgeStarMap (line 62) | void constructEdgeStarMap(EdgeStarMap& esmap, StarSet& stars, bool low) {
    function vertexEdgesInStar (line 82) | size_t vertexEdgesInStar(HyperGraph::EdgeSet& eset, HyperGraph::Vertex...
    function starsInVertex (line 94) | void starsInVertex(StarSet& stars, HyperGraph::Vertex* v, EdgeStarMap&...
    function starsInEdge (line 103) | void starsInEdge(StarSet& stars, HyperGraph::Edge* e, EdgeStarMap& esmap,
    function assignHierarchicalEdges (line 111) | void assignHierarchicalEdges(StarSet& stars, EdgeStarMap& esmap,
    function computeBorder (line 156) | void computeBorder(StarSet& stars, EdgeStarMap& hesmap) {
    function computeSimpleStars (line 173) | void computeSimpleStars(StarSet& stars, SparseOptimizer* optimizer,

FILE: Thirdparty/g2o_new/g2o/examples/g2o_hierarchical/simple_star_ops.h
  function namespace (line 40) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/g2o_hierarchical/star.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/g2o_hierarchical/star.h
  function namespace (line 38) | namespace g2o {
  type std (line 98) | typedef std::multimap<OptimizableGraph::Vertex*, Star*> VertexStarMultimap;
  type std (line 99) | typedef std::map<OptimizableGraph::Vertex*, Star*> VertexStarMap;
  type std (line 100) | typedef std::set<Star*> StarSet;
  type std (line 101) | typedef std::map<HyperGraph::Edge*, Star*> EdgeStarMap;

FILE: Thirdparty/g2o_new/g2o/examples/icp/gicp_demo.cpp
  function main (line 44) | int main() {

FILE: Thirdparty/g2o_new/g2o/examples/icp/gicp_sba_demo.cpp
  function main (line 44) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/g2o_incremental/g2o_incremental.cpp
  type EdgeInformation (line 36) | struct EdgeInformation {
  type IncrementalEdgesCompare (line 46) | struct IncrementalEdgesCompare {
  function solveAndPrint (line 58) | inline void solveAndPrint(G2oSlamInterface& slamInterface, bool verbose) {
  function sigquit_handler (line 74) | void sigquit_handler(int sig) {
  function main (line 85) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/g2o_incremental/graph_optimizer_sparse_incremental.cpp
  type g2o (line 31) | namespace g2o {
    function AllocateCholmodSolver (line 36) | std::unique_ptr<g2o::Solver> AllocateCholmodSolver() {
    type VertexBackup (line 48) | struct VertexBackup {
    function OptimizationAlgorithm (line 459) | static OptimizationAlgorithm* createSolver(const std::string& solverNa...

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/g2o_incremental/graph_optimizer_sparse_incremental.h
  function namespace (line 25) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/g2o_incremental/linear_solver_cholmod_online.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/g2o_interactive/fast_output.h
  function strreverse (line 48) | inline void strreverse(char* begin, char* end) {
  function modp_dtoa (line 56) | inline int modp_dtoa(double value, char* str, int prec) {
  function modp_uitoa10 (line 159) | inline int modp_uitoa10(uint32_t value, char* str) {
  function modp_itoa10 (line 170) | inline int modp_itoa10(int32_t value, char* str) {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/g2o_interactive/g2o_online.cpp
  function sigquit_handler (line 41) | void sigquit_handler(int sig) {
  function main (line 52) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/g2o_interactive/g2o_slam_interface.cpp
  type g2o (line 41) | namespace g2o {
    function quat_to_euler (line 44) | void quat_to_euler(const Eigen::Quaterniond& q, double& yaw, double& p...
    function jac_quat3_euler3 (line 55) | void jac_quat3_euler3(Eigen::Matrix<double, 6, 6>& J, const SE3Quat& t) {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/g2o_interactive/g2o_slam_interface.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/g2o_interactive/generate_commands.cpp
  type IncrementalEdgesCompare (line 45) | struct IncrementalEdgesCompare {
  function sigquit_handler (line 71) | void sigquit_handler(int sig) {
  function main (line 82) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/g2o_interactive/graph_optimizer_sparse_online.cpp
  type g2o (line 43) | namespace g2o {
    function AllocatePCGSolver (line 47) | std::unique_ptr<g2o::Solver> AllocatePCGSolver() {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/g2o_interactive/graph_optimizer_sparse_online.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/g2o_interactive/types_online.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/g2o_interactive/types_slam2d_online.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/g2o_interactive/types_slam3d_online.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/example/example_slam_interface.h
  function class (line 43) | class ExampleSlamInterface : public SlamParser::AbstractSlamInterface {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/example/test_slam_interface.cpp
  function main (line 33) | int main() {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/interface/abstract_slam_interface.h
  function namespace (line 33) | namespace SlamParser {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/interface/parser_interface.cpp
  type SlamParser (line 32) | namespace SlamParser {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/interface/parser_interface.h
  function namespace (line 35) | namespace SlamParser {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/interface/slam_context_interface.cpp
  type SlamParser (line 35) | namespace SlamParser {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/interface/slam_context_interface.h
  function namespace (line 32) | namespace SlamParser {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/parser/FlexLexer.h
  type yy_buffer_state (line 55) | struct yy_buffer_state
  type yy_state_type (line 56) | typedef int yy_state_type;
  function class (line 58) | class FlexLexer {
  function set_debug (line 93) | void set_debug(int flag) { yy_flex_debug = flag; }
  function class (line 112) | class yyFlexLexer : public FlexLexer {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/parser/bison_parser.cpp
  type SlamParser (line 152) | namespace SlamParser {
    class Driver (line 156) | class Driver
    function YY_NOEXCEPT (line 168) | YY_NOEXCEPT YY_NOTHROW {}
  function catch (line 499) | catch (const syntax_error& yyexc) {
  function catch (line 828) | catch (const syntax_error& yyexc) {
  function catch (line 956) | catch (...) {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/parser/bison_parser.h
  function class (line 187) | class Parser {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/parser/commands.h
  function namespace (line 33) | namespace SlamParser {
  function class (line 56) | class AddNode : public CommandNode {
  function class (line 75) | class AddEdge : public CommandNode {
  function class (line 104) | class SolveSate : public CommandNode {
  function class (line 109) | class QueryState : public CommandNode {
  function class (line 120) | class FixNode : public CommandNode {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/parser/driver.cpp
  type SlamParser (line 35) | namespace SlamParser {
    class SlamContext (line 37) | class SlamContext
    class location (line 68) | class location

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/parser/driver.h
  function namespace (line 33) | namespace SlamParser {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/parser/flex_scanner.cpp
  type yy_buffer_state (line 180) | struct yy_buffer_state
  type yy_buffer_state (line 212) | struct yy_buffer_state {
  type yy_trans_info (line 329) | struct yy_trans_info {
  function yy_state_type (line 1117) | yy_state_type yyFlexLexer::yy_get_previous_state() {
  function yy_state_type (line 1144) | yy_state_type yyFlexLexer::yy_try_NUL_trans(yy_state_type yy_current_sta...
  function YY_BUFFER_STATE (line 1331) | YY_BUFFER_STATE yyFlexLexer::yy_create_buffer(std::istream& file, int si...
  function YY_BUFFER_STATE (line 1361) | YY_BUFFER_STATE yyFlexLexer::yy_create_buffer(std::istream* file, int si...
  type yy_buffer_state (line 1488) | struct yy_buffer_state
  type yy_buffer_state (line 1489) | struct yy_buffer_state
  type yy_buffer_state (line 1494) | struct yy_buffer_state
  type yy_buffer_state (line 1506) | struct yy_buffer_state
  type yy_buffer_state (line 1507) | struct yy_buffer_state
  type yy_buffer_state (line 1513) | struct yy_buffer_state
  function yy_flex_strncpy (line 1582) | static void yy_flex_strncpy(char* s1, const char* s2, int n) {
  function yy_flex_strlen (line 1589) | static int yy_flex_strlen(const char* s) {
  function yyfree (line 1610) | void yyfree(void* ptr) {
  type SlamParser (line 1618) | namespace SlamParser {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/parser/location.hh
  type SlamParser (line 56) | namespace SlamParser {
    class position (line 60) | class position {
      method position (line 68) | explicit position(filename_type* f = YY_NULLPTR, counter_type l = 1,
      method initialize (line 73) | void initialize(filename_type* fn = YY_NULLPTR, counter_type l = 1,
      method lines (line 83) | void lines(counter_type count = 1) {
      method columns (line 91) | void columns(counter_type count = 1) { column = add_(column, count, ...
      method counter_type (line 103) | static counter_type add_(counter_type lhs, counter_type rhs,
    function position (line 110) | inline position& operator+=(position& res, position::counter_type widt...
      method position (line 68) | explicit position(filename_type* f = YY_NULLPTR, counter_type l = 1,
      method initialize (line 73) | void initialize(filename_type* fn = YY_NULLPTR, counter_type l = 1,
      method lines (line 83) | void lines(counter_type count = 1) {
      method columns (line 91) | void columns(counter_type count = 1) { column = add_(column, count, ...
      method counter_type (line 103) | static counter_type add_(counter_type lhs, counter_type rhs,
    function position (line 116) | inline position operator+(position res, position::counter_type width) {
      method position (line 68) | explicit position(filename_type* f = YY_NULLPTR, counter_type l = 1,
      method initialize (line 73) | void initialize(filename_type* fn = YY_NULLPTR, counter_type l = 1,
      method lines (line 83) | void lines(counter_type count = 1) {
      method columns (line 91) | void columns(counter_type count = 1) { column = add_(column, count, ...
      method counter_type (line 103) | static counter_type add_(counter_type lhs, counter_type rhs,
    function position (line 121) | inline position& operator-=(position& res, position::counter_type widt...
      method position (line 68) | explicit position(filename_type* f = YY_NULLPTR, counter_type l = 1,
      method initialize (line 73) | void initialize(filename_type* fn = YY_NULLPTR, counter_type l = 1,
      method lines (line 83) | void lines(counter_type count = 1) {
      method columns (line 91) | void columns(counter_type count = 1) { column = add_(column, count, ...
      method counter_type (line 103) | static counter_type add_(counter_type lhs, counter_type rhs,
    function position (line 126) | inline position operator-(position res, position::counter_type width) {
      method position (line 68) | explicit position(filename_type* f = YY_NULLPTR, counter_type l = 1,
      method initialize (line 73) | void initialize(filename_type* fn = YY_NULLPTR, counter_type l = 1,
      method lines (line 83) | void lines(counter_type count = 1) {
      method columns (line 91) | void columns(counter_type count = 1) { column = add_(column, count, ...
      method counter_type (line 103) | static counter_type add_(counter_type lhs, counter_type rhs,
    class location (line 142) | class location {
      method location (line 150) | location(const position& b, const position& e) : begin(b), end(e) {}
      method location (line 153) | explicit location(const position& p = position()) : begin(p), end(p) {}
      method location (line 156) | explicit location(filename_type* f, counter_type l = 1, counter_type...
      method initialize (line 160) | void initialize(filename_type* f = YY_NULLPTR, counter_type l = 1,
      method step (line 170) | void step() { begin = end; }
      method columns (line 173) | void columns(counter_type count = 1) { end += count; }
      method lines (line 176) | void lines(counter_type count = 1) { end.lines(count); }
    function location (line 187) | inline location& operator+=(location& res, const location& end) {
      method location (line 150) | location(const position& b, const position& e) : begin(b), end(e) {}
      method location (line 153) | explicit location(const position& p = position()) : begin(p), end(p) {}
      method location (line 156) | explicit location(filename_type* f, counter_type l = 1, counter_type...
      method initialize (line 160) | void initialize(filename_type* f = YY_NULLPTR, counter_type l = 1,
      method step (line 170) | void step() { begin = end; }
      method columns (line 173) | void columns(counter_type count = 1) { end += count; }
      method lines (line 176) | void lines(counter_type count = 1) { end.lines(count); }
    function location (line 193) | inline location operator+(location res, const location& end) {
      method location (line 150) | location(const position& b, const position& e) : begin(b), end(e) {}
      method location (line 153) | explicit location(const position& p = position()) : begin(p), end(p) {}
      method location (line 156) | explicit location(filename_type* f, counter_type l = 1, counter_type...
      method initialize (line 160) | void initialize(filename_type* f = YY_NULLPTR, counter_type l = 1,
      method step (line 170) | void step() { begin = end; }
      method columns (line 173) | void columns(counter_type count = 1) { end += count; }
      method lines (line 176) | void lines(counter_type count = 1) { end.lines(count); }
    function location (line 198) | inline location& operator+=(location& res, location::counter_type widt...
      method location (line 150) | location(const position& b, const position& e) : begin(b), end(e) {}
      method location (line 153) | explicit location(const position& p = position()) : begin(p), end(p) {}
      method location (line 156) | explicit location(filename_type* f, counter_type l = 1, counter_type...
      method initialize (line 160) | void initialize(filename_type* f = YY_NULLPTR, counter_type l = 1,
      method step (line 170) | void step() { begin = end; }
      method columns (line 173) | void columns(counter_type count = 1) { end += count; }
      method lines (line 176) | void lines(counter_type count = 1) { end.lines(count); }
    function location (line 204) | inline location operator+(location res, location::counter_type width) {
      method location (line 150) | location(const position& b, const position& e) : begin(b), end(e) {}
      method location (line 153) | explicit location(const position& p = position()) : begin(p), end(p) {}
      method location (line 156) | explicit location(filename_type* f, counter_type l = 1, counter_type...
      method initialize (line 160) | void initialize(filename_type* f = YY_NULLPTR, counter_type l = 1,
      method step (line 170) | void step() { begin = end; }
      method columns (line 173) | void columns(counter_type count = 1) { end += count; }
      method lines (line 176) | void lines(counter_type count = 1) { end.lines(count); }
    function location (line 209) | inline location& operator-=(location& res, location::counter_type widt...
      method location (line 150) | location(const position& b, const position& e) : begin(b), end(e) {}
      method location (line 153) | explicit location(const position& p = position()) : begin(p), end(p) {}
      method location (line 156) | explicit location(filename_type* f, counter_type l = 1, counter_type...
      method initialize (line 160) | void initialize(filename_type* f = YY_NULLPTR, counter_type l = 1,
      method step (line 170) | void step() { begin = end; }
      method columns (line 173) | void columns(counter_type count = 1) { end += count; }
      method lines (line 176) | void lines(counter_type count = 1) { end.lines(count); }
    function location (line 214) | inline location operator-(location res, location::counter_type width) {
      method location (line 150) | location(const position& b, const position& e) : begin(b), end(e) {}
      method location (line 153) | explicit location(const position& p = position()) : begin(p), end(p) {}
      method location (line 156) | explicit location(filename_type* f, counter_type l = 1, counter_type...
      method initialize (line 160) | void initialize(filename_type* f = YY_NULLPTR, counter_type l = 1,
      method step (line 170) | void step() { begin = end; }
      method columns (line 173) | void columns(counter_type count = 1) { end += count; }
      method lines (line 176) | void lines(counter_type count = 1) { end.lines(count); }

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/parser/scanner.h
  function namespace (line 20) | namespace SlamParser {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/parser/slam_context.cpp
  type SlamParser (line 34) | namespace SlamParser {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/parser/slam_context.h
  function namespace (line 32) | namespace SlamParser {

FILE: Thirdparty/g2o_new/g2o/examples/interactive_slam/slam_parser/parser/test_slam_parser.cpp
  function main (line 34) | int main() {

FILE: Thirdparty/g2o_new/g2o/examples/line_slam/line_test.cpp
  function ostream (line 13) | ostream& printVector(ostream& os, const T& t) {
  function ostream (line 20) | ostream& printPlueckerLine(ostream& os, const Line3D& l) {
  function main (line 32) | int main(int /*argc*/, char** /*argv*/) {

FILE: Thirdparty/g2o_new/g2o/examples/line_slam/simulator_3d_line.cpp
  function sample_noise_from_se3 (line 20) | Eigen::Isometry3d sample_noise_from_se3(const Vector6& cov) {
  function Vector4d (line 39) | Vector4d sample_noise_from_line(const Vector4d& cov) {
  type SimulatorItem (line 45) | struct SimulatorItem {
    method SimulatorItem (line 46) | SimulatorItem(OptimizableGraph* graph_) : _graph(graph_) {}
    method OptimizableGraph (line 47) | OptimizableGraph* graph() { return _graph; }
  type WorldItem (line 54) | struct WorldItem : public SimulatorItem {
    method WorldItem (line 55) | WorldItem(OptimizableGraph* graph_, OptimizableGraph::Vertex* vertex_ ...
    method setVertex (line 58) | void setVertex(OptimizableGraph::Vertex* vertex_) { _vertex = vertex_; }
  type Robot (line 66) | struct Robot
    method Robot (line 84) | Robot(OptimizableGraph* graph_) : WorldItem(graph_) {
    method move (line 89) | void move(const Isometry3d& newPosition, int& id) {
    method relativeMove (line 128) | void relativeMove(const Isometry3d& delta, int& id) {
    method sense (line 133) | void sense(WorldItem* wi = 0) {
  type Sensor (line 68) | struct Sensor {
    method Sensor (line 69) | Sensor(Robot* robot_) : _robot(robot_) {}
    method Robot (line 70) | Robot* robot() { return _robot; }
    method isVisible (line 71) | virtual bool isVisible(const WorldItem*) const { return false; }
    method sense (line 72) | virtual bool sense(WorldItem*, const Isometry3d&) { return false; }
  type Robot (line 81) | struct Robot : public WorldItem {
    method Robot (line 84) | Robot(OptimizableGraph* graph_) : WorldItem(graph_) {
    method move (line 89) | void move(const Isometry3d& newPosition, int& id) {
    method relativeMove (line 128) | void relativeMove(const Isometry3d& delta, int& id) {
    method sense (line 133) | void sense(WorldItem* wi = 0) {
  type Simulator (line 148) | struct Simulator : public SimulatorItem {
    method Simulator (line 149) | Simulator(OptimizableGraph* graph_)
    method sense (line 151) | void sense(int robotIndex) {
    method move (line 159) | void move(int robotIndex, const Isometry3d& newRobotPose) {
    method relativeMove (line 164) | void relativeMove(int robotIndex, const Isometry3d& delta) {
  type LineItem (line 174) | struct LineItem : public WorldItem {
    method LineItem (line 175) | LineItem(OptimizableGraph* graph_, int id) : WorldItem(graph_) {
  type LineSensor (line 183) | struct LineSensor : public Sensor {
    method LineSensor (line 186) | LineSensor(Robot* r, int offsetId, const Isometry3d& offset_) : Sensor...
    method isVisible (line 193) | virtual bool isVisible(const WorldItem* wi) const {
    method sense (line 204) | virtual bool sense(WorldItem* wi, const Isometry3d& position) {
  function main (line 248) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/logging/logging.cpp
  function main (line 29) | int main() {

FILE: Thirdparty/g2o_new/g2o/examples/plane_slam/plane_test.cpp
  function ostream (line 36) | ostream& operator<<(ostream& os, const Plane3D& p) {
  function transform (line 44) | void transform(PlaneList& l, const SE3Quat& t) {
  function ostream (line 51) | ostream& operator<<(ostream& os, const PlaneList& l) {
  function main (line 59) | int main(/*int argc, char** argv*/) {

FILE: Thirdparty/g2o_new/g2o/examples/plane_slam/simulator_3d_plane.cpp
  function sample_noise_from_se3 (line 44) | Eigen::Isometry3d sample_noise_from_se3(const Vector6& cov) {
  function Vector3d (line 63) | Vector3d sample_noise_from_plane(const Vector3d& cov) {
  type SimulatorItem (line 69) | struct SimulatorItem {
    method SimulatorItem (line 70) | SimulatorItem(OptimizableGraph* graph_) : _graph(graph_) {}
    method OptimizableGraph (line 71) | OptimizableGraph* graph() { return _graph; }
  type WorldItem (line 78) | struct WorldItem : public SimulatorItem {
    method WorldItem (line 79) | WorldItem(OptimizableGraph* graph_, OptimizableGraph::Vertex* vertex_ ...
    method setVertex (line 82) | void setVertex(OptimizableGraph::Vertex* vertex_) { _vertex = vertex_; }
  type Robot (line 90) | struct Robot
    method Robot (line 108) | Robot(OptimizableGraph* graph_) : WorldItem(graph_) {
    method move (line 113) | void move(const Isometry3d& newPosition, int& id) {
    method relativeMove (line 152) | void relativeMove(const Isometry3d& delta, int& id) {
    method sense (line 157) | void sense(WorldItem* wi = 0) {
  type Sensor (line 92) | struct Sensor {
    method Sensor (line 93) | Sensor(Robot* robot_) : _robot(robot_) {}
    method Robot (line 94) | Robot* robot() { return _robot; }
    method isVisible (line 95) | virtual bool isVisible(const WorldItem*) const { return false; }
    method sense (line 96) | virtual bool sense(WorldItem*, const Isometry3d&) { return false; }
  type Robot (line 105) | struct Robot : public WorldItem {
    method Robot (line 108) | Robot(OptimizableGraph* graph_) : WorldItem(graph_) {
    method move (line 113) | void move(const Isometry3d& newPosition, int& id) {
    method relativeMove (line 152) | void relativeMove(const Isometry3d& delta, int& id) {
    method sense (line 157) | void sense(WorldItem* wi = 0) {
  type Simulator (line 172) | struct Simulator : public SimulatorItem {
    method Simulator (line 173) | Simulator(OptimizableGraph* graph_)
    method sense (line 175) | void sense(int robotIndex) {
    method move (line 183) | void move(int robotIndex, const Isometry3d& newRobotPose) {
    method relativeMove (line 188) | void relativeMove(int robotIndex, const Isometry3d& delta) {
  type PlaneItem (line 198) | struct PlaneItem : public WorldItem {
    method PlaneItem (line 199) | PlaneItem(OptimizableGraph* graph_, int id) : WorldItem(graph_) {
  type PlaneSensor (line 207) | struct PlaneSensor : public Sensor {
    method PlaneSensor (line 210) | PlaneSensor(Robot* r, int offsetId, const Isometry3d& offset_) : Senso...
    method isVisible (line 217) | virtual bool isVisible(const WorldItem* wi) const {
    method sense (line 224) | virtual bool sense(WorldItem* wi, const Isometry3d& position) {
  function main (line 263) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/sba/sba_demo.cpp
  class Sample (line 52) | class Sample {
    method uniform (line 54) | static int uniform(int from, int to) {
  function main (line 59) | int main(int argc, const char* argv[]) {

FILE: Thirdparty/g2o_new/g2o/examples/sim3/optimize_sphere_by_sim3.cpp
  function ToVertexSim3 (line 54) | void ToVertexSim3(const g2o::VertexSE3& v_se3,
  function ToVertexSE3 (line 65) | void ToVertexSE3(const g2o::VertexSim3Expmap& v_sim3,
  function ToEdgeSim3 (line 78) | void ToEdgeSim3(const g2o::EdgeSE3& e_se3, g2o::EdgeSim3* const e_sim3) {
  function main (line 93) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/simple_optimize/simple_optimize.cpp
  function main (line 42) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/slam2d/slam2d_g2o.cpp
  function main (line 30) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/slam2d/slam2d_viewer.cpp
  type g2o (line 47) | namespace g2o {
    class StandardCamera (line 54) | class StandardCamera : public qglviewer::Camera {
      method StandardCamera (line 56) | StandardCamera() : _standard(true) {}
      method qglv_real (line 58) | qglv_real zNear() const {
      method qglv_real (line 65) | qglv_real zFar() const {
    function drawSE2 (line 79) | void drawSE2(const VertexSE2* v) {
    function drawCov (line 96) | void drawCov(const Eigen::Vector2d& p, const Eigen::MatrixBase<Derived...

FILE: Thirdparty/g2o_new/g2o/examples/slam2d/slam2d_viewer.h
  function namespace (line 25) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/sphere/create_sphere.cpp
  function main (line 42) | int main(int argc, char** argv) {

FILE: Thirdparty/g2o_new/g2o/examples/target/constant_velocity_target.cpp
  function main (line 49) | int main() {

FILE: Thirdparty/g2o_new/g2o/examples/target/continuous_to_discrete.h
  type Eigen (line 17) | typedef Eigen::Matrix<typename

FILE: Thirdparty/g2o_new/g2o/examples/target/static_target.cpp
  function main (line 46) | int main() {

FILE: Thirdparty/g2o_new/g2o/examples/target/targetTypes3D.hpp
  class VertexPosition3D (line 12) | class VertexPosition3D : public g2o::BaseVertex<3, Eigen::Vector3d> {
    method EIGEN_MAKE_ALIGNED_OPERATOR_NEW (line 14) | EIGEN_MAKE_ALIGNED_OPERATOR_NEW
    method setToOriginImpl (line 17) | virtual void setToOriginImpl() { _estimate.setZero(); }
    method oplusImpl (line 19) | virtual void oplusImpl(const double* update) {
    method read (line 25) | virtual bool read(std::istream& /*is*/) { return false; }
    method write (line 27) | virtual bool write(std::ostream& /*os*/) const { return false; }
  class VertexVelocity3D (line 31) | class VertexVelocity3D : public g2o::BaseVertex<3, Eigen::Vector3d> {
    method EIGEN_MAKE_ALIGNED_OPERATOR_NEW (line 33) | EIGEN_MAKE_ALIGNED_OPERATOR_NEW
    method setToOriginImpl (line 36) | virtual void setToOriginImpl() { _estimate.setZero(); }
    method oplusImpl (line 38) | virtual void oplusImpl(const double* update) {
    method read (line 44) | virtual bool read(std::istream& /*is*/) { return false; }
    method write (line 46) | virtual bool write(std::ostream& /*os*/) const { return false; }
  class GPSObservationPosition3DEdge (line 50) | class GPSObservationPosition3DEdge
    method GPSObservationPosition3DEdge (line 53) | GPSObservationPosition3DEdge() {}
    method computeError (line 55) | void computeError() {
    method read (line 61) | virtual bool read(std::istream& /*is*/) { return false; }
    method write (line 63) | virtual bool write(std::ostream& /*os*/) const { return false; }

FILE: Thirdparty/g2o_new/g2o/examples/target/targetTypes6D.hpp
  class VertexPosition3D (line 19) | class VertexPosition3D : public g2o::BaseVertex<3, Eigen::Vector3d> {
    method EIGEN_MAKE_ALIGNED_OPERATOR_NEW (line 21) | EIGEN_MAKE_ALIGNED_OPERATOR_NEW
    method setToOriginImpl (line 24) | virtual void setToOriginImpl() { _estimate.setZero(); }
    method oplusImpl (line 26) | virtual void oplusImpl(const double* update) {
    method read (line 32) | virtual bool read(std::istream& /*is*/) { return false; }
    method write (line 34) | virtual bool write(std::ostream& /*os*/) const { return false; }
  class PositionVelocity3DEdge (line 37) | class PositionVelocity3DEdge {}
  class VertexPositionVelocity3D (line 39) | class VertexPositionVelocity3D : public g2o::BaseVertex<6, Vector6d> {
    method EIGEN_MAKE_ALIGNED_OPERATOR_NEW (line 41) | EIGEN_MAKE_ALIGNED_OPERATOR_NEW
    method setToOriginImpl (line 44) | virtual void setToOriginImpl() { _estimate.setZero(); }
    method oplusImpl (line 46) | virtual void oplusImpl(const double* update) {
    method read (line 50) | virtual bool read(std::istream& /*is*/) { return false; }
    method write (line 52) | virtual bool write(std::ostream& /*os*/) const { return false; }
  class TargetOdometry3DEdge (line 56) | class TargetOdometry3DEdge
    method TargetOdometry3DEdge (line 60) | TargetOdometry3DEdge(double dt, double noiseSigma) {
    method initialEstimate (line 80) | virtual void initialEstimate(const g2o::OptimizableGraph::VertexSet& f...
    method initialEstimatePossible (line 101) | virtual double initialEstimatePossible(
    method computeError (line 110) | void computeError() {
    method read (line 127) | virtual bool read(std::istream& /*is*/) { return false; }
    method write (line 129) | virtual bool write(std::ostream& /*os*/) const { return false; }
  class GPSObservationEdgePositionVelocity3D (line 136) | class GPSObservationEdgePositionVelocity3D
    method GPSObservationEdgePositionVelocity3D (line 139) | GPSObservationEdgePositionVelocity3D(const Eigen::Vector3d& measurement,
    method computeError (line 145) | void computeError() {
    method read (line 153) | virtual bool read(std::istream& /*is*/) { return false; }
    method write (line 155) | virtual bool write(std::ostream& /*os*/) const { return false; }

FILE: Thirdparty/g2o_new/g2o/examples/tutorial_slam2d/edge_se2.cpp
  type g2o (line 31) | namespace g2o {
    type tutorial (line 32) | namespace tutorial {

FILE: Thirdparty/g2o_new/g2o/examples/tutorial_slam2d/edge_se2.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/tutorial_slam2d/edge_se2_pointxy.cpp
  type g2o (line 31) | namespace g2o {
    type tutorial (line 32) | namespace tutorial {

FILE: Thirdparty/g2o_new/g2o/examples/tutorial_slam2d/edge_se2_pointxy.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/tutorial_slam2d/parameter_se2_offset.cpp
  type g2o (line 31) | namespace g2o {
    type tutorial (line 32) | namespace tutorial {

FILE: Thirdparty/g2o_new/g2o/examples/tutorial_slam2d/parameter_se2_offset.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/tutorial_slam2d/se2.h
  function namespace (line 38) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/tutorial_slam2d/simulator.cpp
  type g2o (line 36) | namespace g2o {
    type tutorial (line 37) | namespace tutorial {
      function round (line 42) | inline double round(double number) {
      function SE2 (line 301) | SE2 Simulator::getMotion(int motionDirection, double stepLen) {
      function SE2 (line 313) | SE2 Simulator::sampleTransformation(const SE2& trueMotion_,

FILE: Thirdparty/g2o_new/g2o/examples/tutorial_slam2d/simulator.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/tutorial_slam2d/tutorial_slam2d.cpp
  function main (line 47) | int main() {

FILE: Thirdparty/g2o_new/g2o/examples/tutorial_slam2d/types_tutorial_slam2d.cpp
  type g2o (line 34) | namespace g2o {
    type tutorial (line 35) | namespace tutorial {

FILE: Thirdparty/g2o_new/g2o/examples/tutorial_slam2d/vertex_point_xy.cpp
  type g2o (line 31) | namespace g2o {
    type tutorial (line 32) | namespace tutorial {

FILE: Thirdparty/g2o_new/g2o/examples/tutorial_slam2d/vertex_point_xy.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/examples/tutorial_slam2d/vertex_se2.cpp
  type g2o (line 29) | namespace g2o {
    type tutorial (line 30) | namespace tutorial {

FILE: Thirdparty/g2o_new/g2o/examples/tutorial_slam2d/vertex_se2.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/solvers/cholmod/cholmod_ext.h
  function namespace (line 32) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/solvers/cholmod/cholmod_wrapper.cpp
  type g2o (line 37) | namespace g2o {
    type cholmod (line 38) | namespace cholmod {
      class Cholmod::Impl (line 40) | class Cholmod::Impl {
        method Impl (line 42) | Impl() {
        method freeFactor (line 58) | void freeFactor() {

FILE: Thirdparty/g2o_new/g2o/solvers/cholmod/cholmod_wrapper.h
  function class (line 36) | class Cholmod {

FILE: Thirdparty/g2o_new/g2o/solvers/cholmod/linear_solver_cholmod.h
  function virtual (line 78) | virtual bool saveMatrix(const std::string& fileName) {
  function computeSymbolicDecomposition (line 91) | void computeSymbolicDecomposition(const SparseBlockMatrix<MatrixType>& A) {

FILE: Thirdparty/g2o_new/g2o/solvers/cholmod/solver_cholmod.cpp
  type g2o (line 40) | namespace g2o {
    function AllocateSolver (line 44) | std::unique_ptr<BlockSolverBase> AllocateSolver() {
    function OptimizationAlgorithm (line 54) | static OptimizationAlgorithm* createSolver(const std::string& fullSolv...
    class CholmodSolverCreator (line 86) | class CholmodSolverCreator : public AbstractOptimizationAlgorithmCreat...
      method CholmodSolverCreator (line 88) | explicit CholmodSolverCreator(const OptimizationAlgorithmProperty& p)
      method OptimizationAlgorithm (line 90) | virtual OptimizationAlgorithm* construct() {

FILE: Thirdparty/g2o_new/g2o/solvers/csparse/csparse_extension.cpp
  type g2o::csparse_extension (line 27) | namespace g2o::csparse_extension {
    function cs_cholsolsymb (line 33) | int cs_cholsolsymb(const cs* A, double* b, const css* S, double* x, in...
    function csn (line 62) | csn* cs_chol_workspace(const cs* A, const css* S, int* cin, double* xi...

FILE: Thirdparty/g2o_new/g2o/solvers/csparse/csparse_extension.h
  function namespace (line 31) | namespace g2o::csparse_extension {

FILE: Thirdparty/g2o_new/g2o/solvers/csparse/csparse_helper.cpp
  type g2o (line 33) | namespace g2o {
    type csparse_extension (line 34) | namespace csparse_extension {
      function writeCs2Octave (line 36) | bool writeCs2Octave(const char* filename, const cs* A, bool upperTri...

FILE: Thirdparty/g2o_new/g2o/solvers/csparse/csparse_helper.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/solvers/csparse/csparse_wrapper.cpp
  type g2o (line 38) | namespace g2o {
    type csparse (line 39) | namespace csparse {
      type CSparseExt (line 44) | struct CSparseExt : public cs {
        method CSparseExt (line 45) | CSparseExt() {
        method CSparseExt (line 54) | CSparseExt(CSparseExt const&) = delete;
        method CSparseExt (line 55) | CSparseExt& operator=(CSparseExt const&) = delete;
      class CSparse::Impl (line 67) | class CSparse::Impl {
        method Impl (line 69) | Impl() = default;
        method prepareWorkspace (line 85) | void prepareWorkspace() {

FILE: Thirdparty/g2o_new/g2o/solvers/csparse/csparse_wrapper.h
  function class (line 38) | class CSparse {

FILE: Thirdparty/g2o_new/g2o/solvers/csparse/linear_solver_csparse.h
  function virtual (line 57) | virtual bool init() {
  function solve (line 62) | bool solve(const SparseBlockMatrix<MatrixType>& A, double* x, double* b) {
  function prepareSolve (line 88) | void prepareSolve(const SparseBlockMatrix<MatrixType>& A) {
  function computeSymbolicDecomposition (line 98) | void computeSymbolicDecomposition(const SparseBlockMatrix<MatrixType>& A) {

FILE: Thirdparty/g2o_new/g2o/solvers/csparse/solver_csparse.cpp
  type g2o (line 30) | namespace g2o {
    function AllocateSolver (line 34) | std::unique_ptr<BlockSolverBase> AllocateSolver() {
    function OptimizationAlgorithm (line 47) | static OptimizationAlgorithm* createSolver(const std::string& fullSolv...
    class CSparseSolverCreator (line 77) | class CSparseSolverCreator : public AbstractOptimizationAlgorithmCreat...
      method CSparseSolverCreator (line 79) | explicit CSparseSolverCreator(const OptimizationAlgorithmProperty& p)
      method OptimizationAlgorithm (line 81) | virtual OptimizationAlgorithm* construct() {

FILE: Thirdparty/g2o_new/g2o/solvers/dense/linear_solver_dense.h
  function namespace (line 40) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/solvers/dense/solver_dense.cpp
  type g2o (line 38) | namespace g2o {
    function AllocateSolver (line 41) | std::unique_ptr<g2o::Solver> AllocateSolver() {
    function OptimizationAlgorithm (line 49) | static OptimizationAlgorithm* createSolver(const std::string& fullSolv...
    class DenseSolverCreator (line 74) | class DenseSolverCreator : public AbstractOptimizationAlgorithmCreator {
      method DenseSolverCreator (line 76) | explicit DenseSolverCreator(const OptimizationAlgorithmProperty& p)
      method OptimizationAlgorithm (line 78) | virtual OptimizationAlgorithm* construct() {

FILE: Thirdparty/g2o_new/g2o/solvers/eigen/linear_solver_eigen.h
  function namespace (line 42) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/solvers/eigen/solver_eigen.cpp
  type g2o (line 40) | namespace g2o {
    function AllocateSolver (line 44) | std::unique_ptr<BlockSolverBase> AllocateSolver() {
    function OptimizationAlgorithm (line 58) | static OptimizationAlgorithm* createSolver(const std::string& fullSolv...
    class EigenSolverCreator (line 88) | class EigenSolverCreator : public AbstractOptimizationAlgorithmCreator {
      method EigenSolverCreator (line 90) | explicit EigenSolverCreator(const OptimizationAlgorithmProperty& p)
      method OptimizationAlgorithm (line 92) | virtual OptimizationAlgorithm* construct() {

FILE: Thirdparty/g2o_new/g2o/solvers/pcg/linear_solver_pcg.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/solvers/pcg/linear_solver_pcg.hpp
  type internal (line 33) | namespace internal {
    function pcg_axy (line 40) | void pcg_axy(const MatrixType& A, const VectorX& x, int xoff, VectorX& y,
    function pcg_axy (line 46) | inline void pcg_axy(const MatrixType& A, const VectorX& x, int xoff, V...
    function pcg_axy (line 53) | inline void pcg_axy(const MatrixX& A, const VectorX& x, int xoff, Vect...
    function pcg_axpy (line 60) | inline void pcg_axpy(const MatrixType& A, const VectorX& x, int xoff,
    function pcg_axpy (line 67) | inline void pcg_axpy(const MatrixX& A, const VectorX& x, int xoff, Vec...
    function pcg_atxpy (line 73) | inline void pcg_atxpy(const MatrixType& A, const VectorX& x, int xoff,
    function pcg_atxpy (line 80) | inline void pcg_atxpy(const MatrixX& A, const VectorX& x, int xoff, Ve...

FILE: Thirdparty/g2o_new/g2o/solvers/pcg/solver_pcg.cpp
  type g2o (line 38) | namespace g2o {
    function AllocateSolver (line 41) | std::unique_ptr<g2o::Solver> AllocateSolver() {
    function OptimizationAlgorithm (line 49) | static OptimizationAlgorithm* createSolver(const std::string& fullSolv...
    class PCGSolverCreator (line 74) | class PCGSolverCreator : public AbstractOptimizationAlgorithmCreator {
      method PCGSolverCreator (line 76) | explicit PCGSolverCreator(const OptimizationAlgorithmProperty& p)
      method OptimizationAlgorithm (line 78) | virtual OptimizationAlgorithm* construct() {

FILE: Thirdparty/g2o_new/g2o/solvers/slam2d_linear/slam2d_linear.cpp
  type g2o (line 37) | namespace g2o {
    function AllocateSolver (line 41) | std::unique_ptr<BlockSolverBase> AllocateSolver() {
    function OptimizationAlgorithm (line 54) | static OptimizationAlgorithm* createSolver(const std::string& fullSolv...
    class SLAM2DLinearSolverCreator (line 60) | class SLAM2DLinearSolverCreator : public AbstractOptimizationAlgorithm...
      method SLAM2DLinearSolverCreator (line 62) | explicit SLAM2DLinearSolverCreator(const OptimizationAlgorithmProper...
      method OptimizationAlgorithm (line 64) | virtual OptimizationAlgorithm* construct() {

FILE: Thirdparty/g2o_new/g2o/solvers/slam2d_linear/solver_slam2d_linear.cpp
  type g2o (line 43) | namespace g2o {
    class ThetaTreeAction (line 48) | class ThetaTreeAction : public HyperDijkstra::TreeAction {
      method ThetaTreeAction (line 50) | explicit ThetaTreeAction(VectorX& theta)
      method perform (line 52) | virtual double perform(HyperGraph::Vertex* v, HyperGraph::Vertex* vP...

FILE: Thirdparty/g2o_new/g2o/solvers/slam2d_linear/solver_slam2d_linear.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/solvers/structure_only/structure_only.cpp
  type g2o (line 32) | namespace g2o {
    function OptimizationAlgorithm (line 37) | static OptimizationAlgorithm* createSolver(const std::string& fullSolv...
    class StructureOnlyCreator (line 48) | class StructureOnlyCreator : public AbstractOptimizationAlgorithmCreat...
      method StructureOnlyCreator (line 50) | explicit StructureOnlyCreator(const OptimizationAlgorithmProperty& p)
      method OptimizationAlgorithm (line 52) | virtual OptimizationAlgorithm* construct() {

FILE: Thirdparty/g2o_new/g2o/solvers/structure_only/structure_only_solver.h
  function namespace (line 39) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/stuff/command_args.cpp
  type g2o (line 36) | namespace g2o {
    function readVector (line 41) | void readVector(const std::string& s, std::vector<T>& v) {
    function writeVectorAsString (line 52) | std::string writeVectorAsString(const std::vector<T>& v) {
    function parseArgument (line 60) | void parseArgument(const std::string& input, CommandArgs::CommandArgum...
    function parseVector (line 70) | void parseVector(const std::string& input, CommandArgs::CommandArgumen...
    function argument2String (line 81) | std::string argument2String(const CommandArgs::CommandArgument& ca) {
    type CommandArgumentType (line 90) | enum CommandArgumentType {

FILE: Thirdparty/g2o_new/g2o/stuff/command_args.h
  function class (line 45) | class G2O_STUFF_API CommandArgs {

FILE: Thirdparty/g2o_new/g2o/stuff/filesys_tools.cpp
  type g2o (line 33) | namespace g2o {
    function getFileExtension (line 35) | std::string getFileExtension(std::string_view filename) {
    function getPureFilename (line 42) | std::string getPureFilename(std::string_view filename) {
    function getBasename (line 50) | std::string getBasename(std::string_view filename) {
    function getDirname (line 55) | std::string getDirname(std::string_view filename) {
    function changeFileExtension (line 60) | std::string changeFileExtension(std::string_view filename,
    function fileExists (line 70) | bool fileExists(std::string_view filename, bool regular) {
    function getFilesByPattern (line 76) | std::vector<std::string> getFilesByPattern(std::string_view directory,

FILE: Thirdparty/g2o_new/g2o/stuff/filesys_tools.h
  function namespace (line 44) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/stuff/logger.cpp
  type g2o::internal (line 41) | namespace g2o::internal {
  type g2o::logging (line 58) | namespace g2o::logging {
    function setLevel (line 60) | void setLevel(Level level) {

FILE: Thirdparty/g2o_new/g2o/stuff/logger.h
  function namespace (line 38) | namespace g2o {
  function namespace (line 118) | namespace g2o::logging {

FILE: Thirdparty/g2o_new/g2o/stuff/misc.h
  function namespace (line 41) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/stuff/opengl_primitives.cpp
  type g2o (line 30) | namespace g2o {
    type opengl (line 31) | namespace opengl {
      class GLUWrapper (line 36) | class GLUWrapper {
        method GLUquadricObj (line 38) | static GLUquadricObj* getQuadradic() {
        method GLUWrapper (line 44) | GLUWrapper() {
      function drawArrow2D (line 53) | void drawArrow2D(float len, float head_width, float head_len) {
      function drawPoseBox (line 67) | void drawPoseBox() {
      function drawBox (line 100) | void drawBox(GLfloat l, GLfloat w, GLfloat h) {
      function drawPlane (line 145) | void drawPlane(GLfloat l, GLfloat w) {
      function drawSphere (line 158) | void drawSphere(GLfloat radius) {
      function drawEllipsoid (line 162) | void drawEllipsoid(GLfloat r1, GLfloat r2, GLfloat r3) {
      function drawCone (line 172) | void drawCone(GLfloat radius, GLfloat height) {
      function drawCylinder (line 181) | void drawCylinder(GLfloat radius, GLfloat height) {
      function drawDisk (line 193) | void drawDisk(GLfloat radius) {
      function drawCircle (line 198) | void drawCircle(GLfloat radius, int segments) {
      function drawPyramid (line 210) | void drawPyramid(GLfloat length, GLfloat height) {
      function drawRangeRing (line 219) | void drawRangeRing(GLfloat range, GLfloat fov, GLfloat range_width) {
      function drawSlice (line 227) | void drawSlice(GLfloat radius, GLfloat height, GLfloat fov,
      function drawPoint (line 297) | void drawPoint(float pointSize) {

FILE: Thirdparty/g2o_new/g2o/stuff/opengl_primitives.h
  function namespace (line 46) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/stuff/property.cpp
  type g2o (line 37) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/stuff/property.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/stuff/sampler.cpp
  type g2o (line 29) | namespace g2o {
    function sampleUniform (line 35) | double sampleUniform(double min, double max, std::mt19937* generator) {
    function sampleGaussian (line 40) | double sampleGaussian(std::mt19937* generator) {

FILE: Thirdparty/g2o_new/g2o/stuff/sampler.h
  function namespace (line 40) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/stuff/sparse_helper.cpp
  type g2o (line 37) | namespace g2o {
    function writeTripletEntries (line 39) | static bool writeTripletEntries(const std::string& filename, int rows,...
    function writeVector (line 61) | bool writeVector(const string& filename, const double* v, int n) {
    function writeCCSMatrix (line 68) | bool writeCCSMatrix(const string& filename, int rows, int cols, const ...
    function writeTripletMatrix (line 86) | bool writeTripletMatrix(const std::string& filename, int nz, int rows,...

FILE: Thirdparty/g2o_new/g2o/stuff/sparse_helper.h
  type TripletEntry (line 37) | struct TripletEntry {

FILE: Thirdparty/g2o_new/g2o/stuff/string_tools.cpp
  type g2o (line 41) | namespace g2o {
    function trim (line 45) | std::string trim(const std::string& s) {
    function trimLeft (line 53) | std::string trimLeft(const std::string& s) {
    function trimRight (line 61) | std::string trimRight(const std::string& s) {
    function strToLower (line 69) | std::string strToLower(const std::string& s) {
    function strToUpper (line 77) | std::string strToUpper(const std::string& s) {
    function strExpandFilename (line 85) | std::string strExpandFilename(const std::string& filename) {
    function strSplit (line 103) | std::vector<std::string> strSplit(const std::string& str,
    function strStartsWith (line 119) | bool strStartsWith(const std::string& s, const std::string& start) {
    function strEndsWith (line 124) | bool strEndsWith(const std::string& s, const std::string& end) {
    function readLine (line 129) | int readLine(std::istream& is, std::stringstream& currentLine) {
    function skipLine (line 143) | void skipLine(std::istream& is) {

FILE: Thirdparty/g2o_new/g2o/stuff/string_tools.h
  function namespace (line 38) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/stuff/tictoc.cpp
  type g2o (line 39) | namespace g2o {
    type TicTocElement (line 44) | struct TicTocElement {
      method TicTocElement (line 54) | TicTocElement()
    type TicTocInitializer (line 72) | struct TicTocInitializer {
      method TicTocInitializer (line 75) | TicTocInitializer() { enabled = getenv("G2O_ENABLE_TICTOC") != NULL; }
    function tictoc (line 118) | double tictoc(const char* algorithmPart) {

FILE: Thirdparty/g2o_new/g2o/stuff/tictoc.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/stuff/timeutil.cpp
  type g2o (line 33) | namespace g2o {
    function get_monotonic_time (line 43) | double get_monotonic_time() {

FILE: Thirdparty/g2o_new/g2o/stuff/timeutil.h
  function get_time (line 81) | inline double get_time() {

FILE: Thirdparty/g2o_new/g2o/stuff/tuple_tools.h
  function namespace (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/stuff/unscented.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/data/data_queue.cpp
  type g2o (line 31) | namespace g2o {
    function RobotData (line 33) | RobotData* DataQueue::findClosestData(double timestamp) const {
    function RobotData (line 46) | RobotData* DataQueue::before(double timestamp) const {
    function RobotData (line 54) | RobotData* DataQueue::after(double timestamp) const {

FILE: Thirdparty/g2o_new/g2o/types/data/data_queue.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/data/laser_parameters.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/data/laser_parameters.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/data/raw_laser.cpp
  type g2o (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/data/raw_laser.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/data/robot_data.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/data/robot_data.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/data/robot_laser.cpp
  type g2o (line 38) | namespace g2o {
    function HyperGraphElementAction (line 136) | HyperGraphElementAction* RobotLaserDrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/data/robot_laser.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/data/types_data.cpp
  type g2o (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/data/vertex_ellipse.cpp
  type g2o (line 43) | namespace g2o {
    function HyperGraphElementAction (line 117) | HyperGraphElementAction* VertexEllipseDrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/data/vertex_ellipse.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/data/vertex_tag.cpp
  type g2o (line 40) | namespace g2o {
    function HyperGraphElementAction (line 82) | HyperGraphElementAction* VertexTagDrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/data/vertex_tag.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/icp/types_icp.cpp
  type g2o (line 36) | namespace g2o {
    type types_icp (line 41) | namespace types_icp {
      function init (line 44) | void init() {
    function G2O_ATTRIBUTE_CONSTRUCTOR (line 70) | G2O_ATTRIBUTE_CONSTRUCTOR(init_icp_types) { types_icp::init(); }

FILE: Thirdparty/g2o_new/g2o/types/icp/types_icp.h
  function namespace (line 43) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_p2mc.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_p2mc.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_p2sc.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_p2sc.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_psi2uv.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_psi2uv.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_stereo_xyz.cpp
  type g2o (line 29) | namespace g2o {
    function Vector3 (line 34) | Vector3 EdgeStereoSE3ProjectXYZ::cam_project(const Vector3& trans_xyz,

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_stereo_xyz.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_stereo_xyz_onlypose.cpp
  type g2o (line 29) | namespace g2o {
    function Vector3 (line 83) | Vector3 EdgeStereoSE3ProjectXYZOnlyPose::cam_project(

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_stereo_xyz_onlypose.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_xyz.cpp
  type g2o (line 29) | namespace g2o {
    function Vector2 (line 95) | Vector2 EdgeSE3ProjectXYZ::cam_project(const Vector3& trans_xyz) const {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_xyz.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_xyz2uv.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_xyz2uv.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_xyz2uvu.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_xyz2uvu.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_xyz_onlypose.cpp
  type g2o (line 29) | namespace g2o {
    function Vector2 (line 65) | Vector2 EdgeSE3ProjectXYZOnlyPose::cam_project(const Vector3& trans_xy...

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_project_xyz_onlypose.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_sba_cam.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_sba_cam.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_sba_scale.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_sba_scale.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_se3_expmap.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/edge_se3_expmap.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/parameter_cameraparameters.cpp
  type g2o (line 31) | namespace g2o {
    function Vector2 (line 59) | Vector2 CameraParameters::cam_map(const Vector3& trans_xyz) const {
    function Vector3 (line 67) | Vector3 CameraParameters::stereocam_uvu_map(const Vector3& trans_xyz) ...

FILE: Thirdparty/g2o_new/g2o/types/sba/parameter_cameraparameters.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/sba_utils.h
  function namespace (line 33) | namespace g2o {
  function Matrix3 (line 59) | inline Matrix3 d_Tinvpsi_d_psi(const SE3Quat& T, const Vector3& psi) {

FILE: Thirdparty/g2o_new/g2o/types/sba/sbacam.cpp
  type g2o (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/sbacam.h
  function namespace (line 44) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/types_sba.cpp
  type g2o (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/types_six_dof_expmap.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/vertex_cam.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/vertex_cam.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/vertex_intrinsics.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/vertex_intrinsics.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/vertex_se3_expmap.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sba/vertex_se3_expmap.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sclam2d/edge_se2_odom_differential_calib.cpp
  type g2o (line 33) | namespace g2o {
    function HyperGraphElementAction (line 57) | HyperGraphElementAction* EdgeSE2OdomDifferentialCalibDrawAction::opera...

FILE: Thirdparty/g2o_new/g2o/types/sclam2d/edge_se2_odom_differential_calib.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sclam2d/edge_se2_sensor_calib.cpp
  type g2o (line 31) | namespace g2o {
    function HyperGraphElementAction (line 69) | HyperGraphElementAction* EdgeSE2SensorCalibDrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/sclam2d/edge_se2_sensor_calib.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sclam2d/odometry_measurement.cpp
  type g2o (line 32) | namespace g2o {
    function VelocityMeasurement (line 48) | VelocityMeasurement OdomConvert::convertToVelocity(const MotionMeasure...
    function MotionMeasurement (line 69) | MotionMeasurement OdomConvert::convertToMotion(const VelocityMeasureme...

FILE: Thirdparty/g2o_new/g2o/types/sclam2d/odometry_measurement.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sclam2d/types_sclam2d.cpp
  type g2o (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sclam2d/vertex_odom_differential_params.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sclam2d/vertex_odom_differential_params.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sim3/sim3.h
  function namespace (line 36) | namespace g2o {
  function Vector3 (line 126) | Vector3 map(const Vector3& xyz) const { return s * (r * xyz) + t; }
  function Vector7 (line 128) | Vector7 log() const {
  function const (line 204) | double operator[](int i) const {
  function normalizeRotation (line 239) | void normalizeRotation() {
  function Vector3 (line 247) | inline Vector3& translation() { return t; }
  function Quaternion (line 251) | inline Quaternion& rotation() { return r; }
  function scale (line 255) | inline double& scale() { return s; }

FILE: Thirdparty/g2o_new/g2o/types/sim3/types_seven_dof_expmap.cpp
  type g2o (line 32) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/sim3/types_seven_dof_expmap.h
  function virtual (line 75) | virtual void setToOriginImpl() { _estimate = Sim3(); }
  function virtual (line 77) | virtual void oplusImpl(const double* update_) {
  function Vector2 (line 89) | Vector2 cam_map1(const Vector2& v) const {
  function Vector2 (line 96) | Vector2 cam_map2(const Vector2& v) const {
  function virtual (line 117) | virtual bool write(std::ostream& os) const;
  function virtual (line 129) | virtual double initialEstimatePossible(const OptimizableGraph::VertexSet&,
  function virtual (line 133) | virtual void initialEstimate(const OptimizableGraph::VertexSet& from,
  function computeError (line 156) | void computeError() {
  function computeError (line 177) | void computeError() {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_pointxy.cpp
  type g2o (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_pointxy.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2.cpp
  type g2o (line 34) | namespace g2o {
    function HyperGraphElementAction (line 89) | HyperGraphElementAction* EdgeSE2WriteGnuplotAction::operator()(
    function HyperGraphElementAction (line 133) | HyperGraphElementAction* EdgeSE2DrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_lotsofxy.cpp
  type g2o (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_lotsofxy.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_offset.cpp
  type g2o (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_offset.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_pointxy.cpp
  type g2o (line 36) | namespace g2o {
    function HyperGraphElementAction (line 95) | HyperGraphElementAction* EdgeSE2PointXYWriteGnuplotAction::operator()(
    function HyperGraphElementAction (line 122) | HyperGraphElementAction* EdgeSE2PointXYDrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_pointxy.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_pointxy_bearing.cpp
  type g2o (line 36) | namespace g2o {
    function HyperGraphElementAction (line 89) | HyperGraphElementAction* EdgeSE2PointXYBearingWriteGnuplotAction::oper...
    function HyperGraphElementAction (line 115) | HyperGraphElementAction* EdgeSE2PointXYBearingDrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_pointxy_bearing.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_pointxy_calib.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_pointxy_calib.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_pointxy_offset.cpp
  type g2o (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_pointxy_offset.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_prior.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_prior.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_twopointsxy.cpp
  type g2o (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_twopointsxy.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_xyprior.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_se2_xyprior.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_xy_prior.cpp
  type g2o (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/edge_xy_prior.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/parameter_se2_offset.cpp
  type g2o (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/parameter_se2_offset.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/se2.h
  function namespace (line 38) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/types_slam2d.cpp
  type g2o (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/vertex_point_xy.cpp
  type g2o (line 38) | namespace g2o {
    function HyperGraphElementAction (line 55) | HyperGraphElementAction* VertexPointXYWriteGnuplotAction::operator()(
    function HyperGraphElementAction (line 87) | HyperGraphElementAction* VertexPointXYDrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam2d/vertex_point_xy.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d/vertex_se2.cpp
  type g2o (line 36) | namespace g2o {
    function HyperGraphElementAction (line 54) | HyperGraphElementAction* VertexSE2WriteGnuplotAction::operator()(
    function HyperGraphElementAction (line 93) | HyperGraphElementAction* VertexSE2DrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam2d/vertex_se2.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/edge_line2d.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/edge_line2d.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/edge_line2d_pointxy.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/edge_line2d_pointxy.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/edge_se2_line2d.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/edge_se2_line2d.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/edge_se2_segment2d.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/edge_se2_segment2d.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/edge_se2_segment2d_line.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/edge_se2_segment2d_line.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/edge_se2_segment2d_pointLine.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/edge_se2_segment2d_pointLine.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/line_2d.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/types_slam2d_addons.cpp
  type g2o (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/vertex_line2d.cpp
  type g2o (line 35) | namespace g2o {
    function HyperGraphElementAction (line 67) | HyperGraphElementAction* VertexLine2DDrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/vertex_line2d.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/vertex_segment2d.cpp
  type g2o (line 37) | namespace g2o {
    function HyperGraphElementAction (line 54) | HyperGraphElementAction* VertexSegment2DWriteGnuplotAction::operator()(
    function HyperGraphElementAction (line 90) | HyperGraphElementAction* VertexSegment2DDrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam2d_addons/vertex_segment2d.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/dquat2mat.cpp
  type g2o (line 30) | namespace g2o {
    type internal (line 31) | namespace internal {
      function _q2m (line 36) | int _q2m(double& S, double& qw, const double& r00, const double& r10,
      function compute_dq_dR (line 71) | void compute_dq_dR(Eigen::Matrix<double, 3, 9, Eigen::ColMajor>& dq_dR,

FILE: Thirdparty/g2o_new/g2o/types/slam3d/dquat2mat.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/dquat2mat_maxima_generated.cpp
  function compute_dq_dR_w (line 27) | void compute_dq_dR_w(Eigen::Matrix<double, 3, 9>& dq_dR_w, const double&...
  function compute_dq_dR_x (line 69) | void compute_dq_dR_x(Eigen::Matrix<double, 3, 9>& dq_dR_x, const double&...
  function compute_dq_dR_y (line 114) | void compute_dq_dR_y(Eigen::Matrix<double, 3, 9>& dq_dR_y, const double&...
  function compute_dq_dR_z (line 159) | void compute_dq_dR_z(Eigen::Matrix<double, 3, 9>& dq_dR_z, const double&...
  function compute_dR_dq (line 204) | void compute_dR_dq(Eigen::Matrix<double, 9, 3>& dR_dq, const double& qx,

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_pointxyz.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_pointxyz.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_se3.cpp
  type g2o (line 36) | namespace g2o {
    function HyperGraphElementAction (line 104) | HyperGraphElementAction* EdgeSE3WriteGnuplotAction::operator()(
    function HyperGraphElementAction (line 133) | HyperGraphElementAction* EdgeSE3DrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_se3.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_se3_lotsofxyz.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_se3_lotsofxyz.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_se3_offset.cpp
  type g2o (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_se3_offset.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_se3_pointxyz.cpp
  type g2o (line 42) | namespace g2o {
    function HyperGraphElementAction (line 150) | HyperGraphElementAction* EdgeSE3PointXYZDrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_se3_pointxyz.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_se3_pointxyz_depth.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_se3_pointxyz_depth.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_se3_pointxyz_disparity.cpp
  type g2o (line 36) | namespace g2o {
    function HyperGraphElementAction (line 171) | HyperGraphElementAction* EdgeProjectDisparityDrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_se3_pointxyz_disparity.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_se3_prior.cpp
  type g2o (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_se3_prior.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_se3_xyzprior.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_se3_xyzprior.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_xyz_prior.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/edge_xyz_prior.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/isometry3d_gradients.cpp
  type g2o (line 30) | namespace g2o {
    type internal (line 34) | namespace internal {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/isometry3d_gradients.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/isometry3d_mappings.cpp
  type g2o (line 31) | namespace g2o {
    type internal (line 32) | namespace internal {
      function Quaternion (line 34) | Quaternion normalized(const Quaternion& q) {
      function Quaternion (line 40) | Quaternion& normalize(Quaternion& q) {
      function Vector3 (line 49) | Vector3 toEuler(const Matrix3& R) {
      function Matrix3 (line 62) | Matrix3 fromEuler(const Vector3& v) {
      function Vector3 (line 80) | Vector3 toCompactQuaternion(const Matrix3& R) {
      function Matrix3 (line 87) | Matrix3 fromCompactQuaternion(const Vector3& v) {
      function Vector6 (line 97) | Vector6 toVectorMQT(const Isometry3& t) {
      function Vector6 (line 104) | Vector6 toVectorET(const Isometry3& t) {
      function Vector7 (line 111) | Vector7 toVectorQT(const Isometry3& t) {
      function Isometry3 (line 123) | Isometry3 fromVectorMQT(const Vector6& v) {
      function Isometry3 (line 130) | Isometry3 fromVectorET(const Vector6& v) {
      function Isometry3 (line 137) | Isometry3 fromVectorQT(const Vector7& v) {
      function SE3Quat (line 144) | SE3Quat toSE3Quat(const Isometry3& t) {
      function Isometry3 (line 149) | Isometry3 fromSE3Quat(const SE3Quat& t) {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/isometry3d_mappings.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/parameter_camera.cpp
  type g2o (line 39) | namespace g2o {
    function HyperGraphElementAction (line 121) | HyperGraphElementAction* CacheCameraDrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam3d/parameter_camera.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/parameter_se3_offset.cpp
  type g2o (line 37) | namespace g2o {
    function HyperGraphElementAction (line 97) | HyperGraphElementAction* CacheSE3OffsetDrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam3d/parameter_se3_offset.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/parameter_stereo_camera.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/parameter_stereo_camera.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/se3_ops.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/se3_ops.hpp
  function Matrix3 (line 27) | Matrix3 skew(const Vector3& v) {
  function Vector3 (line 39) | Vector3 deltaR(const Matrix3& R) {
  function Vector2 (line 47) | Vector2 project(const Vector3& v) {
  function Vector3 (line 54) | Vector3 project(const Vector4& v) {
  function Vector3 (line 62) | Vector3 unproject(const Vector2& v) {
  function Vector4 (line 70) | Vector4 unproject(const Vector3& v) {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/se3quat.h
  function class (line 39) | class G2O_TYPES_SLAM3D_API SE3Quat {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/types_slam3d.cpp
  type g2o (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/vertex_pointxyz.cpp
  type g2o (line 38) | namespace g2o {
    function HyperGraphElementAction (line 64) | HyperGraphElementAction* VertexPointXYZDrawAction::operator()(
    function HyperGraphElementAction (line 94) | HyperGraphElementAction* VertexPointXYZWriteGnuplotAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam3d/vertex_pointxyz.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d/vertex_se3.cpp
  type g2o (line 39) | namespace g2o {
    function HyperGraphElementAction (line 60) | HyperGraphElementAction* VertexSE3WriteGnuplotAction::operator()(
    function drawTriangle (line 78) | void drawTriangle(float xSize, float ySize) {
    function HyperGraphElementAction (line 116) | HyperGraphElementAction* VertexSE3DrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam3d/vertex_se3.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/edge_plane.cpp
  type g2o (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/edge_plane.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/edge_se3_calib.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/edge_se3_calib.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/edge_se3_euler.cpp
  type g2o (line 35) | namespace g2o {
    function jac_quat3_euler3 (line 38) | static void jac_quat3_euler3(Eigen::Matrix<double, 6, 6, Eigen::ColMaj...

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/edge_se3_euler.h
  function namespace (line 34) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/edge_se3_line.cpp
  type g2o (line 31) | namespace g2o {
    function HyperGraphElementAction (line 95) | HyperGraphElementAction* EdgeSE3Line3DDrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/edge_se3_line.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/edge_se3_plane_calib.cpp
  type g2o (line 33) | namespace g2o {
    function HyperGraphElementAction (line 78) | HyperGraphElementAction* EdgeSE3PlaneSensorCalibDrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/edge_se3_plane_calib.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/line3d.cpp
  type g2o (line 31) | namespace g2o {
    function Matrix3 (line 35) | static inline Matrix3 _skew(const Vector3& t) {
    function Vector6 (line 41) | Vector6 Line3D::toCartesian() const {
    function Line3D (line 51) | Line3D operator*(const Isometry3& t, const Line3D& line) {
    type internal (line 60) | namespace internal {
      function Vector6 (line 61) | Vector6 transformCartesianLine(const Isometry3& t, const Vector6& li...
      function Vector6 (line 68) | Vector6 normalizeCartesianLine(const Vector6& line) {

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/line3d.h
  function namespace (line 35) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/plane3d.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/types_slam3d_addons.cpp
  type g2o (line 35) | namespace g2o {
    function G2O_ATTRIBUTE_CONSTRUCTOR (line 57) | G2O_ATTRIBUTE_CONSTRUCTOR(init_slam3d_addons_types) {

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/vertex_line3d.cpp
  type g2o (line 32) | namespace g2o {
    function HyperGraphElementAction (line 70) | HyperGraphElementAction* VertexLine3DDrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/vertex_line3d.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/vertex_plane.cpp
  type g2o (line 31) | namespace g2o {
    function HyperGraphElementAction (line 71) | HyperGraphElementAction* VertexPlaneDrawAction::operator()(

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/vertex_plane.h
  function namespace (line 36) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/vertex_se3_euler.cpp
  type g2o (line 31) | namespace g2o {

FILE: Thirdparty/g2o_new/g2o/types/slam3d_addons/vertex_se3_euler.h
  function namespace (line 33) | namespace g2o {

FILE: Thirdparty/g2o_new/unit_test/data/data_queue_tests.cpp
  class MyTrivialRobotData (line 37) | class MyTrivialRobotData : public RobotData {
    method write (line 38) | virtual bool write(std::ostream&) const { return false; }
    method read (line 39) | virtual bool read(std::istream&) { return false; }
  function TEST (line 42) | TEST(Data, DataQueue) {

FILE: Thirdparty/g2o_new/unit_test/data/io_data.cpp
  function TEST (line 44) | TEST(Data, ReadWriteRobotLaser) {

FILE: Thirdparty/g2o_new/unit_test/general/allocate_optimizer.cpp
  type g2o (line 31) | namespace g2o {
    type internal (line 32) | namespace internal {

FILE: Thirdparty/g2o_new/unit_test/general/allocate_optimizer.h
  function namespace (line 30) | namespace g2o {

FILE: Thirdparty/g2o_new/unit_test/general/auto_diff.cpp
  class VertexFlatSE2 (line 35) | class VertexFlatSE2 : public g2o::BaseVertex<3, g2o::Vector3> {
    method setToOriginImpl (line 37) | virtual void setToOriginImpl() { _estimate.setZero(); }
    method oplusImpl (line 39) | virtual void oplusImpl(const double* update) {
    method read (line 44) | virtual bool read(std::istream&) { return false; }
    method write (line 45) | virtual bool write(std::ostream&) const { return false; }
  class Edge3ADTester (line 52) | class Edge3ADTester
    method project (line 61) | void project(const T* pose, const T* point, T* result) const {
    method G2O_MAKE_AUTO_AD_FUNCTIONS (line 82) | G2O_MAKE_AUTO_AD_FUNCTIONS
    method write (line 86) | bool write(std::ostream&) const override { return false; }
  class EdgeSE2AD (line 92) | class EdgeSE2AD : public g2o::EdgeSE2 {
    method pointerToIso (line 121) | static Iso2<T> pointerToIso(const T* p) {
    method isoToPointer (line 132) | static void isoToPointer(Iso2<T> iso, T* p) {
  class AutoDifferentiation (line 143) | class AutoDifferentiation : public ::testing::Test {
    method SetUp (line 145) | void SetUp() override {
  function TEST_F (line 165) | TEST_F(AutoDifferentiation, ComputesSomething) {
  function TEST_F (line 196) | TEST_F(AutoDifferentiation, ComputesNothingForFixed) {
  class AutoDifferentiationEdgeSE2 (line 214) | class AutoDifferentiationEdgeSE2 : public ::testing::Test {
    method SetUp (line 216) | void SetUp() override {
  function TEST_F (line 242) | TEST_F(AutoDifferentiationEdgeSE2, AdComputesSomething) {
  function TEST_F (line 266) | TEST_F(AutoDifferentiationEdgeSE2, AdComputesCorrect) {

FILE: Thirdparty/g2o_new/unit_test/general/base_fixed_sized_edge.cpp
  class Edge3Constant (line 37) | class Edge3Constant
    method Edge3Constant (line 42) | Edge3Constant()
    method computeError (line 45) | void computeError() {
    method read (line 52) | virtual bool read(std::istream&) { return false; }
    method write (line 53) | virtual bool write(std::ostream&) const { return false; }
  class Edge3Dynamic (line 56) | class Edge3Dynamic : public g2o::BaseVariableSizedEdge<2, g2o::Vector2> {
    method Edge3Dynamic (line 59) | Edge3Dynamic() : g2o::BaseVariableSizedEdge<2, g2o::Vector2>() { resiz...
    method computeError (line 60) | void computeError() {
    method read (line 67) | virtual bool read(std::istream&) { return false; }
    method write (line 68) | virtual bool write(std::ostream&) const { return false; }
  class VertexNotDefaultCtor (line 71) | class VertexNotDefaultCtor : public g2o::BaseVertex<2, g2o::Vector2> {
    method VertexNotDefaultCtor (line 73) | VertexNotDefaultCtor(int x, int y) { _estimate = g2o::Vector2(x, y); }
    method oplusImpl (line 75) | virtual void oplusImpl(const double* update) {
    method setToOriginImpl (line 80) | virtual void setToOriginImpl() { _estimate.setZero(); }
    method read (line 81) | virtual bool read(std::istream& /*is*/) { return false; }
    method write (line 82) | virtual bool write(std::ostream& /*os*/) const { return false; }
  class EdgeUnaryCreateVertexTester (line 85) | class EdgeUnaryCreateVertexTester
    method EdgeUnaryCreateVertexTester (line 88) | EdgeUnaryCreateVertexTester() = default;
    method computeError (line 90) | void computeError() {
    method read (line 95) | virtual bool read(std::istream& /*is*/) { return false; }
    method write (line 96) | virtual bool write(std::ostream& /*os*/) const { return false; }
    method setMeasurement (line 98) | virtual void setMeasurement(const g2o::Vector2& m) { _measurement = m; }
    method measurementDimension (line 100) | virtual int measurementDimension() const { return 2; }
  function TEST (line 103) | TEST(General, IndexToPairToIndex) {
  function TEST (line 132) | TEST(General, ConstantEdgeConstructor) {
  function TEST (line 148) | TEST(General, FixedEdgeCreateVertex) {
  function TEST (line 165) | TEST(General, FixedEdgeCreateVertexNonDefaultCtor) {
  class EdgeTester (line 176) | class EdgeTester {
    method EdgeTester (line 178) | EdgeTester() {
  function TEST (line 225) | TEST(ConstantEdgeTest, ConstantEdge_allVerticesFixed) {
  function TEST (line 240) | TEST(ConstantEdgeTest, ConstantEdge_computeError) {
  function TEST (line 248) | TEST(ConstantEdgeTest, ConstantEdge_linearizeOplus) {
  function TEST (line 275) | TEST(ConstantEdgeTest, ConstantEdge_constructQuadraticForm) {
  function TEST (line 294) | TEST(ConstantEdgeTest, ConstantEdge_constructQuadraticForm_robust) {
  function TEST (line 328) | TEST(ConstantEdgeTest, ConstantEdge_constructQuadraticForm_rowMajor) {
  function TEST (line 380) | TEST(ConstantEdgeTest, NotCopyAssignable) {

FILE: Thirdparty/g2o_new/unit_test/general/batch_statistics.cpp
  function extractValue (line 34) | std::string extractValue(const std::string& input, const std::string& fi...
  function TEST (line 47) | TEST(General, BatchStatisticsOutput) {

FILE: Thirdparty/g2o_new/unit_test/general/clear_and_redo.cpp
  function TEST (line 33) | TEST(General, ClearAndRedo) {

FILE: Thirdparty/g2o_new/unit_test/general/graph_operations.cpp
  class JacobianWorkspaceTestAdapter (line 50) | class JacobianWorkspaceTestAdapter : public g2o::JacobianWorkspace {
    method WorkspaceVector (line 52) | [[nodiscard]] WorkspaceVector& workspace() { return _workspace; }
    method maxNumVertices (line 53) | [[nodiscard]] int maxNumVertices() const { return _maxNumVertices; }
    method maxDimension (line 54) | [[nodiscard]] int maxDimension() const { return _maxDimension; }
  function TEST (line 58) | TEST(General, BinaryEdgeConstructor) {
  function TEST (line 64) | TEST(General, GraphAddVertex) {
  function TEST (line 94) | TEST(General, GraphAddEdge) {
  function TEST (line 139) | TEST(General, GraphChangeId) {
  class GeneralGraphOperations (line 165) | class GeneralGraphOperations : public ::testing::Test {
    method SetUp (line 167) | void SetUp() override {
    method parseVertexIds (line 193) | static std::vector<int> parseVertexIds(std::istream& is) {
    method parseFixedIds (line 209) | static std::vector<int> parseFixedIds(std::istream& is) {
    method parseEdgeIds (line 225) | static std::vector<std::pair<int, int>> parseEdgeIds(std::istream& is) {
    method resetStream (line 241) | static void resetStream(std::istream& is) {
    method expectedIds (line 247) | std::vector<int> expectedIds() const {
    method expectedEdgeIds (line 254) | std::vector<std::pair<int, int>> expectedEdgeIds() const {
    method vertexEstimates (line 261) | std::map<int, g2o::Vector3> vertexEstimates() const {
    method fixedIds (line 271) | std::vector<int> fixedIds() const {
  function TEST_F (line 285) | TEST_F(GeneralGraphOperations, SavingGraph) {
  type internal (line 302) | namespace internal {
    function KeyIntVector (line 304) | static KeyIntVector VectorIntToKeys(const std::vector<int>& keys) {
  function TEST_F (line 311) | TEST_F(GeneralGraphOperations, LoadingGraph) {
  function TEST_F (line 348) | TEST_F(GeneralGraphOperations, SaveSubsetVertices) {
  function TEST_F (line 363) | TEST_F(GeneralGraphOperations, SaveSubsetEdges) {
  function TEST_F (line 385) | TEST_F(GeneralGraphOperations, PushPopActiveVertices) {
  function TEST_F (line 409) | TEST_F(GeneralGraphOperations, PushDiscardActiveVertices) {
  function TEST_F (line 434) | TEST_F(GeneralGraphOperations, PushPopOptimizableGraph) {
  function TEST_F (line 457) | TEST_F(GeneralGraphOperations, PushDiscardOptimizableGraph) {
  function TEST_F (line 482) | TEST_F(GeneralGraphOperations, PushPopDiscardSubset) {
  function TEST_F (line 515) | TEST_F(GeneralGraphOperations, FixSubset) {
  function TEST_F (line 529) | TEST_F(GeneralGraphOperations, TrivialInit) {
  function TEST_F (line 553) | TEST_F(GeneralGraphOperations, EdgeInit) {
  function TEST_F (line 570) | TEST_F(GeneralGraphOperations, Gauge) {
  function TEST_F (line 581) | TEST_F(GeneralGraphOperations, Dimensions) {
  function TEST_F (line 595) | TEST_F(GeneralGraphOperations, VerifyInformationMatrices) {
  function TEST_F (line 620) | TEST_F(GeneralGraphOperations, SolverSuitable) {
  function TEST_F (line 655) | TEST_F(GeneralGraphOperations, JacWorkspace) {
  class TreeVisitor (line 697) | class TreeVisitor : public g2o::HyperDijkstra::TreeAction {
    method perform (line 699) | double perform(g2o::HyperGraph::Vertex* v,
  function range_helper (line 712) | std::vector<int> range_helper(int range) {
  function TEST_F (line 719) | TEST_F(GeneralGraphOperations, HyperDijkstraVisitor) {

FILE: Thirdparty/g2o_new/unit_test/general/robust_kernel_tests.cpp
  function TEST (line 35) | TEST(General, RobustKernelFactory) {
  class RobustKernelTests (line 73) | class RobustKernelTests : public Test {
    method RobustKernelTests (line 77) | RobustKernelTests() : Test() {
    method eval (line 91) | double eval(double val) const {
    method estimateDerivative (line 100) | double estimateDerivative(double x) {
    method estimate2ndDerivative (line 107) | double estimate2ndDerivative(double x) {
  function TYPED_TEST_P (line 122) | TYPED_TEST_P(RobustKernelTests, Values) {
  function TYPED_TEST_P (line 130) | TYPED_TEST_P(RobustKernelTests, Derivative) {
  function TYPED_TEST_P (line 139) | TYPED_TEST_P(RobustKernelTests, SecondDerivative) {

FILE: Thirdparty/g2o_new/unit_test/general/sparse_block_matrix.cpp
  function TEST (line 47) | TEST(General, SparseBlockMatrix) {

FILE: Thirdparty/g2o_new/unit_test/sba/io_sba.cpp
  type RandomSBACam (line 37) | struct RandomSBACam {
    method SBACam (line 38) | static SBACam create() { return SBACam(); }
    method isApprox (line 39) | static bool isApprox(const SBACam& a, const SBACam& b) {
  function TEST (line 48) | TEST(IoSba, ReadWriteVertexIntrinsics) {
  function TEST (line 52) | TEST(IoSba, ReadWriteVertexCam) {
  function TEST (line 59) | TEST(IoSba, ReadWriteEdgeProjectP2MC) {
  function TEST (line 63) | TEST(IoSba, ReadWriteEdgeProjectP2SC) {
  function TEST (line 67) | TEST(IoSba, ReadWriteEdgeSBACam) {
  function TEST (line 71) | TEST(IoSba, ReadWriteEdgeSBAScale) {

FILE: Thirdparty/g2o_new/unit_test/sba/io_six_dof_expmap.cpp
  function TEST (line 40) | TEST(IoSixDofExpmap, ReadWriteVertexSE3Expmap) {
  function TEST (line 47) | TEST(IoSixDofExpmap, ReadWriteEdgeSE3Expmap) {
  function TEST (line 51) | TEST(IoSixDofExpmap, ReadWriteEdgeSE3ProjectXYZ) {
  function TEST (line 55) | TEST(IoSixDofExpmap, ReadWriteEdgeStereoSE3ProjectXYZ) {
  function TEST (line 59) | TEST(IoSixDofExpmap, ReadWriteEdgeSE3ProjectXYZOnlyPose) {
  function TEST (line 63) | TEST(IoSixDofExpmap, ReadWriteEdgeStereoSE3ProjectXYZOnlyPose) {
  class IoSixDofExpmapParam (line 70) | class IoSixDofExpmapParam : public ::testing::Test {
    method SetUp (line 72) | void SetUp() override {
    method prepareEdge (line 88) | void prepareEdge(OptimizableGraph::Edge* e) {
  function TEST_F (line 100) | TEST_F(IoSixDofExpmapParam, ReadWriteEdgeProjectXYZ2UV) {
  function TEST_F (line 106) | TEST_F(IoSixDofExpmapParam, ReadWriteEdgeProjectPSI2UV) {
  function TEST_F (line 116) | TEST_F(IoSixDofExpmapParam, ReadWriteEdgeProjectXYZ2UVU) {

FILE: Thirdparty/g2o_new/unit_test/sclam2d/io_sclam2d.cpp
  type RandomSE2 (line 39) | struct RandomSE2 {
    method SE2 (line 40) | static SE2 create() {
    method isApprox (line 46) | static bool isApprox(const SE2& a, const SE2& b) {
  type RandomVelocityMeasurement (line 51) | struct RandomVelocityMeasurement {
    method VelocityMeasurement (line 52) | static VelocityMeasurement create() {
    method isApprox (line 57) | static bool isApprox(const VelocityMeasurement& a,
  function TEST (line 65) | TEST(IoSclam2d, ReadWriteVertexOdomDifferentialParams) {
  function TEST (line 69) | TEST(IoSclam2d, ReadWriteEdgeSE2SensorCalib) {
  function TEST (line 73) | TEST(IoSclam2d, ReadWriteEdgeSE2OdomDifferentialCalib) {

FILE: Thirdparty/g2o_new/unit_test/sclam2d/odom_convert_sclam2d.cpp
  function TEST (line 34) | TEST(Sclam2D, MotionMeasurementCtor) {
  function TEST (line 47) | TEST(Sclam2D, VelocityMeasurementCtor) {
  function TEST (line 54) | TEST(Sclam2D, OdomConvertStraightLine) {
  function TEST (line 69) | TEST(Sclam2D, OdomConvert) {

FILE: Thirdparty/g2o_new/unit_test/sim3/allocate_sim3.cpp
  function TEST (line 30) | TEST(Sim3, VertexSE3ExpmapCtor) {

FILE: Thirdparty/g2o_new/unit_test/sim3/io_sim3.cpp
  type RandomSim3 (line 36) | struct RandomSim3 {
    method Sim3 (line 37) | static Sim3 create() {
    method isApprox (line 42) | static bool isApprox(const Sim3& a, const Sim3& b) {
  function TEST (line 49) | TEST(IoSim3, ReadWriteVertexSim3Expmap) {
  function TEST (line 53) | TEST(IoSim3, ReadWriteEdgeSim3) {
  function TEST (line 57) | TEST(IoSim3, ReadWriteEdgeSim3ProjectXYZ) {
  function TEST (line 61) | TEST(IoSim3, ReadWriteEdgeInverseSim3ProjectXYZ) {

FILE: Thirdparty/g2o_new/unit_test/sim3/jacobians_sim3.cpp
  function Sim3 (line 39) | static Sim3 randomSim3() {
  function TEST (line 47) | TEST(Sim3, EdgeSim3Jacobian) {

FILE: Thirdparty/g2o_new/unit_test/slam2d/io_slam2d.cpp
  type RandomSE2 (line 42) | struct RandomSE2 {
    method SE2 (line 43) | static SE2 create() {
    method isApprox (line 49) | static bool isApprox(const SE2& a, const SE2& b) {
  function TEST (line 54) | TEST(IoSlam2d, ReadWriteVertexSE2) {
  function TEST (line 58) | TEST(IoSlam2d, ReadWriteVertexPointXY) {
  function TEST (line 62) | TEST(IoSlam2d, ReadWriteParameterSE2Offset) {
  function TEST (line 71) | TEST(IoSlam2d, ReadWriteEdgeSE2) {
  function TEST (line 75) | TEST(IoSlam2d, ReadWriteEdgeSE2Prior) {
  function TEST (line 79) | TEST(IoSlam2d, ReadWriteEdgeSE2PointXY) {
  function TEST (line 83) | TEST(IoSlam2d, ReadWriteEdgeXYPrior) {

FILE: Thirdparty/g2o_new/unit_test/slam2d/jacobians_slam2d.cpp
  function SE2 (line 40) | static SE2 randomSE2() { return SE2(Vector3d::Random()); }
  function TEST (line 42) | TEST(Slam2D, EdgeSE2Jacobian) {
  function TEST (line 68) | TEST(Slam2D, EdgeSE2PriorJacobian) {
  function TEST (line 89) | TEST(Slam2D, EdgePointXYJacobian) {
  function TEST (line 115) | TEST(Slam2D, EdgeSE2PointXYJacobian) {
  function TEST (line 141) | TEST(Slam2D, EdgeSE2PointXYBearingJacobian) {

FILE: Thirdparty/g2o_new/unit_test/slam2d/mappings_se2.cpp
  function TEST (line 33) | TEST(MappingsSlam2D, SE2) {

FILE: Thirdparty/g2o_new/unit_test/slam2d_addons/io_slam2d_addons.cpp
  type RandomLine2D (line 41) | struct RandomLine2D {
    method Line2D (line 42) | static Line2D create() { return Line2D(g2o::Vector2::Random()); }
    method isApprox (line 43) | static bool isApprox(const Line2D& a, const Line2D& b) {
  function TEST (line 48) | TEST(IoSlam2dAddOns, ReadWriteVertexSegment2D) {
  function TEST (line 52) | TEST(IoSlam2dAddOns, ReadWriteEdgeLine2D) {
  function TEST (line 56) | TEST(IoSlam2dAddOns, ReadWriteEdgeSE2Line2D) {
  function TEST (line 60) | TEST(IoSlam2dAddOns, ReadWriteEdgeSE2Segment2D) {
  function TEST (line 64) | TEST(IoSlam2dAddOns, ReadWriteEdgeSE2Segment2DLine) {
  function TEST (line 68) | TEST(IoSlam2dAddOns, ReadWriteEdgeSE2Segment2DPointLine) {

FILE: Thirdparty/g2o_new/unit_test/slam3d/io_slam3d.cpp
  class IoSlam3dParam (line 48) | class IoSlam3dParam : public ::testing::Test {
    method SetUp (line 50) | void SetUp() override {
    method preparePosePoseEdge (line 74) | bool preparePosePoseEdge(OptimizableGraph::Edge* e) {
    method preparePosePointEdge (line 81) | bool preparePosePointEdge(OptimizableGraph::Edge* e) {
    method prepareCamPointEdge (line 88) | bool prepareCamPointEdge(OptimizableGraph::Edge* e) {
  function TEST (line 107) | TEST(IoSlam3d, ReadWriteVertexSE3) {
  function TEST (line 111) | TEST(IoSlam3d, ReadWriteVertexPointXYZ) {
  function TEST (line 118) | TEST(IoSlam3d, ReadWriteEdgeSE3) {
  function TEST (line 122) | TEST(IoSlam3d, ReadWriteEdgePointXYZ) {
  function TEST (line 126) | TEST(IoSlam3d, ReadWriteEdgeXYZPrior) {
  function TEST_F (line 130) | TEST_F(IoSlam3dParam, ReadWriteEdgeSE3Offset) {
  function TEST_F (line 146) | TEST_F(IoSlam3dParam, ReadWriteEdgeSE3PointXYZ) {
  function TEST_F (line 152) | TEST_F(IoSlam3dParam, ReadWriteEdgeSE3Prior) {
  function TEST_F (line 158) | TEST_F(IoSlam3dParam, ReadWriteEdgeSE3PointXYZDepth) {
  function TEST_F (line 164) | TEST_F(IoSlam3dParam, ReadWriteEdgeSE3PointXYZDisparity) {
  function TEST_F (line 170) | TEST_F(IoSlam3dParam, ReadWriteEdgeSE3XYZPrior) {
  function TEST (line 177) | TEST(IoSlam3d, ReadWriteParameterCamera) {
  function TEST (line 188) | TEST(IoSlam3d, ReadWriteParameterStereoCamera) {
  function TEST (line 201) | TEST(IoSlam3d, ReadWriteParameterSE3Offset) {

FILE: Thirdparty/g2o_new/unit_test/slam3d/jacobians_slam3d.cpp
  function TEST (line 43) | TEST(Slam3D, EdgeSE3Jacobian) {
  function TEST (line 69) | TEST(Slam3D, EdgeSE3XYZPriorJacobian) {
  function TEST (line 96) | TEST(Slam3D, EdgeSE3PointXYZJacobian) {
  function TEST (line 133) | TEST(Slam3D, EdgePointXYZJacobian) {
  type RotationMatrix2QuaternionManifold (line 162) | struct RotationMatrix2QuaternionManifold {
  function TEST (line 201) | TEST(Slam3D, dqDRJacobian) {

FILE: Thirdparty/g2o_new/unit_test/slam3d/mappings_slam3d.cpp
  function TEST (line 33) | TEST(MappingsSlam3D, EulerConversion) {
  function TEST (line 41) | TEST(MappingsSlam3D, QuaternionConversion) {
  function TEST (line 50) | TEST(MappingsSlam3D, ET) {
  function TEST (line 67) | TEST(MappingsSlam3D, MQT) {
  function TEST (line 83) | TEST(MappingsSlam3D, QT) {

FILE: Thirdparty/g2o_new/unit_test/slam3d/optimization_slam3d.cpp
  class Slam3DOptimization (line 43) | class Slam3DOptimization : public testing::Test {
    method Slam3DOptimization (line 47) | Slam3DOptimization() {
  function TYPED_TEST_P (line 62) | TYPED_TEST_P(Slam3DOptimization, Translation) {
  function TYPED_TEST_P (line 101) | TYPED_TEST_P(Slam3DOptimization, Rotation) {

FILE: Thirdparty/g2o_new/unit_test/slam3d/orthogonal_matrix.cpp
  function TEST (line 32) | TEST(Slam3D, OrthogonalMatrix) {

FILE: Thirdparty/g2o_new/unit_test/slam3d_addons/io_slam3d_addons.cpp
  type RandomPlane3D (line 43) | struct RandomPlane3D {
    method Plane3D (line 44) | static Plane3D create() { return Plane3D(Vector4::Random()); }
    method isApprox (line 45) | static bool isApprox(const Plane3D& a, const Plane3D& b) {
  type RandomLine3D (line 50) | struct RandomLine3D {
    method Line3D (line 51) | static Line3D create() { return Line3D(Vector6::Random()); }
    method isApprox (line 52) | static bool isApprox(const Line3D& a, const Line3D& b) {
  class IoSlam3dAddonsParam (line 57) | class IoSlam3dAddonsParam : public ::testing::Test {
    method SetUp (line 59) | void SetUp() override {
  function TEST (line 83) | TEST(IoSlam3dAddOns, ReadWriteVertexSE3Euler) {
  function TEST (line 87) | TEST(IoSlam3dAddOns, ReadWriteVertexPlane) {
  function TEST (line 95) | TEST(IoSlam3dAddOns, ReadWriteVertexLine3D) {
  function TEST (line 99) | TEST(IoSlam3dAddOns, ReadWriteEdgeSE3Calib) {
  function TEST_F (line 103) | TEST_F(IoSlam3dAddonsParam, ReadWriteEdgeSE3Line3D) {
  function TEST (line 114) | TEST(IoSlam3dAddOns, ReadWriteEdgeSE3PlaneSensorCalib) {

FILE: Thirdparty/g2o_new/unit_test/solver/allocate_algorithm_test.cpp
  function TEST (line 48) | TEST(AlgorithmFactory, ContainsBasicSolvers) {
  function TEST (line 63) | TEST(AlgorithmFactory, AllocatingSolver) {
  function TEST (line 77) | TEST(AlgorithmFactory, AllocatingInvalidReturnsNull) {
  function TEST (line 88) | TEST(AlgorithmFactory, PrintSolverProperties) {
  function TEST (line 104) | TEST(AlgorithmFactory, ListsAllSolvers) {

FILE: Thirdparty/g2o_new/unit_test/solver/linear_solver_test.cpp
  type BlockOrdering (line 43) | struct BlockOrdering {
    method setOrdering (line 45) | void setOrdering(T& solver) {
  type NoBlockOrdering (line 50) | struct NoBlockOrdering {
    method setOrdering (line 52) | void setOrdering(T& solver) {
  type NoooOrdering (line 57) | struct NoooOrdering {
    method setOrdering (line 59) | void setOrdering(T& solver) {
  class LS (line 70) | class LS : public testing::Test {
    method LS (line 75) | LS() : linearsolver(std::make_unique<LinearSolverType>()) {
  function TYPED_TEST_P (line 89) | TYPED_TEST_P(LS, Solve) {
  function TYPED_TEST_P (line 103) | TYPED_TEST_P(LS, SolvePattern) {
  function TYPED_TEST_P (line 137) | TYPED_TEST_P(LS, SolveBlocks) {

FILE: Thirdparty/g2o_new/unit_test/solver/sparse_system_helper.cpp
  type g2o (line 34) | namespace g2o {
    type internal (line 35) | namespace internal {
      function readIndices (line 37) | static std::vector<int> readIndices(const std::string& indices) {
      function sparseMatrixString (line 52) | std::string sparseMatrixString() {
      function denseInverseMatrixString (line 151) | std::string denseInverseMatrixString() {
      function fillTestMatrix (line 196) | void fillTestMatrix(g2o::SparseBlockMatrixX& A) {
      function createTestMatrixInverse (line 234) | g2o::MatrixX createTestMatrixInverse() {
      function createTestVectorB (line 255) | g2o::VectorX createTestVectorB() {
      function createTestVectorX (line 298) | g2o::VectorX createTestVectorX() {

FILE: Thirdparty/g2o_new/unit_test/solver/sparse_system_helper.h
  function namespace (line 29) | namespace g2o {

FILE: Thirdparty/g2o_new/unit_test/stuff/command_args_tests.cpp
  class CommandArgsTest (line 33) | class CommandArgsTest : public ::testing::Test {
    method SetUp (line 35) | void SetUp() override {
    method call (line 49) | void call(const std::vector<std::string>& arguments) {
  function TEST_F (line 85) | TEST_F(CommandArgsTest, DefaultValues) {
  function TEST_F (line 101) | TEST_F(CommandArgsTest, ParseValues) {
  class CommandArgsTestAdapter (line 129) | class CommandArgsTestAdapter : public g2o::CommandArgs {
  class CommandArgsTypeToStr (line 135) | class CommandArgsTypeToStr : public testing::TestWithParam<int> {
  function TEST_P (line 140) | TEST_P(CommandArgsTypeToStr, type2str) {

FILE: Thirdparty/g2o_new/unit_test/stuff/filesys_tools_tests.cpp
  function TEST (line 34) | TEST(Stuff, GetFileExtension) {
  function TEST (line 41) | TEST(Stuff, GetPureFilename) {
  function TEST (line 48) | TEST(Stuff, ChangeFileExtension) {
  function TEST (line 55) | TEST(Stuff, GetBasename) {
  function TEST (line 66) | TEST(Stuff, GetDirname) {
  function TEST (line 77) | TEST(Stuff, FileExists) {
  function TEST (line 91) | TEST(Stuff, GetFilesByPattern) {

FILE: Thirdparty/g2o_new/unit_test/stuff/misc_tests.cpp
  function simple_normalize_theta (line 33) | double simple_normalize_theta(double th) {
  function TEST (line 40) | TEST(Stuff, NormalizeTheta) {
  function TEST (line 67) | TEST(Stuff, NormalizeThetaCmpBruteForce) {
  function TEST (line 74) | TEST(Stuff, Deg2Rad) {
  function TEST (line 88) | TEST(Stuff, Rad2Deg) {
  function TEST (line 102) | TEST(Stuff, ArrayHasNaN) {

FILE: Thirdparty/g2o_new/unit_test/stuff/property_tests.cpp
  class PropertyTest (line 30) | class PropertyTest : public ::testing::Test {
    method SetUp (line 32) | void SetUp() override {
  function TEST_F (line 41) | TEST_F(PropertyTest, Erase) {
  function TEST_F (line 50) | TEST_F(PropertyTest, Add) {
  function TEST_F (line 58) | TEST_F(PropertyTest, UpdatePropertyFromString) {
  function TEST_F (line 67) | TEST_F(PropertyTest, UpdateMapFromString) {
  function TEST_F (line 76) | TEST_F(PropertyTest, WriteCSV) {

FILE: Thirdparty/g2o_new/unit_test/stuff/string_tools_tests.cpp
  function TEST (line 35) | TEST(Stuff, Trim) {
  function TEST (line 53) | TEST(Stuff, StrToLower) {
  function TEST (line 61) | TEST(Stuff, StrToUpper) {
  function TEST (line 69) | TEST(Stuff, StrSplit) {
  function TEST (line 82) | TEST(Stuff, StrJoin) {
  function TEST (line 90) | TEST(Stuff, StrStartsWith) {
  function TEST (line 97) | TEST(Stuff, StrEndsWith) {
  function TEST (line 104) | TEST(Stuff, ReadLine) {
  function TEST (line 131) | TEST(Stuff, StrExpand) {

FILE: Thirdparty/g2o_new/unit_test/stuff/tuple_tools_tests.cpp
  function TEST (line 30) | TEST(Stuff, Tuple_apply) {

FILE: Thirdparty/g2o_new/unit_test/stuff/unscented_tests.cpp
  function TEST (line 38) | TEST(Unscented, SampleUnscented) {
  function testMarginals (line 64) | void testMarginals(SparseOptimizer& optimizer) {

FILE: Thirdparty/g2o_new/unit_test/test_helper/eigen_matcher.h
  function PrintTo (line 53) | void PrintTo(const EigenPrintWrap& m, ::std::ostream* o) { *o << "\n" <<...

FILE: Thirdparty/g2o_new/unit_test/test_helper/evaluate_jacobian.h
  function namespace (line 37) | namespace g2o {

FILE: Thirdparty/g2o_new/unit_test/test_helper/io.h
  function namespace (line 35) | namespace g2o {
  function own (line 57) | ptr(new T), own(true) {}
  function typename (line 65) | static typename T::EstimateType create() { return T::EstimateType::Rando...
  function isApprox (line 66) | static bool isApprox(const typename T::EstimateType& a,
  function typename (line 74) | static typename T::Measurement create() { return T::Measurement::Random(...
  function isApprox (line 75) | static bool isApprox(const typename T::Measurement& a,

FILE: Thirdparty/g2o_new/unit_test/test_helper/random_state.h
  function namespace (line 31) | namespace g2o {
  function isApprox (line 60) | struct RandomDouble {

FILE: Thirdparty/g2o_new/unit_test/test_helper/test_main.cpp
  function main (line 4) | int main(int argc, char** argv) {

FILE: include/Converter.h
  function namespace (line 34) | namespace Jetson_SLAM

FILE: include/Frame.h
  function namespace (line 44) | namespace Jetson_SLAM

FILE: include/FrameDrawer.h
  function namespace (line 38) | namespace Jetson_SLAM

FILE: include/Initializer.h
  function namespace (line 32) | namespace Jetson_SLAM

FILE: include/KeyFrame.h
  function namespace (line 39) | namespace Jetson_SLAM

FILE: include/KeyFrameDatabase.h
  function namespace (line 39) | namespace Jetson_SLAM

FILE: include/LocalMapping.h
  function namespace (line 37) | namespace Jetson_SLAM

FILE: include/LoopClosing.h
  function namespace (line 40) | namespace Jetson_SLAM

FILE: include/Map.h
  function namespace (line 36) | namespace Jetson_SLAM

FILE: include/MapDrawer.h
  function namespace (line 35) | namespace Jetson_SLAM

FILE: include/MapPoint.h
  function namespace (line 35) | namespace Jetson_SLAM

FILE: include/ORBVocabulary.h
  function namespace (line 28) | namespace Jetson_SLAM

FILE: include/ORBextractor.h
  function namespace (line 18) | namespace Jetson_SLAM

FILE: include/ORBmatcher.h
  function namespace (line 38) | namespace Jetson_SLAM

FILE: include/Optimizer.h
  function namespace (line 36) | namespace Jetson_SLAM

FILE: include/PnPsolver.h
  function namespace (line 64) | namespace Jetson_SLAM

FILE: include/Sim3Solver.h
  function namespace (line 32) | namespace Jetson_SLAM

FILE: include/System.h
  function namespace (line 39) | namespace Jetson_SLAM

FILE: include/Tracking.h
  function namespace (line 43) | namespace Jetson_SLAM

FILE: include/Viewer.h
  function namespace (line 32) | namespace Jetson_SLAM

FILE: include/cuda/orb_gpu.hpp
  type orb_cuda (line 14) | namespace orb_cuda
    class ORB_GPU (line 22) | class ORB_GPU

FILE: include/cuda/orb_matcher.hpp
  type orb_cuda (line 7) | namespace orb_cuda{

FILE: include/cuda/synced_mem_holder.hpp
  type orb_cuda (line 8) | namespace orb_cuda {
    class SyncedMem (line 11) | class SyncedMem {

FILE: include/cuda/tracking_gpu.hpp
  type tracking_cuda (line 7) | namespace tracking_cuda{

FILE: include/tictoc.hpp
  class tictoc (line 7) | class tictoc
    method tic (line 10) | void tic(void)
    method toc (line 15) | float toc(void)
    method toc_print (line 22) | void toc_print(void)
    method print (line 29) | void print(void)
    method time (line 34) | float time(void)

FILE: include/tictoc_cuda.hpp
  class tictoc (line 10) | class tictoc
    method tictoc (line 14) | tictoc()
    method tic (line 29) | void tic(void)
    method toc (line 34) | float toc(void)
    method toc_print (line 42) | void toc_print(void)
    method print (line 50) | void print(void)
    method time (line 55) | float time(void)

FILE: src/Converter.cpp
  type Jetson_SLAM (line 28) | namespace Jetson_SLAM

FILE: src/Frame.cpp
  type Jetson_SLAM (line 34) | namespace Jetson_SLAM

FILE: src/FrameDrawer.cpp
  type Jetson_SLAM (line 34) | namespace Jetson_SLAM

FILE: src/Initializer.cpp
  type Jetson_SLAM (line 34) | namespace Jetson_SLAM

FILE: src/KeyFrame.cpp
  type Jetson_SLAM (line 30) | namespace Jetson_SLAM
    function MapPoint (line 287) | MapPoint* KeyFrame::GetMapPoint(const size_t &idx)
    function KeyFrame (line 410) | KeyFrame* KeyFrame::GetParent()

FILE: src/KeyFrameDatabase.cpp
  type Jetson_SLAM (line 34) | namespace Jetson_SLAM

FILE: src/LocalMapping.cpp
  type Jetson_SLAM (line 34) | namespace Jetson_SLAM

FILE: src/LoopClosing.cpp
  type Jetson_SLAM (line 40) | namespace Jetson_SLAM

FILE: src/Map.cpp
  type Jetson_SLAM (line 29) | namespace Jetson_SLAM

FILE: src/MapDrawer.cpp
  type Jetson_SLAM (line 33) | namespace Jetson_SLAM

FILE: src/MapPoint.cpp
  type Jetson_SLAM (line 31) | namespace Jetson_SLAM
    function KeyFrame (line 123) | KeyFrame* MapPoint::GetReferenceKeyFrame()
    function MapPoint (line 201) | MapPoint* MapPoint::GetReplaced()

FILE: src/ORBextractor.cpp
  type Jetson_SLAM (line 23) | namespace Jetson_SLAM

FILE: src/ORBmatcher.cpp
  type Jetson_SLAM (line 21) | namespace Jetson_SLAM

FILE: src/Optimizer.cpp
  type Jetson_SLAM (line 42) | namespace Jetson_SLAM

FILE: src/PnPsolver.cpp
  type Jetson_SLAM (line 70) | namespace Jetson_SLAM

FILE: src/Sim3Solver.cpp
  type Jetson_SLAM (line 39) | namespace Jetson_SLAM

FILE: src/System.cpp
  type Jetson_SLAM (line 36) | namespace Jetson_SLAM

FILE: src/Tracking.cpp
  type Jetson_SLAM (line 56) | namespace Jetson_SLAM

FILE: src/Viewer.cpp
  type Jetson_SLAM (line 32) | namespace Jetson_SLAM

FILE: src/cuda/orb_FAST_apply_NMS_MS.cpp
  type orb_cuda (line 8) | namespace orb_cuda {

FILE: src/cuda/orb_FAST_obtain_keypoints.cpp
  type orb_cuda (line 8) | namespace orb_cuda {

FILE: src/cuda/orb_bitpattern.cpp
  type orb_cuda (line 4) | namespace orb_cuda {

FILE: src/cuda/orb_gpu.cpp
  type orb_cuda (line 19) | namespace orb_cuda {
    class tictoc (line 456) | class tictoc
      method tic (line 459) | void tic(void)
      method toc (line 464) | float toc(void)
      method toc_print (line 471) | void toc_print(void)

FILE: src/cuda/synced_mem_holder.cpp
  type orb_cuda (line 6) | namespace orb_cuda {
    function Dtype (line 76) | Dtype* SyncedMem<Dtype>::cpu_data()
    function Dtype (line 82) | Dtype* SyncedMem<Dtype>::gpu_data()
    class SyncedMem<unsigned char> (line 192) | class SyncedMem<unsigned char>
    class SyncedMem<signed char> (line 193) | class SyncedMem<signed char>
    class SyncedMem<unsigned short> (line 194) | class SyncedMem<unsigned short>
    class SyncedMem<short> (line 195) | class SyncedMem<short>
    class SyncedMem<unsigned int> (line 196) | class SyncedMem<unsigned int>
    class SyncedMem<int> (line 197) | class SyncedMem<int>
    class SyncedMem<float> (line 198) | class SyncedMem<float>

[
  {
    "path": ".gitignore",
    "chars": 11,
    "preview": "build\n*.*~\n"
  },
  {
    "path": "CMakeLists.txt",
    "chars": 4264,
    "preview": "cmake_minimum_required(VERSION 2.8)\nproject(Jetson-SLAM)\n\n\n\nIF(NOT CMAKE_BUILD_TYPE)\n  SET(CMAKE_BUILD_TYPE Release)\nEND"
  },
  {
    "path": "Examples/Monocular/EuRoC.yaml",
    "chars": 1855,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# Camera Parame"
  },
  {
    "path": "Examples/Monocular/EuRoC_TimeStamps/MH01.txt",
    "chars": 73640,
    "preview": "1403636579763555584\n1403636579813555456\n1403636579863555584\n1403636579913555456\n1403636579963555584\n1403636580013555456\n"
  },
  {
    "path": "Examples/Monocular/EuRoC_TimeStamps/MH02.txt",
    "chars": 60800,
    "preview": "1403636858651666432\n1403636858701666560\n1403636858751666432\n1403636858801666560\n1403636858851666432\n1403636858901666560\n"
  },
  {
    "path": "Examples/Monocular/EuRoC_TimeStamps/MH03.txt",
    "chars": 54000,
    "preview": "1403637130538319104\n1403637130588318976\n1403637130638319104\n1403637130688318976\n1403637130738319104\n1403637130788318976\n"
  },
  {
    "path": "Examples/Monocular/EuRoC_TimeStamps/MH04.txt",
    "chars": 40660,
    "preview": "1403638127245096960\n1403638127295097088\n1403638127345096960\n1403638127395097088\n1403638127445096960\n1403638127495097088\n"
  },
  {
    "path": "Examples/Monocular/EuRoC_TimeStamps/MH05.txt",
    "chars": 45460,
    "preview": "1403638518077829376\n1403638518127829504\n1403638518177829376\n1403638518227829504\n1403638518277829376\n1403638518327829504\n"
  },
  {
    "path": "Examples/Monocular/EuRoC_TimeStamps/V101.txt",
    "chars": 58240,
    "preview": "1403715273262142976\n1403715273312143104\n1403715273362142976\n1403715273412143104\n1403715273462142976\n1403715273512143104\n"
  },
  {
    "path": "Examples/Monocular/EuRoC_TimeStamps/V102.txt",
    "chars": 34200,
    "preview": "1403715523912143104\n1403715523962142976\n1403715524012143104\n1403715524062142976\n1403715524112143104\n1403715524162142976\n"
  },
  {
    "path": "Examples/Monocular/EuRoC_TimeStamps/V103.txt",
    "chars": 42980,
    "preview": "1403715886584058112\n1403715886634057984\n1403715886684058112\n1403715886734057984\n1403715886784058112\n1403715886834057984\n"
  },
  {
    "path": "Examples/Monocular/EuRoC_TimeStamps/V201.txt",
    "chars": 45600,
    "preview": "1413393212255760384\n1413393212305760512\n1413393212355760384\n1413393212405760512\n1413393212455760384\n1413393212505760512\n"
  },
  {
    "path": "Examples/Monocular/EuRoC_TimeStamps/V202.txt",
    "chars": 46960,
    "preview": "1413393886005760512\n1413393886055760384\n1413393886105760512\n1413393886155760384\n1413393886205760512\n1413393886255760384\n"
  },
  {
    "path": "Examples/Monocular/EuRoC_TimeStamps/V203.txt",
    "chars": 38440,
    "preview": "1413394881555760384\n1413394881605760512\n1413394881655760384\n1413394881705760512\n1413394881755760384\n1413394881805760512\n"
  },
  {
    "path": "Examples/Monocular/KITTI00-02.yaml",
    "chars": 1820,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# Camera Parame"
  },
  {
    "path": "Examples/Monocular/KITTI03.yaml",
    "chars": 1821,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# Camera Parame"
  },
  {
    "path": "Examples/Monocular/KITTI04-12.yaml",
    "chars": 1822,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# Camera Parame"
  },
  {
    "path": "Examples/Monocular/TUM1.yaml",
    "chars": 1875,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# Camera Parame"
  },
  {
    "path": "Examples/Monocular/TUM2.yaml",
    "chars": 1876,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# Camera Parame"
  },
  {
    "path": "Examples/Monocular/TUM3.yaml",
    "chars": 1813,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# Camera Parame"
  },
  {
    "path": "Examples/Monocular/mono_euroc.cpp",
    "chars": 4643,
    "preview": "/**\n* This file is part of ORB-SLAM2.\n*\n* Copyright (C) 2014-2016 Raúl Mur-Artal <raulmur at unizar dot es> (University "
  },
  {
    "path": "Examples/Monocular/mono_kitti.cpp",
    "chars": 4666,
    "preview": "/**\n* This file is part of ORB-SLAM2.\n*\n* Copyright (C) 2014-2016 Raúl Mur-Artal <raulmur at unizar dot es> (University "
  },
  {
    "path": "Examples/Monocular/mono_live.cpp",
    "chars": 2711,
    "preview": "\n#include<iostream>\n#include<algorithm>\n#include<fstream>\n#include<chrono>\n\n#include<opencv2/core/core.hpp>\n\n#include<Sy"
  },
  {
    "path": "Examples/Monocular/mono_tum.cpp",
    "chars": 4517,
    "preview": "/**\n* This file is part of ORB-SLAM2.\n*\n* Copyright (C) 2014-2016 Raúl Mur-Artal <raulmur at unizar dot es> (University "
  },
  {
    "path": "Examples/RGB-D/TUM1.yaml",
    "chars": 2075,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# Camera Parame"
  },
  {
    "path": "Examples/RGB-D/TUM1_GPU.yaml",
    "chars": 2337,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# GPU Parameter"
  },
  {
    "path": "Examples/RGB-D/TUM2.yaml",
    "chars": 2076,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# Camera Parame"
  },
  {
    "path": "Examples/RGB-D/TUM3.yaml",
    "chars": 2012,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# Camera Parame"
  },
  {
    "path": "Examples/RGB-D/associations/fr1_desk.txt",
    "chars": 51570,
    "preview": "1305031453.359684 rgb/1305031453.359684.png 1305031453.374112 depth/1305031453.374112.png\n1305031453.391690 rgb/13050314"
  },
  {
    "path": "Examples/RGB-D/associations/fr1_desk2.txt",
    "chars": 55800,
    "preview": "1305031526.671473 rgb/1305031526.671473.png 1305031526.688356 depth/1305031526.688356.png\n1305031526.707547 rgb/13050315"
  },
  {
    "path": "Examples/RGB-D/associations/fr1_room.txt",
    "chars": 121680,
    "preview": "1305031910.765238 rgb/1305031910.765238.png 1305031910.771502 depth/1305031910.771502.png\n1305031910.797230 rgb/13050319"
  },
  {
    "path": "Examples/RGB-D/associations/fr1_xyz.txt",
    "chars": 71280,
    "preview": "1305031102.175304 rgb/1305031102.175304.png 1305031102.160407 depth/1305031102.160407.png\n1305031102.211214 rgb/13050311"
  },
  {
    "path": "Examples/RGB-D/associations/fr2_desk.txt",
    "chars": 260370,
    "preview": "1311868164.363181 rgb/1311868164.363181.png 1311868164.373557 depth/1311868164.373557.png\n1311868164.399026 rgb/13118681"
  },
  {
    "path": "Examples/RGB-D/associations/fr2_xyz.txt",
    "chars": 325350,
    "preview": "1311867170.462290 rgb/1311867170.462290.png 1311867170.450076 depth/1311867170.450076.png\n1311867170.494139 rgb/13118671"
  },
  {
    "path": "Examples/RGB-D/associations/fr3_nstr_tex_near.txt",
    "chars": 147510,
    "preview": "1341840083.789974 rgb/1341840083.789974.png 1341840083.790018 depth/1341840083.790018.png\n1341840083.821987 rgb/13418400"
  },
  {
    "path": "Examples/RGB-D/associations/fr3_office.txt",
    "chars": 223920,
    "preview": "1341847980.722988 rgb/1341847980.722988.png 1341847980.723020 depth/1341847980.723020.png\n1341847980.754743 rgb/13418479"
  },
  {
    "path": "Examples/RGB-D/associations/fr3_office_val.txt",
    "chars": 232560,
    "preview": "1341848149.066823 rgb/1341848149.066823.png 1341848149.066840 depth/1341848149.066840.png\n1341848149.102697 rgb/13418481"
  },
  {
    "path": "Examples/RGB-D/associations/fr3_str_tex_far.txt",
    "chars": 81630,
    "preview": "1341839113.657637 rgb/1341839113.657637.png 1341839113.657663 depth/1341839113.657663.png\n1341839113.693575 rgb/13418391"
  },
  {
    "path": "Examples/RGB-D/associations/fr3_str_tex_near.txt",
    "chars": 95130,
    "preview": "1341839327.392692 rgb/1341839327.392692.png 1341839327.392719 depth/1341839327.392719.png\n1341839327.424683 rgb/13418393"
  },
  {
    "path": "Examples/RGB-D/kinect.yaml",
    "chars": 2023,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# Camera Parame"
  },
  {
    "path": "Examples/RGB-D/rgbd_live.cpp",
    "chars": 2719,
    "preview": "\n#include<iostream>\n#include<algorithm>\n#include<fstream>\n#include<chrono>\n\n#include<opencv2/core/core.hpp>\n\n#include<Sy"
  },
  {
    "path": "Examples/RGB-D/rgbd_live.yaml",
    "chars": 2529,
    "preview": "%YAML:1.0\n\n\nmask.left: \"//home/ashish/ashish/datasets/ga/fridge_open/mask.png\"\n\n#---------------------------------------"
  },
  {
    "path": "Examples/RGB-D/rgbd_tum.cpp",
    "chars": 5587,
    "preview": "/**\n* This file is part of ORB-SLAM2.\n*\n* Copyright (C) 2014-2016 Raúl Mur-Artal <raulmur at unizar dot es> (University "
  },
  {
    "path": "Examples/Stereo/EuRoC.yaml",
    "chars": 4316,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# GPU Parameter"
  },
  {
    "path": "Examples/Stereo/EuRoC_TimeStamps/MH01.txt",
    "chars": 73640,
    "preview": "1403636579763555584\n1403636579813555456\n1403636579863555584\n1403636579913555456\n1403636579963555584\n1403636580013555456\n"
  },
  {
    "path": "Examples/Stereo/EuRoC_TimeStamps/MH02.txt",
    "chars": 60800,
    "preview": "1403636858651666432\n1403636858701666560\n1403636858751666432\n1403636858801666560\n1403636858851666432\n1403636858901666560\n"
  },
  {
    "path": "Examples/Stereo/EuRoC_TimeStamps/MH03.txt",
    "chars": 54000,
    "preview": "1403637130538319104\n1403637130588318976\n1403637130638319104\n1403637130688318976\n1403637130738319104\n1403637130788318976\n"
  },
  {
    "path": "Examples/Stereo/EuRoC_TimeStamps/MH04.txt",
    "chars": 40640,
    "preview": "1403638127295097088\n1403638127345096960\n1403638127395097088\n1403638127445096960\n1403638127495097088\n1403638127545096960\n"
  },
  {
    "path": "Examples/Stereo/EuRoC_TimeStamps/MH05.txt",
    "chars": 45460,
    "preview": "1403638518077829376\n1403638518127829504\n1403638518177829376\n1403638518227829504\n1403638518277829376\n1403638518327829504\n"
  },
  {
    "path": "Examples/Stereo/EuRoC_TimeStamps/V101.txt",
    "chars": 58240,
    "preview": "1403715273262142976\n1403715273312143104\n1403715273362142976\n1403715273412143104\n1403715273462142976\n1403715273512143104\n"
  },
  {
    "path": "Examples/Stereo/EuRoC_TimeStamps/V102.txt",
    "chars": 34200,
    "preview": "1403715523912143104\n1403715523962142976\n1403715524012143104\n1403715524062142976\n1403715524112143104\n1403715524162142976\n"
  },
  {
    "path": "Examples/Stereo/EuRoC_TimeStamps/V103.txt",
    "chars": 42980,
    "preview": "1403715886584058112\n1403715886634057984\n1403715886684058112\n1403715886734057984\n1403715886784058112\n1403715886834057984\n"
  },
  {
    "path": "Examples/Stereo/EuRoC_TimeStamps/V201.txt",
    "chars": 45600,
    "preview": "1413393212255760384\n1413393212305760512\n1413393212355760384\n1413393212405760512\n1413393212455760384\n1413393212505760512\n"
  },
  {
    "path": "Examples/Stereo/EuRoC_TimeStamps/V202.txt",
    "chars": 46960,
    "preview": "1413393886005760512\n1413393886055760384\n1413393886105760512\n1413393886155760384\n1413393886205760512\n1413393886255760384\n"
  },
  {
    "path": "Examples/Stereo/EuRoC_TimeStamps/V203.txt",
    "chars": 38420,
    "preview": "1413394881605760512\n1413394881655760384\n1413394881705760512\n1413394881755760384\n1413394881805760512\n1413394881855760384\n"
  },
  {
    "path": "Examples/Stereo/KITTI00-02.yaml",
    "chars": 2125,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# GPU Parameter"
  },
  {
    "path": "Examples/Stereo/KITTI00-02_custom.yaml",
    "chars": 1954,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# Camera Parame"
  },
  {
    "path": "Examples/Stereo/KITTI03.yaml",
    "chars": 1960,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# Camera Parame"
  },
  {
    "path": "Examples/Stereo/KITTI04-12.yaml",
    "chars": 2463,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# GPU Parameter"
  },
  {
    "path": "Examples/Stereo/euroc_old/CameraTrajectory_MH01.txt",
    "chars": 389892,
    "preview": "1403636579763555584 0.000000000 0.000000000 0.000000000 0.000000000 0.000000000 0.000000000 1.000000000\n1403636579813555"
  },
  {
    "path": "Examples/Stereo/euroc_old/CameraTrajectory_MH02.txt",
    "chars": 323813,
    "preview": "1403636858651666432 0.000000000 0.000000000 0.000000000 0.000000000 0.000000000 0.000000000 1.000000000\n1403636858701666"
  },
  {
    "path": "Examples/Stereo/euroc_old/CameraTrajectory_MH03.txt",
    "chars": 286817,
    "preview": "1403637130538319104 0.000000000 0.000000000 0.000000000 0.000000000 0.000000000 0.000000000 1.000000000\n1403637130588318"
  },
  {
    "path": "Examples/Stereo/euroc_old/CameraTrajectory_MH04.txt",
    "chars": 217312,
    "preview": "1403638127295097088 0.000000000 0.000000000 0.000000000 0.000000000 0.000000000 0.000000000 1.000000000\n1403638127345096"
  },
  {
    "path": "Examples/Stereo/euroc_old/CameraTrajectory_MH05.txt",
    "chars": 242424,
    "preview": "1403638518077829376 0.000000000 0.000000000 0.000000000 0.000000000 0.000000000 0.000000000 1.000000000\n1403638518127829"
  },
  {
    "path": "Examples/Stereo/kaist_vio_dataset.yaml",
    "chars": 2553,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# GPU Parameter"
  },
  {
    "path": "Examples/Stereo/stereo_euroc.cpp",
    "chars": 7204,
    "preview": "/**\n* This file is part of ORB-SLAM2.\n*\n* Copyright (C) 2014-2016 Raúl Mur-Artal <raulmur at unizar dot es> (University "
  },
  {
    "path": "Examples/Stereo/stereo_kitti.cpp",
    "chars": 8036,
    "preview": "/**\n* This file is part of ORB-SLAM2.\n*\n* Copyright (C) 2014-2016 Raúl Mur-Artal <raulmur at unizar dot es> (University "
  },
  {
    "path": "Examples/Stereo/stereo_live.cpp",
    "chars": 3806,
    "preview": "/**\n* This file is part of ORB-SLAM2.\n*\n* Copyright (C) 2014-2016 Raúl Mur-Artal <raulmur at unizar dot es> (University "
  },
  {
    "path": "Examples/Stereo/stereo_rig_realsense.yaml",
    "chars": 3045,
    "preview": "%YAML:1.0\n\n#--------------------------------------------------------------------------------------------\n# mask for feat"
  },
  {
    "path": "README.md",
    "chars": 4151,
    "preview": "# Jetson-SLAM\n\n\n**The frontend of Jetson-SLAM will be released as a separate repository as-well.**\n\n**Authors:** Ashish "
  },
  {
    "path": "Thirdparty/DBoW2/CMakeLists.txt",
    "chars": 803,
    "preview": "cmake_minimum_required(VERSION 2.8)\nproject(DBoW2)\n\nset(CMAKE_C_FLAGS \"${CMAKE_C_FLAGS}  -Wall  -O3 -march=native \")\nset"
  },
  {
    "path": "Thirdparty/DBoW2/DBoW2/BowVector.cpp",
    "chars": 2752,
    "preview": "/**\n * File: BowVector.cpp\n * Date: March 2011\n * Author: Dorian Galvez-Lopez\n * Description: bag of words vector\n * Lic"
  },
  {
    "path": "Thirdparty/DBoW2/DBoW2/BowVector.h",
    "chars": 1886,
    "preview": "/**\n * File: BowVector.h\n * Date: March 2011\n * Author: Dorian Galvez-Lopez\n * Description: bag of words vector\n * Licen"
  },
  {
    "path": "Thirdparty/DBoW2/DBoW2/FClass.h",
    "chars": 1647,
    "preview": "/**\n * File: FClass.h\n * Date: November 2011\n * Author: Dorian Galvez-Lopez\n * Description: generic FClass to instantiat"
  },
  {
    "path": "Thirdparty/DBoW2/DBoW2/FORB.cpp",
    "chars": 4409,
    "preview": "/**\n * File: FORB.cpp\n * Date: June 2012\n * Author: Dorian Galvez-Lopez\n * Description: functions for ORB descriptors\n *"
  },
  {
    "path": "Thirdparty/DBoW2/DBoW2/FORB.h",
    "chars": 1676,
    "preview": "/**\n * File: FORB.h\n * Date: June 2012\n * Author: Dorian Galvez-Lopez\n * Description: functions for ORB descriptors\n * L"
  },
  {
    "path": "Thirdparty/DBoW2/DBoW2/FeatureVector.cpp",
    "chars": 1831,
    "preview": "/**\n * File: FeatureVector.cpp\n * Date: November 2011\n * Author: Dorian Galvez-Lopez\n * Description: feature vector\n * L"
  },
  {
    "path": "Thirdparty/DBoW2/DBoW2/FeatureVector.h",
    "chars": 1080,
    "preview": "/**\n * File: FeatureVector.h\n * Date: November 2011\n * Author: Dorian Galvez-Lopez\n * Description: feature vector\n * Lic"
  },
  {
    "path": "Thirdparty/DBoW2/DBoW2/ScoringObject.cpp",
    "chars": 7890,
    "preview": "/**\n * File: ScoringObject.cpp\n * Date: November 2011\n * Author: Dorian Galvez-Lopez\n * Description: functions to comput"
  },
  {
    "path": "Thirdparty/DBoW2/DBoW2/ScoringObject.h",
    "chars": 2449,
    "preview": "/**\n * File: ScoringObject.h\n * Date: November 2011\n * Author: Dorian Galvez-Lopez\n * Description: functions to compute "
  },
  {
    "path": "Thirdparty/DBoW2/DBoW2/TemplatedVocabulary.h",
    "chars": 42456,
    "preview": "/**\n * This is a modified version of TemplatedVocabulary.h from DBoW2 (see below).\n * Added functions: Save and Load fro"
  },
  {
    "path": "Thirdparty/DBoW2/DUtils/Random.cpp",
    "chars": 2886,
    "preview": "/*\t\r\n * File: Random.cpp\r\n * Project: DUtils library\r\n * Author: Dorian Galvez-Lopez\r\n * Date: April 2010\r\n * Descriptio"
  },
  {
    "path": "Thirdparty/DBoW2/DUtils/Random.h",
    "chars": 3774,
    "preview": "/*\t\n * File: Random.h\n * Project: DUtils library\n * Author: Dorian Galvez-Lopez\n * Date: April 2010, November 2011\n * De"
  },
  {
    "path": "Thirdparty/DBoW2/DUtils/Timestamp.cpp",
    "chars": 5117,
    "preview": "/*\r\n * File: Timestamp.cpp\r\n * Author: Dorian Galvez-Lopez\r\n * Date: March 2009\r\n * Description: timestamping functions\r"
  },
  {
    "path": "Thirdparty/DBoW2/DUtils/Timestamp.h",
    "chars": 4567,
    "preview": "/*\n * File: Timestamp.h\n * Author: Dorian Galvez-Lopez\n * Date: March 2009\n * Description: timestamping functions\n * Lic"
  },
  {
    "path": "Thirdparty/DBoW2/LICENSE.txt",
    "chars": 2072,
    "preview": "DBoW2: bag-of-words library for C++ with generic descriptors\r\n\r\nCopyright (c) 2015 Dorian Galvez-Lopez <http://doriangal"
  },
  {
    "path": "Thirdparty/DBoW2/README.txt",
    "chars": 443,
    "preview": "You should have received this DBoW2 version along with ORB-SLAM2 (https://github.com/raulmur/ORB_SLAM2).\nSee the origina"
  },
  {
    "path": "Thirdparty/g2o/CMakeLists.txt",
    "chars": 5616,
    "preview": "CMAKE_MINIMUM_REQUIRED(VERSION 2.6)\nSET(CMAKE_LEGACY_CYGWIN_WIN32 0)\n\nPROJECT(g2o)\n\nSET(g2o_C_FLAGS)\nSET(g2o_CXX_FLAGS)\n"
  },
  {
    "path": "Thirdparty/g2o/README.txt",
    "chars": 243,
    "preview": "You should have received this g2o version along with ORB-SLAM2 (https://github.com/raulmur/ORB_SLAM2).\nSee the original "
  },
  {
    "path": "Thirdparty/g2o/cmake_modules/FindBLAS.cmake",
    "chars": 12988,
    "preview": "# Find BLAS library\n#\n# This module finds an installed library that implements the BLAS\n# linear-algebra interface (see "
  },
  {
    "path": "Thirdparty/g2o/cmake_modules/FindEigen3.cmake",
    "chars": 3249,
    "preview": "# - Try to find Eigen3 lib\n#\n# This module supports requiring a minimum version, e.g. you can do\n#   find_package(Eigen3"
  },
  {
    "path": "Thirdparty/g2o/cmake_modules/FindLAPACK.cmake",
    "chars": 9909,
    "preview": "# Find LAPACK library\n#\n# This module finds an installed library that implements the LAPACK\n# linear-algebra interface ("
  },
  {
    "path": "Thirdparty/g2o/config.h",
    "chars": 380,
    "preview": "#ifndef G2O_CONFIG_H\n#define G2O_CONFIG_H\n\n/* #undef G2O_OPENMP */\n/* #undef G2O_SHARED_LIBS */\n\n// give a warning if Ei"
  },
  {
    "path": "Thirdparty/g2o/config.h.in",
    "chars": 384,
    "preview": "#ifndef G2O_CONFIG_H\n#define G2O_CONFIG_H\n\n#cmakedefine G2O_OPENMP 1\n#cmakedefine G2O_SHARED_LIBS 1\n\n// give a warning i"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/base_binary_edge.h",
    "chars": 4621,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, H. Strasdat, W. Burgard\n// All righ"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/base_binary_edge.hpp",
    "chars": 7868,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, H. Strasdat, W. Burgard\n// All righ"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/base_edge.h",
    "chars": 3912,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, H. Strasdat, W. Burgard\n// All righ"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/base_multi_edge.h",
    "chars": 3921,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, H. Strasdat, W. Burgard\n// All righ"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/base_multi_edge.hpp",
    "chars": 7378,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, H. Strasdat, W. Burgard\n// All righ"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/base_unary_edge.h",
    "chars": 3603,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, H. Strasdat, W. Burgard\n// All righ"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/base_unary_edge.hpp",
    "chars": 4571,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, H. Strasdat, W. Burgard\n// All righ"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/base_vertex.h",
    "chars": 4545,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/base_vertex.hpp",
    "chars": 2152,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/batch_stats.cpp",
    "chars": 3360,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/batch_stats.h",
    "chars": 3782,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/block_solver.h",
    "chars": 7527,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/block_solver.hpp",
    "chars": 22001,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/cache.cpp",
    "chars": 5242,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 G. Grisetti, R. Kuemmerle, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/cache.h",
    "chars": 4952,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/creators.h",
    "chars": 2656,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/eigen_types.h",
    "chars": 4167,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/estimate_propagator.cpp",
    "chars": 10141,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/estimate_propagator.h",
    "chars": 6395,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/factory.cpp",
    "chars": 6420,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/factory.h",
    "chars": 5930,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/hyper_dijkstra.cpp",
    "chars": 9489,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/hyper_dijkstra.h",
    "chars": 4579,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/hyper_graph.cpp",
    "chars": 4368,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/hyper_graph.h",
    "chars": 8135,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/hyper_graph_action.cpp",
    "chars": 8960,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/hyper_graph_action.h",
    "chars": 7930,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/jacobian_workspace.cpp",
    "chars": 3376,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/jacobian_workspace.h",
    "chars": 3321,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/linear_solver.h",
    "chars": 3811,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/marginal_covariance_cholesky.cpp",
    "chars": 7345,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/marginal_covariance_cholesky.h",
    "chars": 4172,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/matrix_operations.h",
    "chars": 3358,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/matrix_structure.cpp",
    "chars": 3566,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/matrix_structure.h",
    "chars": 2581,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/openmp_mutex.h",
    "chars": 2916,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/optimizable_graph.cpp",
    "chars": 27537,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, H. Strasdat, W. Burgard\n// All righ"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/optimizable_graph.h",
    "chars": 25597,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, H. Strasdat, W. Burgard\n// All righ"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/optimization_algorithm.cpp",
    "chars": 2283,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/optimization_algorithm.h",
    "chars": 4355,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/optimization_algorithm_dogleg.cpp",
    "chars": 8625,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/optimization_algorithm_dogleg.h",
    "chars": 3493,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/optimization_algorithm_factory.cpp",
    "chars": 4892,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/optimization_algorithm_factory.h",
    "chars": 6192,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/optimization_algorithm_gauss_newton.cpp",
    "chars": 3491,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/optimization_algorithm_gauss_newton.h",
    "chars": 2177,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/optimization_algorithm_levenberg.cpp",
    "chars": 6704,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/optimization_algorithm_levenberg.h",
    "chars": 3815,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/optimization_algorithm_property.h",
    "chars": 2593,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/optimization_algorithm_with_hessian.cpp",
    "chars": 3537,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/optimization_algorithm_with_hessian.h",
    "chars": 2731,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/parameter.cpp",
    "chars": 1587,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/parameter.h",
    "chars": 2166,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/parameter_container.cpp",
    "chars": 4459,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/parameter_container.h",
    "chars": 2827,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/robust_kernel.cpp",
    "chars": 1670,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/robust_kernel.h",
    "chars": 2835,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/robust_kernel_factory.cpp",
    "chars": 3401,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/robust_kernel_factory.h",
    "chars": 4749,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/robust_kernel_impl.cpp",
    "chars": 4973,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/robust_kernel_impl.h",
    "chars": 4678,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/solver.cpp",
    "chars": 2610,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/solver.h",
    "chars": 5444,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/sparse_block_matrix.h",
    "chars": 9514,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/sparse_block_matrix.hpp",
    "chars": 25490,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/sparse_block_matrix_ccs.h",
    "chars": 10801,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/sparse_block_matrix_diagonal.h",
    "chars": 4184,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/sparse_block_matrix_test.cpp",
    "chars": 3192,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/sparse_optimizer.cpp",
    "chars": 20717,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/core/sparse_optimizer.h",
    "chars": 12602,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/solvers/linear_solver_dense.h",
    "chars": 3946,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 H. Strasdat\n// Copyright (C) 2012 R. Kümmerle\n// All rights re"
  },
  {
    "path": "Thirdparty/g2o/g2o/solvers/linear_solver_eigen.h",
    "chars": 9078,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/stuff/color_macros.h",
    "chars": 2572,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/stuff/macros.h",
    "chars": 4360,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/stuff/misc.h",
    "chars": 4207,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/stuff/os_specific.c",
    "chars": 2043,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/stuff/os_specific.h",
    "chars": 1882,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/stuff/property.cpp",
    "chars": 3410,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/stuff/property.h",
    "chars": 5023,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/stuff/string_tools.cpp",
    "chars": 5037,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/stuff/string_tools.h",
    "chars": 4767,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/stuff/timeutil.cpp",
    "chars": 3722,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/stuff/timeutil.h",
    "chars": 3690,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 R. Kuemmerle, G. Grisetti, W. Burgard\n// All rights reserved.\n"
  },
  {
    "path": "Thirdparty/g2o/g2o/types/se3_ops.h",
    "chars": 1851,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 H. Strasdat\n// All rights reserved.\n//\n// Redistribution and u"
  },
  {
    "path": "Thirdparty/g2o/g2o/types/se3_ops.hpp",
    "chars": 2334,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 H. Strasdat\n// All rights reserved.\n//\n// Redistribution and u"
  },
  {
    "path": "Thirdparty/g2o/g2o/types/se3quat.h",
    "chars": 8167,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 H. Strasdat\n// All rights reserved.\n//\n// Redistribution and u"
  },
  {
    "path": "Thirdparty/g2o/g2o/types/sim3.h",
    "chars": 6948,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 H. Strasdat\n// All rights reserved.\n//\n// Redistribution and u"
  },
  {
    "path": "Thirdparty/g2o/g2o/types/types_sba.cpp",
    "chars": 1905,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 Kurt Konolige\n// All rights reserved.\n//\n// Redistribution and"
  },
  {
    "path": "Thirdparty/g2o/g2o/types/types_sba.h",
    "chars": 2045,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 Kurt Konolige\n// All rights reserved.\n//\n// Redistribution and"
  },
  {
    "path": "Thirdparty/g2o/g2o/types/types_seven_dof_expmap.cpp",
    "chars": 6226,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 H. Strasdat\n// All rights reserved.\n//\n// Redistribution and u"
  },
  {
    "path": "Thirdparty/g2o/g2o/types/types_seven_dof_expmap.h",
    "chars": 5634,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 H. Strasdat\n// All rights reserved.\n//\n// Redistribution and u"
  },
  {
    "path": "Thirdparty/g2o/g2o/types/types_six_dof_expmap.cpp",
    "chars": 10260,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 H. Strasdat\n// All rights reserved.\n//\n// Redistribution and u"
  },
  {
    "path": "Thirdparty/g2o/g2o/types/types_six_dof_expmap.h",
    "chars": 6116,
    "preview": "// g2o - General Graph Optimization\n// Copyright (C) 2011 H. Strasdat\n// All rights reserved.\n//\n// Redistribution and u"
  },
  {
    "path": "Thirdparty/g2o/license-bsd.txt",
    "chars": 1401,
    "preview": "g2o - General Graph Optimization\nCopyright (C) 2011 Rainer Kuemmerle, Giorgio Grisetti, Hauke Strasdat,\nKurt Konolige, a"
  },
  {
    "path": "Thirdparty/g2o_new/CMakeLists.txt",
    "chars": 18769,
    "preview": "cmake_minimum_required(VERSION 3.14)\n\nset(CMAKE_LEGACY_CYGWIN_WIN32 0)\nset(CMAKE_OSX_DEPLOYMENT_TARGET \"10.15\" CACHE STR"
  },
  {
    "path": "Thirdparty/g2o_new/Makefile",
    "chars": 346,
    "preview": "SHELL = /bin/bash\n\nifeq ($(VERBOSE), 1)\nQUIET=\nelse\nQUIET=-s --no-print-directory\nendif\n\nall: build/Makefile\n\t@ $(MAKE) "
  },
  {
    "path": "Thirdparty/g2o_new/README.md",
    "chars": 7808,
    "preview": "# g2o - General Graph Optimization\n\nLinux/Mac: [![CI](https://github.com/RainerKuemmerle/g2o/actions/workflows/ci.yml/ba"
  },
  {
    "path": "Thirdparty/g2o_new/benchmarks/CMakeLists.txt",
    "chars": 292,
    "preview": "add_executable(benchmark_jacobian_timing jacobian_timing_tests.cpp)\n\ntarget_include_directories(benchmark_jacobian_timin"
  },
  {
    "path": "Thirdparty/g2o_new/benchmarks/jacobian_timing_tests.cpp",
    "chars": 9735,
    "preview": "#include <benchmark/benchmark.h>\n\n#include \"g2o/autodiff/fixed_array.h\"\n#include \"g2o/core/dynamic_aligned_buffer.hpp\"\n\n"
  },
  {
    "path": "Thirdparty/g2o_new/cmake_modules/CheckIfUnderscorePrefixedBesselFunctionsExist.cmake",
    "chars": 2599,
    "preview": "# Ceres Solver - A fast non-linear least squares minimizer\n# Copyright 2017 Google Inc. All rights reserved.\n# http://ce"
  },
  {
    "path": "Thirdparty/g2o_new/cmake_modules/Config.cmake.in",
    "chars": 297,
    "preview": "include(CMakeFindDependencyMacro)\n\nfind_dependency(Eigen3)\n\nif (@G2O_HAVE_OPENGL@)\n  find_dependency(OpenGL)\nendif()\n\n# "
  },
  {
    "path": "Thirdparty/g2o_new/cmake_modules/FindCSparse.cmake",
    "chars": 618,
    "preview": "# Look for csparse; note the difference in the directory specifications!\nfind_path(CSPARSE_INCLUDE_DIR NAMES cs.h\n  PATH"
  },
  {
    "path": "Thirdparty/g2o_new/cmake_modules/FindEigen3.cmake",
    "chars": 3505,
    "preview": "# - Try to find Eigen3 lib\n#\n# This module supports requiring a minimum version, e.g. you can do\n#   find_package(Eigen3"
  },
  {
    "path": "Thirdparty/g2o_new/cmake_modules/FindG2O.cmake",
    "chars": 3271,
    "preview": "# Find the header files\n\nfind_path(G2O_INCLUDE_DIR g2o/core/base_vertex.h\n  ${G2O_ROOT}/include\n  $ENV{G2O_ROOT}/include"
  },
  {
    "path": "Thirdparty/g2o_new/cmake_modules/FindMETIS.cmake",
    "chars": 4255,
    "preview": "#\n# Copyright (c) 2022 Sergiu Deitsch\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n#"
  },
  {
    "path": "Thirdparty/g2o_new/cmake_modules/FindQGLViewer.cmake",
    "chars": 1478,
    "preview": "find_package(Qt5 COMPONENTS Core Xml OpenGL Gui Widgets QUIET)\nif(NOT Qt5_FOUND)\n  message(\"Qt5 not found. Install it an"
  }
]

// ... and 750 more files (download for full content)