Initial commit

Author: TillBeemelmanns

.github/workflows/publish.yml

@@ -0,0 +1,35 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - 'v*'  # Trigger on version tags like v0.0.1
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.9'
+    
+    - name: Install build dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build twine
+    
+    - name: Build package
+      run: python -m build
+    
+    - name: Check package
+      run: twine check dist/*
+    
+    - name: Publish to PyPI
+      env:
+        TWINE_USERNAME: __token__
+        TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
+      run: twine upload dist/*

.gitignore

@@ -0,0 +1,78 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+.pytest_cache/
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/

.vscode/launch.json

@@ -0,0 +1,12 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Debug: ros2_calib",
+            "type": "python",
+            "request": "launch",
+            "module": "ros2_calib.main",
+            "justMyCode": true
+        }
+    ]
+}

CLAUDE.md

@@ -0,0 +1,81 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is a manual LiDAR-Camera calibration tool for ROS 2 that provides a graphical interface for performing extrinsic calibration between LiDAR sensors and cameras. The application is built with PySide6 and operates on recorded rosbag data (.mcap files) without requiring a live ROS 2 environment.
+
+## Development Commands
+
+### Installation and Setup
+```bash
+# Install the project in development mode
+python -m pip install .
+```
+
+### Running the Application
+```bash
+# Run the calibration tool
+ros2_calib
+```
+
+### Code Quality
+```bash
+# Run linter (configured in pyproject.toml)
+ruff check
+
+# Format code
+ruff format
+```
+
+## Architecture Overview
+
+The application follows a modular GUI-based architecture:
+
+**Core Workflow:**
+1. User loads a rosbag file (.mcap format)
+2. Application displays available topics for selection
+3. User selects image, point cloud, and camera info topics
+4. Interactive calibration view allows manual 2D-3D correspondences
+5. RANSAC-based PnP solver provides initial estimate
+6. Scipy least-squares optimization refines the transformation
+
+**Key Components:**
+
+- **main.py**: Application entry point with PySide6 QApplication setup
+- **main_window.py**: Primary GUI window handling rosbag loading and topic selection
+- **calibration_widget.py**: Interactive widget for 2D/3D point selection and visualization
+- **calibration.py**: Core mathematical calibration logic using OpenCV and Scipy
+- **bag_handler.py**: Rosbag file processing and message extraction utilities
+- **ros_utils.py**: Mock ROS 2 message dataclasses (PointCloud2, Image, CameraInfo) and conversion utilities
+
+**Key Components (Continued):**
+
+- **transformation_widget.py**: Node graph visualization for TF trees using NodeGraphQt
+- **lidar_cleaner.py**: Point cloud processing based on RePLAy ECCV 2024 paper for removing occluded points
+- **tf_transformations.py**: Transform utilities for coordinate frame conversions
+
+**Application Flow:** The main application uses a QStackedWidget to manage multiple views:
+1. Initial view for rosbag loading and topic selection (main_window.py)  
+2. Interactive calibration view with 2D/3D visualization (calibration_widget.py)
+3. Transform tree visualization and management (transformation_widget.py)
+
+**Dependencies:** The project uses `rosbags` library for ROS bag processing, avoiding dependency on live ROS 2 installation. All ROS message types are mocked as dataclasses in `ros_utils.py`. NodeGraphQt provides the graph visualization for TF trees.
+
+**Calibration Algorithm:** Two-stage approach using OpenCV's `solvePnPRansac` for robust initial pose estimation followed by Scipy's `least_squares` optimization for refinement. The objective function minimizes reprojection error between 3D LiDAR points and 2D image correspondences. Point cloud cleaning uses algorithms from the RePLAy paper to remove occluded points.
+
+## Configuration
+
+- **Linting**: Configured in `pyproject.toml` with ruff (line length: 100, select: E, F, W, I)
+- **Entry Point**: Defined in `pyproject.toml` as `ros2_calib = "ros2_calib.main:main"`
+- **Dependencies**: PySide6, rosbags, numpy, opencv-python-headless, scipy, ruff, NodeGraphQt, transforms3d, setuptools
+
+## Development Notes
+
+- The application is designed to work offline with recorded rosbag data
+- GUI framework: PySide6 for cross-platform compatibility  
+- No test suite is currently present in the codebase
+- Code uses modern Python with type hints and dataclasses
+- The LiDAR cleaning implementation is based on the RePLAy ECCV 2024 paper for removing projective artifacts
+- Transform visualization uses NodeGraphQt for interactive graph-based TF tree management

GEMINI.md

@@ -0,0 +1,51 @@
+# Gemini Code Assistant Context
+
+This file provides context for the Gemini code assistant to understand the project structure, purpose, and conventions.
+
+## Project Overview
+
+This project is a graphical tool for performing manual extrinsic calibration between a LiDAR sensor and a camera for ROS 2. It is a standalone Python application that uses PySide6 for its user interface.
+
+The tool's workflow is as follows:
+1.  The user loads a rosbag (`.mcap` file).
+2.  The application reads the bag and displays the available topics.
+3.  The user selects the appropriate topics for the image, point cloud, and camera information.
+4.  The application then proceeds to a calibration view where the user can manually create 2D-3D correspondences between the image and the point cloud.
+5.  The core calibration logic uses these correspondences to calculate the rigid transformation (rotation and translation) between the camera and LiDAR frames. It employs OpenCV's RANSAC-based PnP solver for a robust initial estimate and Scipy's least-squares optimization for refinement.
+
+The project is structured to be independent of a live ROS 2 environment for its core functionality, instead relying on the `rosbags` library to process recorded data. It uses dataclasses to mock the necessary ROS 2 message structures.
+
+## Key Files
+
+-   `pyproject.toml`: Defines the project metadata, dependencies (`PySide6`, `rosbags`, `numpy`, `opencv-python-headless`, `scipy`), and the main entry point script.
+-   `ros2_calib/main.py`: The main entry point for the application.
+-   `ros2_calib/main_window.py`: Implements the main GUI window, handling rosbag loading and topic selection.
+-   `ros2_calib/calibration_widget.py`: (Inferred) The widget that handles the interactive 2D/3D point selection and visualization for the calibration process.
+-   `ros2_calib/calibration.py`: Contains the core mathematical logic for performing the calibration using OpenCV and Scipy.
+-   `ros2_calib/bag_handler.py`: Provides functions for reading topic information and messages from rosbag files.
+-   `ros2_calib/ros_utils.py`: Defines mock dataclasses for ROS 2 message types (`PointCloud2`, `Image`, `CameraInfo`) and includes utility functions for converting message data into NumPy arrays.
+
+## Building and Running
+
+### Installation
+
+To install the project and its dependencies, run the following command from the project root directory:
+
+```bash
+python -m pip install .
+```
+
+### Running the Application
+
+Once installed, the application can be run using the command defined in `pyproject.toml`:
+
+```bash
+ros2_calib
+```
+
+## Development Conventions
+
+-   **GUI:** The user interface is built with PySide6.
+-   **ROS 2 Data:** The application interacts with ROS 2 data via `.mcap` rosbag files. It does not require a running ROS 2 daemon.
+-   **Calibration Logic:** The calibration algorithm is implemented in the `calibrate` function in `ros2_calib/calibration.py`. It uses a robust RANSAC approach followed by a least-squares refinement.
+-   **Code Style:** The code is written in modern Python, using type hints and dataclasses. There is no specific linter configuration file present.

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Institute for Automotive Engineering (ika), RWTH Aachen University
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include LICENSE
+include CLAUDE.md
+recursive-include assets *.png *.jpg *.jpeg