Core Dependencies for lingbot-map: Complete Installation Guide

The lingbot-map repository requires Python ≥3.8, PyTorch, Open3D, NumPy, SciPy, and CMake ≥3.18 with pybind11 for its optional CUDA extensions, as declared in pyproject.toml and demo_render/render_cuda_ext/setup.py.

The lingbot-map repository is a Python-based visual-SLAM and mapping toolkit that builds on a small set of well-maintained third-party libraries. Understanding the core dependencies for lingbot-map is essential for successfully running the mapping pipeline, benchmark suite, and optional GPU-accelerated rendering extensions on Linux-based development environments.

Runtime Dependencies in pyproject.toml

The primary runtime requirements are declared in the root pyproject.toml file. These packages constitute the minimal stack required to execute the core mapping algorithms and visualization tools.

• Python ≥3.8: The baseline runtime language for the entire toolkit.
• PyTorch: Provides tensor operations and GPU-accelerated neural-network components for depth estimation tasks.
• Open3D: Handles 3-D point-cloud processing, mesh construction, and visualization utilities throughout the codebase.
• NumPy: Supplies fundamental array mathematics used in geometric transformations and data structures.
• SciPy: Offers linear-algebra utilities and optimizations for registration algorithms and pose-graph solvers.
• tqdm: Renders progress-bar feedback for long-running loops in benchmark runs and dataset processing.
• Matplotlib: Enables plotting of metrics and visual debugging of maps and trajectories.
• Pillow: Manages image loading and conversion for the demo rendering pipeline.
• PyYAML: Parses configuration files located under demo_render/config/.
• Click: Powers the command-line interface for benchmark utilities in benchmark/run.py and benchmark/evaluate.py.
• imageio: Handles reading and writing of video frames used by the RGB-D demo renderer.

Build Tools for CUDA Extensions

Optional GPU acceleration requires compiling native extensions located in demo_render/render_cuda_ext/. The build system relies on additional tooling specified in demo_render/render_cuda_ext/setup.py.

• CMake ≥3.18: Required to configure the build system for the CUDA extensions.
• pybind11: Provides the Python bindings for C++ CUDA kernels such as voxel_morton, enabling fast Morton encoding on the GPU from Python code.

Installing the Dependency Stack

To install the core dependencies for lingbot-map, clone the repository and use pip with the provided configuration files.

First, install the primary runtime packages:

pip install torch open3d numpy scipy tqdm matplotlib pillow pyyaml click imageio

Then, install the package itself along with any remaining requirements:

pip install .

For the optional CUDA extensions, ensure CMake ≥3.18 is installed on your system, then build the extensions:

cd demo_render/render_cuda_ext
python setup.py build_ext --inplace

Additional runtime packages specific to the demo rendering pipeline are listed in demo_render/requirements.txt and can be installed via:

pip install -r demo_render/requirements.txt

Dependency Usage Examples

The following examples demonstrate how lingbot-map leverages its core dependencies in practice.

Basic Mapping with Open3D and PyTorch

This example shows the integration of Open3D for geometry handling and PyTorch for internal tensor operations when building a map from an RGB-D sequence using the Mapping class defined in lingbot_map/__init__.py:

import lingbot_map as lm
import open3d as o3d
import numpy as np

# Load an example RGB-D dataset (the repository ships a few PNG sequences)

rgb = o3d.io.read_image("example/university/000320.png")
depth = o3d.io.read_image("example/university/000321.png")
rgbd = o3d.geometry.RGBDImage.create_from_color_and_depth(rgb, depth)

# Initialise the mapper (uses PyTorch tensors internally)

mapper = lm.Mapping()
mapper.integrate(rgbd)

# Retrieve the current point cloud

pcd = mapper.get_point_cloud()
o3d.visualization.draw_geometries([pcd])

CLI Benchmark Utilities

The benchmark suite relies on Click for its command-line interface, as implemented in benchmark/run.py:

# CLI entry point provided by Click in `benchmark/run.py`

python -m benchmark.run --config demo_render/config/indoor.yaml --output results/

CUDA Extension with pybind11

For GPU-accelerated voxel operations, the repository uses pybind11-bound CUDA kernels. This requires the build tools mentioned above:

from render_cuda_ext.voxel_morton import voxel_hash
import torch

coords = torch.randint(0, 256, (1000, 3), dtype=torch.int32, device='cuda')
hashes = voxel_hash(coords)      # Fast Morton encoding on the GPU

print(hashes[:10])

Summary

• The core dependencies for lingbot-map are declared in pyproject.toml and include PyTorch, Open3D, NumPy, and SciPy for the computational pipeline.
• Python ≥3.8 is the minimum required version for running the toolkit.
• Optional GPU acceleration requires CMake ≥3.18 and pybind11 to compile the CUDA extensions in demo_render/render_cuda_ext/.
• Utility dependencies such as Click, tqdm, and Matplotlib support the benchmarking and visualization workflows.
• Install the full stack using pip install . followed by manual compilation of CUDA extensions if GPU support is needed.

Frequently Asked Questions

What is the minimum Python version required for lingbot-map?

The repository requires Python ≥3.8 as the baseline runtime language, as specified in the pyproject.toml file. This ensures compatibility with the type hints and async features used throughout the codebase.

Do I need CUDA to run lingbot-map?

No, CUDA is optional. The core mapping pipeline runs entirely on CPU using PyTorch and NumPy. However, if you want to use the GPU-accelerated voxel operations (such as the voxel_morton kernel), you must compile the CUDA extensions using CMake ≥3.18 and pybind11 as defined in demo_render/render_cuda_ext/setup.py.

Where are the core dependencies declared?

The primary runtime dependencies are listed in the root pyproject.toml file. Additional packages specific to the demo rendering pipeline are cataloged in demo_render/requirements.txt, while build dependencies for the CUDA extensions are specified in demo_render/render_cuda_ext/setup.py.

How do I install the optional CUDA extensions?

First ensure CMake ≥3.18 is installed on your Linux system. Then navigate to demo_render/render_cuda_ext/ and run python setup.py build_ext --inplace to compile the pybind11-bound kernels. This enables the render_cuda_ext module imports used for fast Morton encoding on the GPU.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}