SDK Overview

The PathVynt SDK

Four production-ready modules. One drop-in integration. C++17, ROS 2, Python bindings included.

PathVynt sensor fusion pipeline architecture: LiDAR and camera inputs flowing through alignment, fusion, and path planning modules

C++ Header-Only Core

Zero runtime dependencies beyond Eigen and PCL. Integrate with a single #include directive in your CMake project.

ROS 2 Wrapper

Full ROS 2 node wrappers for all four modules. Subscribes to standard sensor_msgs and publishes nav_msgs-compatible outputs.

Python Bindings

pybind11-based Python API for rapid prototyping and offline evaluation on recorded data bags.

Module 01

LiDAR-Camera Fusion

Extrinsic calibration is done once during deployment setup, but real environments introduce runtime drift — vibration, thermal expansion, mechanical loosening. PathVynt's fusion engine tracks and corrects for this drift continuously without requiring a calibration target.

Temporal alignment between LiDAR (typically 10Hz) and camera (30Hz) streams is handled via interpolation with configurable latency tolerance. The Kalman filter output includes per-voxel uncertainty estimates.

Runtime extrinsic drift correction — no re-calibration downtime
Temporal alignment with configurable latency tolerance
Per-voxel uncertainty estimates in fused output
Supports Velodyne, Ouster, Hesai, Intel RealSense, ZED 2

Dynamic occupancy grid visualization showing path planning trajectories overlaid on a dark top-down environment map

Module 02

Obstacle Prediction Engine

Risk-scored trajectory forecasts at 20Hz. The predictor runs CVTR (Constant Velocity Turn Rate) for wheeled agents and a social force approximation for pedestrians, outputting a discrete probability distribution over future poses at t+0.5s, t+1.0s, t+2.0s horizons.

ObstaclePredictorConfig cfg;
cfg.set_update_rate_hz(20);
cfg.set_horizon_s({0.5, 1.0, 2.0});
cfg.set_model(PredictorModel::CVTR_SOCIAL_BLEND);
cfg.set_risk_threshold(0.75f);
ObstaclePredictor predictor(cfg);

Module 03

Occupancy Grid Engine

Configurable resolution from 2cm (precision indoor) to 25cm (highway-scale outdoor). Memory budget is configurable — set your footprint constraint and the grid manager adapts resolution and update rate accordingly.

OccupancyGridConfig grid_cfg;
grid_cfg.set_resolution_cm(5);          // 5cm cells
grid_cfg.set_memory_budget_mb(256);     // hard cap
grid_cfg.set_dynamic_update_hz(30);     // update rate
grid_cfg.set_rolling_window_m(80.0f);   // 80m radius
OccupancyGridEngine grid(grid_cfg);

2cm resolution

Precision indoor — detailed obstacle contours, forklift leg detection, narrow-gap traversal.

25cm resolution

Outdoor highway-scale — 80m radius rolling window, reduced compute for high-speed environments.

Module 04

Lane-Level Localization

Map-relative localization using LiDAR scan feature extraction and keyframe matching. Maintains lane-level accuracy (<15cm lateral) in GPS-denied environments — underground parking, dense urban corridors, RF-shielded facilities.

Feature persistence under 70% occlusion
Dynamic reference updates for changing environments
Particle filter update at 10Hz without full scan re-matching
Compatible with Open HD maps and custom map formats
Graceful degradation with confidence output when features are sparse

Integration

Drop-in. Seriously.

Install via apt or download the tarball. Three integration paths — choose what fits your stack.

# Ubuntu 22.04 / Jetson L4T 36+ (apt)
$ curl -fsSL https://packages.pathvynt.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/pathvynt.gpg
$ echo "deb [signed-by=/usr/share/keyrings/pathvynt.gpg] https://packages.pathvynt.com stable main" | sudo tee /etc/apt/sources.list.d/pathvynt.list
$ sudo apt update && sudo apt install libpathvynt-dev pathvynt-ros2
# Or pull the SDK tarball directly from your account dashboard

// CMakeLists.txt
find_package(pathvynt 1.4 REQUIRED)
target_link_libraries(my_robot pathvynt::fusion pathvynt::prediction)

// main.cpp
#include <pathvynt/pipeline.hpp>

FusionPipeline::Config cfg;
cfg.set_lidar_topic("/velodyne/points");
cfg.set_camera_topic("/camera/image_raw");
cfg.set_fusion_hz(20);

FusionPipeline pipeline(cfg);
pipeline.start();

while (ok()) {
  auto frame = pipeline.next_frame();
  // frame.fused_cloud, frame.obstacles, frame.pose ...
  process(frame);
}

# ros2_launch/pathvynt.launch.py
from pathvynt_ros2 import FusionLaunch, PredictionLaunch

def generate_launch_description():
    fusion = FusionLaunch(
        lidar_topic="/ouster/points",
        camera_topic="/zed/image_raw",
        hz=20
    )
    prediction = PredictionLaunch(
        input_topic="/pathvynt/fused",
        hz=20
    )
    return LaunchDescription([fusion, prediction])

import pathvynt

cfg = pathvynt.FusionConfig(
    lidar_topic="/velodyne/points",
    camera_topic="/camera/image_raw",
    hz=20
)
pipeline = pathvynt.FusionPipeline(cfg)
pipeline.start()

for frame in pipeline.frames():
    # frame.fused_cloud: Open3D PointCloud
    # frame.obstacles: list[ObstacleState]
    # frame.pose: SE3
    process(frame)

Jetson AGX Orin

64-core Ampere GPU + 12-core Cortex-A78AE. 32GB unified memory. Typical configuration: 5cm occupancy grid, 80m radius, 20Hz fusion.

<18ms fusion latency at full config

Jetson Orin NX 16

1024-core GPU + 6-core Cortex-A78AE. 16GB unified memory. Typical: 10cm grid, 40m radius, 15Hz fusion with prediction disabled or at 10Hz.

<28ms fusion latency at recommended config

x86_64 Linux

Ubuntu 20.04/22.04 with CUDA 11.8+. Development workstation, data bag playback, CI pipeline. Not recommended as primary production compute without GPU.

Full-speed dev & evaluation environment

Ready to integrate?

Request SDK access or read the quickstart guide to estimate your integration effort.

PathVynt is a perception and navigation software library. We do not sell hardware, simulation environments, HD maps, or complete robot platforms — only the SDK that runs on your hardware with your maps.

Request SDK Access Read the Docs