### Setup PPA automatically

Source: https://github.com/koide3/glim/blob/master/docs/installation.md

Automatically configures the GLIM PPA by downloading and executing a setup script.

```bash
# Automatically setup PPA via online script
curl -s https://koide3.github.io/ppa/setup_ppa.sh | sudo bash
```

--------------------------------

### Build and install GTSAM from source

Source: https://github.com/koide3/glim/blob/master/docs/installation.md

Clones the GTSAM repository, checks out a specific version, configures the build with CMake (disabling examples, tests, TBB, and enabling system Eigen), and installs it.

```bash
# Install GTSAM
git clone https://github.com/borglab/gtsam
cd gtsam && git checkout 4.3a0
mkdir build && cd build
cmake .. -DGTSAM_BUILD_EXAMPLES_ALWAYS=OFF \
         -DGTSAM_BUILD_TESTS=OFF \
         -DGTSAM_WITH_TBB=OFF \
         -DGTSAM_USE_SYSTEM_EIGEN=ON \
         -DGTSAM_BUILD_WITH_MARCH_NATIVE=OFF
make -j$(nproc)
sudo make install
```

--------------------------------

### Install PPA prerequisites

Source: https://github.com/koide3/glim/blob/master/docs/installation.md

Installs curl and gpg, which are necessary for managing package repositories.

```bash
sudo apt install curl gpg
```

--------------------------------

### Install Project Directories and Targets

Source: https://github.com/koide3/glim/blob/master/CMakeLists.txt

Installs the project's include directory, targets (libraries, archives, runtimes), and CMake configuration files. This makes the project installable and usable by other projects.

```cmake
install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
install(TARGETS ${glim_LIBRARIES}
  EXPORT glim-targets
  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
include(CMakePackageConfigHelpers)
install(EXPORT glim-targets
  FILE glim-targets.cmake
  NAMESPACE glim::
  DESTINATION ${CMAKE_CONFIG_INSTALL_DIR}
)
configure_package_config_file(
  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/glim-config.cmake.in"
  "${CMAKE_CURRENT_BINARY_DIR}/glim-config.cmake"
  INSTALL_DESTINATION ${CMAKE_CONFIG_INSTALL_DIR}
)
write_basic_package_version_file(
  "${CMAKE_CURRENT_BINARY_DIR}/glim-config-version.cmake"
  VERSION ${VERSION}
  COMPATIBILITY SameMajorVersion
)
install(FILES
  "${CMAKE_CURRENT_BINARY_DIR}/glim-config.cmake"
  "${CMAKE_CURRENT_BINARY_DIR}/glim-config-version.cmake"
  DESTINATION ${CMAKE_CONFIG_INSTALL_DIR}
)
```

--------------------------------

### Build and install Iridescence from source

Source: https://github.com/koide3/glim/blob/master/docs/installation.md

Clones the Iridescence repository (including submodules), builds it with CMake in Release mode, and installs it. This is optional but recommended for visualization.

```bash
# Install Iridescence for visualization
# This is optional but highly recommended
git clone https://github.com/koide3/iridescence --recursive
mkdir iridescence/build && cd iridescence/build
cmake .. -DCMAKE_BUILD_TYPE=Release
make -j$(nproc)
sudo make install
```

--------------------------------

### Install GLIM dependencies

Source: https://github.com/koide3/glim/blob/master/docs/installation.md

Installs core dependencies for GLIM, including development libraries for Iridescence, Boost, GLFW, and METIS. Also installs GTSAM, with options for CUDA support.

```bash
sudo apt update
sudo apt install -y libiridescence-dev libboost-all-dev libglfw3-dev libmetis-dev

# Choose one of the follows
sudo apt install -y libgtsam-points-dev           # without CUDA
sudo apt install -y libgtsam-points-cuda12.2-dev  # with CUDA 12.2 (Ubuntu 22.04 only)
sudo apt install -y libgtsam-points-cuda12.6-dev  # with CUDA 12.6
sudo apt install -y libgtsam-points-cuda13.1-dev  # with CUDA 13.1
```

--------------------------------

### Start Map Editor

Source: https://github.com/koide3/glim/blob/master/docs/edit.md

Launches the Glim map editor. Ensure ROS 2 is sourced.

```bash
ros2 run glim_ros map_editor
```

--------------------------------

### Install common dependencies for building from source

Source: https://github.com/koide3/glim/blob/master/docs/installation.md

Installs essential development libraries required for building GLIM from source, including OpenMP, Boost, METIS, fmt, spdlog, GLM, GLFW, and image loading libraries.

```bash
# Install dependencies
sudo apt install libomp-dev libboost-all-dev libmetis-dev \
                 libfmt-dev libspdlog-dev \
                 libglm-dev libglfw3-dev libpng-dev libjpeg-dev
```

--------------------------------

### Manually setup PPA for Ubuntu 22.04

Source: https://github.com/koide3/glim/blob/master/docs/installation.md

Manually adds the GLIM PPA for Ubuntu 22.04 by downloading the GPG key and adding the repository to sources.list.d.

```bash
# Manually setup PPA for Ubuntu 22.04
curl -s --compressed "https://koide3.github.io/ppa/ubuntu2204/KEY.gpg" | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/koide3_ppa.gpg >/dev/null
echo "deb [signed-by=/etc/apt/trusted.gpg.d/koide3_ppa.gpg] https://koide3.github.io/ppa/ubuntu2204 ./
" | sudo tee /etc/apt/sources.list.d/koide3_ppa.list
sudo apt update
```

--------------------------------

### Build and install gtsam_points from source

Source: https://github.com/koide3/glim/blob/master/docs/installation.md

Clones the gtsam_points repository, builds it with CMake enabling CUDA support, and installs it.

```bash
# Install gtsam_points
git clone https://github.com/koide3/gtsam_points
mkdir gtsam_points/build && cd gtsam_points/build
cmake .. -DBUILD_WITH_CUDA=ON
make -j$(nproc)
sudo make install
```

--------------------------------

### Manually setup PPA for Ubuntu 24.04

Source: https://github.com/koide3/glim/blob/master/docs/installation.md

Manually adds the GLIM PPA for Ubuntu 24.04 by downloading the GPG key and adding the repository to sources.list.d.

```bash
# Manually setup PPA for Ubuntu 24.04
curl -s --compressed "https://koide3.github.io/ppa/ubuntu2404/KEY.gpg" | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/koide3_ppa.gpg >/dev/null
echo "deb [signed-by=/etc/apt/trusted.gpg.d/koide3_ppa.gpg] https://koide3.github.io/ppa/ubuntu2404 ./
" | sudo tee /etc/apt/sources.list.d/koide3_ppa.list
sudo apt update
```

--------------------------------

### Start Glim Offline Viewer

Source: https://github.com/koide3/glim/blob/master/docs/merge.md

Launches the Glim offline viewer application. Ensure ROS 2 is sourced before running.

```bash
ros2 run glim_ros offline_viewer
```

--------------------------------

### Install GLIM for ROS2 (Ubuntu 22.04)

Source: https://github.com/koide3/glim/blob/master/docs/installation.md

Installs the GLIM ROS2 package for Ubuntu 22.04 (humble), with options for CUDA 12.2, 12.6, or 13.1, or without CUDA.

```bash
# ROS2 humble (Ubuntu 22.04)
sudo apt install -y ros-humble-glim-ros            # Without CUDA
sudo apt install -y ros-humble-glim-ros-cuda12.2   # With CUDA 12.2
sudo apt install -y ros-humble-glim-ros-cuda12.6   # With CUDA 12.6
sudo apt install -y ros-humble-glim-ros-cuda13.1   # With CUDA 13.1
```

--------------------------------

### Install Dialog Manager for Offline Viewer Issues

Source: https://github.com/koide3/glim/wiki/FAQ

The offline viewer's map open dialog may not appear if a dialog manager is not installed. Install either 'zenity' or 'kdialog' to resolve this.

```bash
sudo apt install zenity
```

```bash
sudo apt install kdialog
```

--------------------------------

### Install GLIM for ROS2 (Ubuntu 24.04)

Source: https://github.com/koide3/glim/blob/master/docs/installation.md

Installs the GLIM ROS2 package for Ubuntu 24.04 (jazzy), with options for CUDA 12.6 or 13.1, or without CUDA.

```bash
# ROS2 jazzy (Ubuntu 24.04)
sudo apt install -y ros-jazzy-glim-ros             # Without CUDA
sudo apt install -y ros-jazzy-glim-ros-cuda12.6    # With CUDA 12.6
sudo apt install -y ros-jazzy-glim-ros-cuda13.1    # With CUDA 13.1
```

--------------------------------

### Install Open-Source GLIM Extensions

Source: https://github.com/koide3/glim/blob/master/docs/extensions.md

Clone the glim_ext repository and build it within your ROS2 workspace. Ensure you are in the src directory before cloning.

```bash
cd ~/ros2_ws/src
git clone https://github.com/koide3/glim_ext

cd ~/ros2_ws
colcon build
```

--------------------------------

### Configure Installation Paths for ROS 1

Source: https://github.com/koide3/glim/blob/master/CMakeLists.txt

Sets specific installation directories for include, library, binary, and data files when ROS 1 is detected. This ensures proper integration with the ROS 1 build system.

```cmake
set(CMAKE_INSTALL_INCLUDEDIR "include/glim")
    set(CMAKE_INSTALL_LIBDIR "lib")
    set(CMAKE_INSTALL_BINDIR "bin/glim")
    set(CMAKE_INSTALL_DATADIR "share/glim")
    set(CMAKE_CONFIG_INSTALL_DIR "share/glim")
```

--------------------------------

### GLIM Configuration Parameters

Source: https://github.com/koide3/glim/blob/master/docs/quickstart.md

These JSON snippets show the default sensor and ROS topic parameters for GLIM. Ensure these match your system setup.

```json
glim/config/config.json
  "config_odometry": "config_odometry_gpu.json",
  "config_sub_mapping": "config_sub_mapping_gpu.json",
  "config_global_mapping": "config_global_mapping_gpu.json"
```

```json
glim/config/config_sensors.json
  "T_lidar_imu": [-0.006, 0.012, -0.008, 0, 0, 0, 1]
```

```json
glim/config/config_ros.json
  "imu_topic": "/os_cloud_node/imu",
  "points_topic": "/os_cloud_node/points"
```

--------------------------------

### Configure CMake Config Install Directory

Source: https://github.com/koide3/glim/blob/master/CMakeLists.txt

Sets the installation directory for CMake configuration files when ROS is not defined. This is a standard CMake practice for managing package configuration.

```cmake
include(GNUInstallDirs)
  set(CMAKE_CONFIG_INSTALL_DIR
    "${CMAKE_INSTALL_LIBDIR}/cmake/glim"
    CACHE PATH "Install directory for CMake config files"
  )
```

--------------------------------

### Implement a GLIM Extension Module

Source: https://github.com/koide3/glim/blob/master/docs/extend.md

Define a C++ class that inherits from `glim::ExtensionModule` and implement the `create_extension_module()` function to return an instance of your module. This example shows how to hook into the `on_new_frame` callback.

```cpp
#include <glim/odometry/callbacks.hpp>
#include <glim/util/extension_module.hpp>

using namespace glim;

class MyExtensionModule : public ExtensionModule {
public:
  MyExtensionModule() {
    using std::placeholders::_1;
    OdometryEstimationCallbacks::on_new_frame.add(std::bind(&MyExtensionModule::on_new_frame, this, _1));
  }

  void on_new_frame(const EstimationFrame::ConstPtr& frame) {
    // ...
  }
};

extern "C" ExtensionModule* create_extension_module() {
  return new MyExtensionModule();
}
```

--------------------------------

### Launch glim ROS2 Docker Image with GPU

Source: https://github.com/koide3/glim/blob/master/docs/docker.md

Use this command to pull and run the glim ROS2 Docker image with CUDA support. Ensure you have Docker installed and the NVIDIA Container Toolkit for GPU access. This command mounts a local config directory and enables host networking and IPC.

```bash
docker pull koide3/glim_ros2:humble_cuda12.2

docker run \
  -it \
  --rm \
  --net=host \
  --ipc=host \
  --pid=host \
  --gpus all \
  -e=DISPLAY \
  -e=ROS_DOMAIN_ID \
  -v $(realpath config):/glim/config \
  koide3/glim_ros2:humble_cuda12.2 \
  ros2 run glim_ros glim_rosnode --ros-args -p config_path:=/glim/config
```

--------------------------------

### ROS 1 Integration with catkin

Source: https://github.com/koide3/glim/blob/master/CMakeLists.txt

Configures the project for ROS 1 using catkin. It finds the catkin package, defines package information including include directories and libraries, and installs configuration files.

```cmake
find_package(catkin REQUIRED)
    catkin_package(
      INCLUDE_DIRS include
      LIBRARIES ${glim_LIBRARIES} ${GTSAM_LIBRARIES} fmt spdlog::spdlog
    )
    install(DIRECTORY config DESTINATION ${CATKIN_PACKAGE_SHARE_DESTINATION})
```

--------------------------------

### Update shared library cache

Source: https://github.com/koide3/glim/blob/master/docs/installation.md

Updates the system's shared library cache to make newly installed libraries visible.

```bash
sudo ldconfig
```

--------------------------------

### ROS 2 Integration with ament_cmake

Source: https://github.com/koide3/glim/blob/master/CMakeLists.txt

Configures the project for ROS 2 using ament_cmake. It finds the ament_cmake package, installs configuration files, and exports include directories and libraries.

```cmake
find_package(ament_cmake REQUIRED)
    install(DIRECTORY config DESTINATION share/glim)
    ament_export_include_directories(include ${EIGEN3_INCLUDE_DIR} ${OpenCV_INCLUDE_DIRS})
    ament_export_libraries(${glim_LIBRARIES} ${GTSAM_LIBRARIES} fmt spdlog::spdlog)
    ament_export_targets(glim-targets HAS_LIBRARY_TARGET)
    ament_package(CONFIG_EXTRAS "cmake/glim-config.cmake.in")
```

--------------------------------

### Loading GLIM Configuration with Custom Path

Source: https://github.com/koide3/glim/blob/master/docs/quickstart.md

These commands demonstrate how to load GLIM configuration files from different locations using the `config_path` ROS parameter. Use `realpath` for local configuration files.

```bash
# Load parameters from "glim/config/presets/gpu/config.json"
ros2 run glim_ros glim_rosnode --ros-args -p config_path:=config/presets/gpu
```

```bash
# Load parameters from "/tmp/config/config.json"
ros2 run glim_ros glim_rosnode --ros-args -p config_path:=/tmp/config
```

```bash
# Load parameters from "./config/config.json"
ros2 run glim_ros glim_rosnode --ros-args -p config_path:=$(realpath ./config)
```

--------------------------------

### Build GLIM for ROS2 from source

Source: https://github.com/koide3/glim/blob/master/docs/installation.md

Clones the GLIM and glim_ros2 repositories into the ROS2 workspace src directory, then builds the workspace using colcon.

```bash
cd ~/ros2_ws/src
git clone https://github.com/koide3/glim
git clone https://github.com/koide3/glim_ros2

cd ~/ros2_ws
colcon build
```

--------------------------------

### Build Standard Viewer Library

Source: https://github.com/koide3/glim/blob/master/CMakeLists.txt

This snippet defines and builds the 'standard_viewer' shared library. It includes the necessary source files for the standard viewer and links it against the 'glim' library. This is enabled when BUILD_WITH_VIEWER is true.

```cmake
add_library(standard_viewer SHARED
  src/glim/viewer/standard_viewer.cpp
  src/glim/viewer/standard_viewer_ui.cpp
  src/glim/viewer/standard_viewer_callbacks.cpp
  src/glim/viewer/standard_viewer_mem.cpp
)
target_link_libraries(standard_viewer
  glim
)
```

--------------------------------

### ROS2 Command to Run glim_rosnode

Source: https://github.com/koide3/glim/blob/master/docs/quickstart.md

Launches GLIM as a standard ROS node. Ensure you have played the ROS bag file and launched RViz2 for visualization.

```bash
ros2 run glim_ros glim_rosnode
```

```bash
ros2 bag play os1_128_01
```

```bash
rviz2 -d glim_ros2/rviz/glim_ros.rviz
```

--------------------------------

### Build GLIM for ROS2 from source with CMake options

Source: https://github.com/koide3/glim/blob/master/docs/installation.md

Builds the GLIM ROS2 package from source using colcon, with specific CMake arguments to enable CUDA, the viewer, and disable native march optimization.

```bash
# cmake options
# colcon build --cmake-args \
#   -DBUILD_WITH_CUDA=ON \
#   -DBUILD_WITH_VIEWER=ON \
#   -DBUILD_WITH_MARCH_NATIVE=OFF
```

--------------------------------

### Run GLIM with Kinect Sensor

Source: https://github.com/koide3/glim/blob/master/docs/demo.md

Launches the GLIM ROS 2 node for mapping using a Kinect sensor. Ensure the configuration path is correctly set to your Kinect configuration files.

```bash
ros2 run glim_ros glim_rosbag --ros-args -p config_path:=$(realpath config/kinect) kinect
```

--------------------------------

### Configure GLIM Extension Modules for IMU Validation

Source: https://github.com/koide3/glim/wiki/FAQ

To enable the IMU validator module for calibration checks, build the 'glim_ext' library and add 'libimu_validator.so' to the 'glim_ros/extension_modules' list in your configuration file.

```json
"libimu_validator.so"
```

--------------------------------

### Build glim ROS2 Docker Image from Source (With GPU)

Source: https://github.com/koide3/glim/blob/master/docs/docker.md

Builds the glim ROS2 Docker image using a GCC-based Dockerfile with CUDA support. This requires specifying a CUDA-enabled base image and the ROS distribution. The build process clones the glim and glim_ros2 repositories.

```bash
docker build \
  -f glim_ros2/docker/Dockerfile.gcc.cuda \
  --build-arg="BASE_IMAGE=koide3/gtsam_points:jammy_cuda12.2" \
  --build-arg="ROS_DISTRO=humble" \
  --tag glim_ros2:humble_cuda12.2 \
  .
```

--------------------------------

### ROS2 Command to Run glim_rosbag

Source: https://github.com/koide3/glim/blob/master/docs/quickstart.md

Launches GLIM to read data directly from a rosbag file, optimizing playback speed for mapping.

```bash
ros2 run glim_ros glim_rosbag os1_128_01
```

--------------------------------

### CMakeLists.txt for Extension Module

Source: https://github.com/koide3/glim/blob/master/docs/extend.md

Configure your CMake build to create a shared library for your extension module, linking against the GLIM library. Ensure C++17 standard is used.

```cmake
cmake_minimum_required(VERSION 3.5.2)
project(my_extension_module)

set(CMAKE_CXX_STANDARD 17)

find_package(glim REQUIRED)

add_library(my_extension_module SHARED
  src/my_extension_module.cpp
)
target_link_libraries(my_extension_module
  glim::glim
)
```

--------------------------------

### Build glim ROS2 Docker Image from Source (Without GPU)

Source: https://github.com/koide3/glim/blob/master/docs/docker.md

Builds the glim ROS2 Docker image using a GCC-based Dockerfile without CUDA support. This process involves cloning the necessary repositories and specifying the base image and ROS distribution.

```bash
mkdir /tmp/glim_docker && cd /tmp/glim_docker
git clone git@github.com:koide3/glim
git clone git@github.com:koide3/glim_ros2

docker build \
  -f glim_ros2/docker/Dockerfile.gcc \
  --build-arg="BASE_IMAGE=koide3/gtsam_points:jammy" \
  --build-arg="ROS_DISTRO=humble" \
  --tag glim_ros2:humble \
  .
```

--------------------------------

### Build Interactive Viewer Library

Source: https://github.com/koide3/glim/blob/master/CMakeLists.txt

This snippet defines and builds the 'interactive_viewer' shared library. It includes source files for interactive viewer functionalities and links against the 'glim' library. This is enabled when BUILD_WITH_VIEWER is true.

```cmake
add_library(interactive_viewer SHARED
  src/glim/viewer/interactive_viewer.cpp
  src/glim/viewer/interactive/manual_loop_close_modal.cpp
  src/glim/viewer/interactive/bundle_adjustment_modal.cpp
  src/glim/viewer/offline_viewer.cpp
)
target_link_libraries(interactive_viewer
  glim
)
```

--------------------------------

### Build Shared Libraries for Estimation Modules

Source: https://github.com/koide3/glim/blob/master/CMakeLists.txt

This snippet iterates through a list of source files to create shared libraries for estimation modules. It dynamically generates library names based on source filenames and links them against the 'glim' library. Conditional inclusion of GPU estimation is handled based on the BUILD_WITH_CUDA flag.

```cmake
list(APPEND module_srcs
  src/glim/odometry/odometry_estimation_ct_create.cpp
  src/glim/odometry/odometry_estimation_cpu_create.cpp
  src/glim/mapping/sub_mapping_create.cpp
  src/glim/mapping/sub_mapping_passthrough_create.cpp
  src/glim/mapping/global_mapping_create.cpp
  src/glim/mapping/global_mapping_pose_graph_create.cpp
)
if(BUILD_WITH_CUDA)
  list(APPEND module_srcs
    src/glim/odometry/odometry_estimation_gpu_create.cpp
  )
endif()

foreach(module_src IN LISTS module_srcs)
  get_filename_component(module_src_filename ${module_src} NAME_WE)
  string(REGEX REPLACE "_create" "" module_name ${module_src_filename})

  add_library(${module_name} SHARED
    ${module_src}
  )
  target_link_libraries(${module_name}
    glim
  )
  list(APPEND glim_LIBRARIES ${module_name})
endforeach()
```

--------------------------------

### Launch glim ROS2 Docker Image without GPU

Source: https://github.com/koide3/glim/blob/master/docs/docker.md

This command pulls and runs the glim ROS2 Docker image without GPU support. It requires modifying the configuration file to use CPU-specific settings before launching. Similar to the GPU version, it mounts local configurations and uses host networking.

```bash
docker pull koide3/glim_ros2:humble

docker run \
  -it \
  --rm \
  --net=host \
  --ipc=host \
  --pid=host \
  --gpus all \
  -e=DISPLAY \
  -e=ROS_DOMAIN_ID \
  -v $(realpath config):/glim/config \
  koide3/glim_ros2:humble \
  ros2 run glim_ros glim_rosnode --ros-args -p config_path:=/glim/config
```

--------------------------------

### Register Callback for New Frame Event

Source: https://github.com/koide3/glim/blob/master/docs/extend.md

Shows how to register a callback function to the on_new_frame event in GLIM's odometry estimation to retrieve sensor states.

```cpp
#include <glim/odometry/callback.hpp>

using namespace glim;

void on_new_frame(const EstimationFrame::ConstPtr& new_frame) {
  const long id = new_frame->id;                                    // Frame ID
  const double stamp = new_frame->stamp;                            // Timestamp
  const Eigen::Isometry3d& T_world_imu = new_frame->T_world_imu;    // IMU pose
}

void setup_callback() {
  using std::placeholders::_1;
  OdometryEstimationCallback::on_new_frame.add(std::bind(&on_new_frame, _1));
}
```

--------------------------------

### Build Map Editor Library

Source: https://github.com/koide3/glim/blob/master/CMakeLists.txt

This snippet defines and builds the 'map_editor' shared library. It includes source files related to map editing functionalities and links against the 'glim' library. This is enabled when BUILD_WITH_VIEWER is true.

```cmake
add_library(map_editor SHARED
  src/glim/viewer/editor/map_cell.cpp
  src/glim/viewer/editor/points_selector.cpp
  src/glim/viewer/map_editor.cpp
)
target_link_libraries(map_editor
  glim
)
```

--------------------------------

### Append Libraries to glim_LIBRARIES

Source: https://github.com/koide3/glim/blob/master/CMakeLists.txt

Appends several libraries, including the newly defined 'memory_monitor', to the 'glim_LIBRARIES' list. This aggregates all necessary libraries for the main project.

```cmake
list(APPEND glim_LIBRARIES standard_viewer interactive_viewer memory_monitor map_editor)
```

--------------------------------

### Manually Provide Initial Gravity Alignment

Source: https://github.com/koide3/glim/wiki/FAQ

If the created map is tilted due to issues with initial gravity direction estimation, you can manually specify the initial gravity-aligned sensor pose using 'odometry_estimation/init_T_world_imu' in your configuration file.

```json
"odometry_estimation/init_T_world_imu"
```

--------------------------------

### Disable GLIM Viewer

Source: https://github.com/koide3/glim/wiki/FAQ

To launch GLIM without a graphical user interface, remove the 'libstandard_viewer.so' entry from your 'config_ros.json' file.

```json
"libstandard_viewer.so"
```

--------------------------------

### Define memory_monitor Library

Source: https://github.com/koide3/glim/blob/master/CMakeLists.txt

Defines the memory_monitor library as a SHARED library and links it against the glim library. This is typically used for modular code organization.

```cmake
add_library(memory_monitor SHARED
    src/glim/viewer/memory_monitor.cpp
  )
  target_link_libraries(memory_monitor
    glim
  )
```

--------------------------------

### Insert Pose Variable into GTSAM Values

Source: https://github.com/koide3/glim/blob/master/docs/extend.md

Demonstrates how to insert a pose variable into a gtsam::Values object using the gtsam::Symbol shorthand.

```cpp
using gtsam::symbol_shorthand::X;

int id = 0;
gtsam::Pose3 pose;

gtsam::Values values;
values.insert(X(id), pose);
```

--------------------------------

### Reload ROS Paths for Module Loading Errors

Source: https://github.com/koide3/glim/wiki/FAQ

When encountering 'failed to load module' errors, ensure your ROS environment is correctly sourced. If the library path is not set, you may need to re-install ROS and its packages.

```bash
source ros2_ws/install/setup.bash
```

```bash
echo $LD_LIBRARY_PATH
```

--------------------------------

### Fatal Error for Unsupported ROS Version

Source: https://github.com/koide3/glim/blob/master/CMakeLists.txt

Generates a fatal error message if an unsupported ROS version is detected. This prevents the build process from continuing with an incompatible configuration.

```cmake
message(FATAL_ERROR "Unsupported ROS version")
```

--------------------------------

### Override CMAKE_CUDA_ARCHITECTURES for CUDA Runtime Errors

Source: https://github.com/koide3/glim/wiki/FAQ

If your CUDA driver version is insufficient for the CUDA runtime version, you may need to override the CMAKE_CUDA_ARCHITECTURES during the CMake configuration. Consult the provided link for GPU compute capability matching.

```bash
cmake .. -DBUILD_WITH_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES=87
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.