Project

tinyspline

0.59
No release in over a year
TinySpline is a small, yet powerful library for interpolating, transforming, and querying arbitrary NURBS, B-Splines, and Bézier curves. The core of the library is written in ANSI C (C89) with a C++ wrapper for an object-oriented programming model. Based on the C++ wrapper, auto-generated bindings for C#, D, Go, Java, Javascript, Lua, Octave, PHP, Python, R, and Ruby are provided.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
 Dependencies
 Project Readme

TinySpline

CI Security

TinySpline is a small, yet powerful library for interpolating, transforming, and querying arbitrary NURBS, B-Splines, and Bézier curves. The core of the library is written in ANSI C (C89) with a C++ wrapper for an object-oriented programming model. Based on the C++ wrapper, auto-generated bindings for C#, D, Go, Java, Javascript, Lua, Octave, PHP, Python, R, and Ruby are provided.

Table of Contents

  • License
  • Features
  • Installation
    • Pre-built Binaries
    • Compiling From Source
  • Getting Started
  • Documentation
  • Publications
  • Theoretical Backgrounds

License

MIT License - see the LICENSE file in the source distribution.

Features

  • Object-oriented programming model
  • B-Splines of any degree and dimensionality
  • Spline interpolation
    • Cubic natural
    • Centripetal Catmull–Rom
  • Evaluation
    • Knots
    • Sampling (multiple knots at once)
    • Equidistant points
    • Components (find y for given x)
  • Reparametrization by arc length
    • Mapping length <--> knot
  • Knot insertion (refinement)
  • Sub-spline extraction
  • Bézier curve decomposition
    • (also known as subdivision)
  • Derivative
  • Degree elevation
  • Computation of rotation minimizing frames
  • Morphing
  • Serialization (JSON)
  • Vector math

Installation

Pre-built Binaries

Releases can be downloaded from the releases page. In addition, the following package manager are supported:

Conan (C/C++):
https://conan.io/center/tinyspline

NuGet (C#):

<PackageReference Include="tinyspline" Version="0.6.0.1" />

Go:

go get github.com/tinyspline/go@v0.6.0

Luarocks (Lua):

luarocks install --server=https://tinyspline.github.io/lua tinyspline

Maven (Java):

<dependency>
   <groupId>org.tinyspline</groupId>
   <artifactId>tinyspline</artifactId>
   <version>0.6.0-1</version>
</dependency>

PyPI (Python):

python -m pip install tinyspline

RubyGems (Ruby):

gem install tinyspline

Compiling From Source

See BUILD.md.

Getting Started

A variety of examples (tests) can be found in the test subdirectory.

The following listing shows a Python example:

from tinyspline import *
import matplotlib.pyplot as plt

spline = BSpline.interpolate_cubic_natural(
  [
     100, -100, # P1
    -100,  200, # P2
     100,  400, # P3
     400,  300, # P4
     700,  500  # P5
  ], 2) # <- dimensionality of the points

# Draw spline as polyline.
points = spline.sample(100)
x = points[0::2]
y = points[1::2]
plt.plot(x, y)

# Draw point at knot 0.3.
vec2 = spline.eval(0.3).result_vec2()
plt.plot(vec2.x, vec2.y, 'ro')

# Draw tangent at knot 0.7.
pos = spline(0.7).result_vec2() # operator () -> eval
der = spline.derive()(0.7).result_vec2().normalize() * 200
s = pos - der
t = pos + der
plt.plot([s.x, t.x], [s.y, t.y])

# Draw 15 normals with equidistant distribution.
knots = spline.equidistant_knot_seq(15)
frames = spline.compute_rmf(knots)
for i in range(frames.size()):
    pos = frames.at(i).position
    nor = pos + frames.at(i).normal * 20
    # You can also fetch the tangent and binormal:
    #     frames.at(i).tangent
    #     frames.at(i).binormal
    plt.plot([pos.x, nor.x], [pos.y, nor.y], 'g')

plt.show()

Result:

Getting Started

Documentation

The latest Doxygen documentation can be found at: https://msteinbeck.github.io/tinyspline/

The documentation of the C interface (https://msteinbeck.github.io/tinyspline/tinyspline_8h.html) is quite extensive and also serves as an entry point for the C++ interface documentation (as well as the documentation for the bindings created from the C++ interface).

Publications

If you use TinySpline in your research, please cite it as below.

@INPROCEEDINGS{Steinbeck:SANER:21,
  author =       {Steinbeck, Marcel and Koschke, Rainer},
  booktitle =    {2021 IEEE International Conference on Software
                  Analysis, Evolution and Reengineering (SANER)},
  title =        {TinySpline: A Small, yet Powerful Library for
                  Interpolating, Transforming, and Querying NURBS,
                  B-Splines, and Bézier Curves},
  year =         {2021},
  pages =        {572-576},
  doi =          {10.1109/SANER50967.2021.00068}
}

Other publications:

@INPROCEEDINGS{Steinbeck:VISSOFT:22,
  author =       {Steinbeck, Marcel and Koschke, Rainer},
  booktitle =    {2022 Working Conference on Software Visualization
                  (VISSOFT)},
  title =        {Edge Animation in Software Visualization},
  year =         {2022},
  pages =        {63-74},
  doi =          {10.1109/VISSOFT55257.2022.00015}
}

Theoretical Backgrounds

[1] is a very good starting point for B-Splines.

[2] explains De Boor's Algorithm and gives some pseudo code.

[3] provides a good overview of NURBS with some mathematical background.

[4] is useful if you want to use NURBS in TinySpline.