# RapidKinematics

**Repository Path**: rapid-robotics/rapid-kinematics

## Basic Information

- **Project Name**: RapidKinematics
- **Description**: 一款基于 pinocchio 的运动学算法库，实现了 urdf导入、fk、ik等运动学常用的算法
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: main
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-03-22
- **Last Updated**: 2026-03-22

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# RapidKinematics

RapidKinematics is a C++17 dual-arm robot kinematics library built around Pinocchio. The current implementation baseline targets the robot model in hc_tj_robot.urdf and focuses on a low-coupling architecture that can grow toward collision checking, dynamics-constrained planning, real-time leg control, and closed-chain dual-arm cooperative grasping.

## Goals

- Load the robot model from URDF.
- Provide right arm, left arm, and dual-arm planning groups.
- Support forward kinematics, inverse kinematics, MoveJ, MoveL, and trajectory interpolation.
- Keep Python and C# bindings in scope through binding-friendly APIs.
- Isolate logging, scene, constraints, and control boundaries so later extensions do not force a redesign.

## Current Scope

This first implementation stage provides:

- Project structure and build system.
- Public data types and status model.
- Default planning groups for the current dual-arm robot.
- Logging abstraction backed by spdlog.
- Interfaces for kinematics, motion planning, collision, dynamics, whole-body control, and bindings.

The following capabilities are reserved by interface but not fully implemented yet:

- Pinocchio-based FK and IK execution.
- Collision checking backend integration.
- Dynamics-constrained planning.
- Real-time leg control.
- Closed-chain dual-arm cooperative grasping.

## Build Dependencies

- CMake 3.16 or newer
- C++17 compiler
- Eigen3
- spdlog
- Pinocchio for full kinematics implementation
- pybind11 when Python bindings are enabled

## Quick Start

Configure the project:

```bash
cmake -S . -B build
cmake --build build
```

Use public headers directly from the include root:

```cpp
#include "core/robot_description.hpp"
#include "kinematics/forward_kinematics_impl.hpp"
#include "kinematics/numerical_ik_solver.hpp"
```

The `include` directory is laid out as:

- `include/core`
- `include/kinematics`
- `include/motion`
- `include/trajectory`
- `include/collision`
- `include/constraints`
- `include/control`
- `include/coordination`
- `include/dynamics`
- `include/facade`
- `include/c_api`

Build Python bindings when ready:

```bash
cmake -S . -B build -DRTK_BUILD_PYTHON_BINDINGS=ON
cmake --build build
```

## Planning Groups

The default groups are derived from the current URDF model:

- right_arm: Joint1_R to Joint7_R, tip flange_R_Link
- left_arm: Joint1_L to Joint7_L, tip flange_L_Link
- dual_arm: right arm plus left arm
- torso_right_arm and torso_left_arm: reserved extension groups that include zhi

## Documentation

- See docs/architecture.md for module boundaries and extension points.
- See docs/roadmap.md for phased delivery targets.
- The C API public header is `include/c_api/rk_c_api.h`.

## Status

The repository now contains the initial implementation skeleton. The next implementation stage is to complete RobotDescription loading through Pinocchio and then fill in FK, IK, MoveJ, and MoveL execution.