TinySpline

TinySpline works with a hierarchy of spline types where each type is a specialized version of the one above it. The relationship is defined as follows:

NURBS > BSPLINES > BEZIERS > LINES > POINTS

This means every point can be treated as a line, every line as a Bézier curve, every Bézier curve as a B-Spline, and every B-Spline as a NURBS curve.

You can install the C and C++ interfaces to your system using the CMake install target. This also installs CMake config scripts and pkg-config files.

Using in CMake projects

Use find_package(tinyspline) for the C interface or find_package(tinysplinecxx) for the C++ interface.

Exported Variables

C Interface:

• TINYSPLINE_INCLUDE_DIRS: Header file locations.
• TINYSPLINE_LIBRARY_DIRS: Library locations.
• TINYSPLINE_LIBRARIES: Shared libraries to link.
• TINYSPLINE_DEFINITIONS: Definitions for add_definitions.
• TINYSPLINE_VERSION: Version string.

C++ Interface: Uses the same variable names but with the TINYSPLINECXX_ prefix (e.g., TINYSPLINECXX_INCLUDE_DIRS).

cmake --build . --target install

By default, the C interface is always enabled and the C++ interface is enabled unless explicitly disabled. To build specific language bindings, use the -DTINYSPLINE_ENABLE_<LANGUAGE> flag during the CMake configuration step.

To enable all interfaces at once, use -DTINYSPLINE_ENABLE_ALL_INTERFACES=True.

# Build only the Python interface
cmake -DTINYSPLINE_ENABLE_PYTHON=True ..
cmake --build . tinysplinepython

# Build all interfaces
cmake -DTINYSPLINE_ENABLE_ALL_INTERFACES=True ..
cmake --build .

TinySpline uses CMake to compile its interfaces. The build requires a compiler suite like GCC, Clang, or MSVC. To create language bindings, Swig (4.1.0 or later) must be installed.

Follow these steps to perform a standard build:

1. Clone the repository and enter the directory.
2. Create and enter a build directory.
3. Run CMake and build the project.

Compiled libraries and packages are located in tinyspline/build/lib after a successful build.

git clone https://github.com/msteinbeck/tinyspline.git tinyspline
cd tinyspline

mkdir build
cd build

cmake ..
cmake --build .

To compute rotation minimizing frames (RMF) along a spline, first generate an equidistant sequence of knots using equidistant_knot_seq(n), then pass those knots to compute_rmf(knots). The resulting frames allow you to access the position, normal, tangent, and binormal at each knot.

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')

You can create a B-Spline using cubic natural interpolation by providing a flat list of coordinates and the dimensionality of the points. Once created, you can sample points along the spline, evaluate the position at a specific knot, or compute derivatives (tangents).

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.
spline.sample(100)

# Draw point at knot 0.3.
vec2 = spline.eval(0.3).result_vec2()

# Draw tangent at knot 0.7.
pos = spline(0.7).result_vec2() # operator () -> eval
der = spline.derive()(0.7).result_vec2().normalize() * 200

When building bindings, certain languages require specific headers or tools.

• Note: On macOS, use a package manager like Homebrew to get PHP Zend headers.

Required tools for creating binary packages:

• C#: csc, mcs, dmcs, or gmcs (outputs TinySpline.dll)
• Java: javac and jar from JDK (outputs tinyspline.jar)

The DeBoorNet class provides a way to evaluate the spline at a specific knot using the De Boor algorithm. It is returned by calling BSpline::eval(real knot) or using the operator()(real knot).

Capabilities:

• Access the knot value, index, and multiplicity.
• Retrieve the result at a specific index as a Vec2, Vec3, or Vec4 using resultVec2(idx), resultVec3(idx), or resultVec4(idx). These methods are safe to call even if the spline dimension is lower than the requested vector dimension (missing components are set to 0).

When using the Emscripten build, the VecMath class provides static methods to perform vector operations without needing to manage object instances manually. This is useful for functional-style programming.

Available Methods:

• add2, add3, add4
• subtract2, subtract3, subtract4
• multiply2, multiply3, multiply4
• cross3 (3D only)
• normalize2, normalize3, normalize4
• magnitude2, magnitude3, magnitude4
• dot2, dot3, dot4
• angle2, angle3, angle4
• distance2, distance3, distance4