Production-ready trajectory planning and interpolation for robotics, animation, and scientific computing.
InterpolatePy provides 20+ algorithms for smooth trajectory generation with precise control over position, velocity, acceleration, and jerk. From cubic splines and B-curves to quaternion interpolation and S-curve motion profiles — everything you need for professional motion control.
⚡ Fast: Vectorized NumPy operations, ~1ms for 1000-point cubic splines
🎯 Precise: Research-grade algorithms with C² continuity and bounded derivatives
📊 Visual: Built-in plotting for every algorithm
🔧 Complete: Splines, motion profiles, quaternions, and path planning in one library
pip install InterpolatePyRequirements: Python ≥3.10, NumPy ≥2.0, SciPy ≥1.15, Matplotlib ≥3.10
Development Installation
git clone https://github.com/GiorgioMedico/InterpolatePy.git
cd InterpolatePy
pip install -e '.[all]' # Includes testing and development toolsimport numpy as np
import matplotlib.pyplot as plt
from interpolatepy import CubicSpline, DoubleSTrajectory, StateParams, TrajectoryBounds
# Smooth spline through waypoints
t_points = [0.0, 5.0, 10.0, 15.0]
q_points = [0.0, 2.0, -1.0, 3.0]
spline = CubicSpline(t_points, q_points, v0=0.0, vn=0.0)
# Evaluate at any time
position = spline.evaluate(7.5)
velocity = spline.evaluate_velocity(7.5)
acceleration = spline.evaluate_acceleration(7.5)
# Built-in visualization
spline.plot()
# S-curve motion profile (jerk-limited)
state = StateParams(q_0=0.0, q_1=10.0, v_0=0.0, v_1=0.0)
bounds = TrajectoryBounds(v_bound=5.0, a_bound=10.0, j_bound=30.0)
trajectory = DoubleSTrajectory(state, bounds)
print(f"Duration: {trajectory.get_duration():.2f}s")
# Manual plotting (DoubleSTrajectory doesn't have built-in plot method)
t_eval = np.linspace(0, trajectory.get_duration(), 100)
results = [trajectory.evaluate(t) for t in t_eval]
positions = [r[0] for r in results]
velocities = [r[1] for r in results]
plt.figure(figsize=(10, 6))
plt.subplot(2, 1, 1)
plt.plot(t_eval, positions)
plt.ylabel('Position')
plt.title('S-Curve Trajectory')
plt.subplot(2, 1, 2)
plt.plot(t_eval, velocities)
plt.ylabel('Velocity')
plt.xlabel('Time')
plt.show()| Category | Algorithms | Key Features | Use Cases |
|---|---|---|---|
| 🔵 Splines | Cubic, B-Spline, Smoothing | C² continuity, noise-robust | Waypoint interpolation, curve fitting |
| ⚡ Motion Profiles | S-curves, Trapezoidal, Polynomial | Bounded derivatives, time-optimal | Industrial automation, robotics |
| 🔄 Quaternions | SLERP, SQUAD, Splines | Smooth rotations, no gimbal lock | 3D orientation control, animation |
| 🎯 Path Planning | Linear, Circular, Frenet frames | Geometric primitives, tool orientation | Path following, machining |
📚 Complete Algorithms Reference →
Detailed technical documentation, mathematical foundations, and implementation details for all 22 algorithms
Complete Algorithm List
CubicSpline– Natural cubic splines with boundary conditionsCubicSmoothingSpline– Noise-robust splines with smoothing parameterCubicSplineWithAcceleration1/2– Bounded acceleration constraintsBSpline– General B-spline curves with configurable degreeApproximationBSpline,CubicBSpline,InterpolationBSpline,SmoothingCubicBSpline
DoubleSTrajectory– S-curve profiles with bounded jerkTrapezoidalTrajectory– Classic trapezoidal velocity profilesPolynomialTrajectory– 3rd, 5th, 7th order polynomialsLinearPolyParabolicTrajectory– Linear segments with parabolic blends
Quaternion– Core quaternion operations with SLERPQuaternionSpline– C²-continuous rotation trajectoriesSquadC2– Enhanced SQUAD with zero-clamped boundariesLogQuaternion– Logarithmic quaternion methods
SimpleLinearPath,SimpleCircularPath– 3D geometric primitivesFrenetFrame– Frenet-Serret frame computation along curvesLinearInterpolation– Basic linear interpolationTridiagonalInverse– Efficient tridiagonal system solver
Quaternion Rotation Interpolation
import matplotlib.pyplot as plt
from interpolatepy import QuaternionSpline, Quaternion
# Define rotation waypoints
orientations = [
Quaternion.identity(),
Quaternion.from_euler_angles(0.5, 0.3, 0.1),
Quaternion.from_euler_angles(1.0, -0.2, 0.8)
]
times = [0.0, 2.0, 5.0]
# Smooth quaternion trajectory with C² continuity
quat_spline = QuaternionSpline(times, orientations, interpolation_method="squad")
# Evaluate at any time
orientation, segment = quat_spline.interpolate_at_time(3.5)
# For angular velocity, use interpolate_with_velocity
orientation_with_vel, angular_velocity, segment = quat_spline.interpolate_with_velocity(3.5)
# QuaternionSpline doesn't have built-in plotting - manual visualization needed
plt.show()B-Spline Curve Fitting
import numpy as np
import matplotlib.pyplot as plt
from interpolatepy import CubicSmoothingSpline
# Fit smooth curve to noisy data
t = np.linspace(0, 10, 50)
q = np.sin(t) + 0.1 * np.random.randn(50)
# Use CubicSmoothingSpline with correct parameter name 'mu'
spline = CubicSmoothingSpline(t, q, mu=0.01)
spline.plot()
plt.show()Industrial Motion Planning
import numpy as np
import matplotlib.pyplot as plt
from interpolatepy import DoubleSTrajectory, StateParams, TrajectoryBounds
# Jerk-limited S-curve for smooth industrial motion
state = StateParams(q_0=0.0, q_1=50.0, v_0=0.0, v_1=0.0)
bounds = TrajectoryBounds(v_bound=10.0, a_bound=5.0, j_bound=2.0)
trajectory = DoubleSTrajectory(state, bounds)
print(f"Duration: {trajectory.get_duration():.2f}s")
# Evaluate trajectory
t_eval = np.linspace(0, trajectory.get_duration(), 1000)
results = [trajectory.evaluate(t) for t in t_eval]
positions = [r[0] for r in results]
velocities = [r[1] for r in results]
# Manual plotting
plt.figure(figsize=(12, 8))
plt.subplot(2, 1, 1)
plt.plot(t_eval, positions)
plt.ylabel('Position')
plt.title('Industrial S-Curve Motion Profile')
plt.grid(True)
plt.subplot(2, 1, 2)
plt.plot(t_eval, velocities)
plt.ylabel('Velocity')
plt.xlabel('Time')
plt.grid(True)
plt.show()🤖 Robotics Engineers: Motion planning, trajectory optimization, smooth control
🎬 Animation Artists: Smooth keyframe interpolation, camera paths, character motion
🔬 Scientists: Data smoothing, curve fitting, experimental trajectory analysis
🏭 Automation Engineers: Industrial motion control, CNC machining, conveyor systems
- Fast: Vectorized NumPy operations, optimized algorithms
- Reliable: 85%+ test coverage, continuous integration
- Modern: Python 3.10+, strict typing, dataclass-based APIs
- Research-grade: Peer-reviewed algorithms from robotics literature
Typical Performance:
- Cubic spline (1000 points): ~1ms
- B-spline evaluation (10k points): ~5ms
- S-curve trajectory planning: ~0.5ms
Development Setup
git clone https://github.com/GiorgioMedico/InterpolatePy.git
cd InterpolatePy
pip install -e '.[all]'
pre-commit install
# Run tests
python -m pytest tests/
# Run tests with coverage
python -m pytest tests/ --cov=interpolatepy --cov-report=html --cov-report=term
# Code quality
ruff format interpolatepy/
ruff check interpolatepy/
mypy interpolatepy/
Contributions welcome! Please:
- Fork the repo and create a feature branch
- Install dev dependencies:
pip install -e '.[all]' - Follow existing patterns and add tests
- Run
pre-commit run --all-filesbefore submitting - Open a pull request with clear description
For major changes, open an issue first to discuss the approach.
⭐ Star the repo if InterpolatePy helps your work!
🐛 Report issues on GitHub Issues
💬 Join discussions to share your use cases and feedback
MIT License – Free for commercial and academic use. See LICENSE for details.
If you use InterpolatePy in research, please cite:
@misc{InterpolatePy,
author = {Giorgio Medico},
title = {InterpolatePy: Trajectory Planning and Interpolation for Python},
year = {2025},
url = {https://github.com/GiorgioMedico/InterpolatePy}
}Academic References
This library implements algorithms from:
Robotics & Trajectory Planning:
- Biagiotti & Melchiorri (2008). Trajectory Planning for Automatic Machines and Robots
- Siciliano et al. (2010). Robotics: Modelling, Planning and Control
Quaternion Interpolation:
- Parker et al. (2023). "Logarithm-Based Methods for Interpolating Quaternion Time Series"
- Wittmann et al. (2023). "Spherical Cubic Blends: C²-Continuous Quaternion Interpolation"
- Dam, E. B., Koch, M., & Lillholm, M. (1998). "Quaternions, Interpolation and Animation"
Built with ❤️ for the robotics and scientific computing community.
