InterpolatePy 3.2.2__tar.gz → 3.3.1__tar.gz

{interpolatepy-3.2.2 → interpolatepy-3.3.1}/.github/workflows/docs.yml

@@ -8,7 +8,7 @@ on:
       - 'ALGORITHMS.md'
       - 'docs/**'
       - 'mkdocs.yml'
-      - 'interpolatepy/**/*.py'  # Only Python files for API docs
+      - 'src/interpolatepy/**/*.py'  # Only Python files for API docs
       - 'scripts/check_doc_snippets.py'
       - 'pyproject.toml'
       - 'uv.lock'
@@ -20,7 +20,7 @@ on:
       - 'ALGORITHMS.md'
       - 'docs/**'
       - 'mkdocs.yml'
-      - 'interpolatepy/**/*.py'
+      - 'src/interpolatepy/**/*.py'
       - 'scripts/check_doc_snippets.py'
       - 'pyproject.toml'
       - 'uv.lock'
@@ -52,16 +52,20 @@ jobs:
         cache-dependency-glob: uv.lock
 
     - name: Sync dependencies
-      run: uv sync --locked --no-default-groups --group docs
+      run: uv sync --locked --no-default-groups --group docs --no-install-project
 
     - name: Check documentation snippets
       env:
         INTERPOLATEPY_NO_CPP: '1'
         MPLBACKEND: Agg
-      run: uv run python -m scripts.check_doc_snippets
+        PYTHONPATH: src
+      run: uv run --no-sync python -m scripts.check_doc_snippets
 
     - name: Build documentation
-      run: uv run mkdocs build --clean --strict
+      env:
+        INTERPOLATEPY_NO_CPP: '1'
+        PYTHONPATH: src
+      run: uv run --no-sync mkdocs build --clean --strict
 
     - name: Setup Pages
       if: github.ref == 'refs/heads/main' && github.event_name == 'push'

{interpolatepy-3.2.2 → interpolatepy-3.3.1}/.github/workflows/pre-commit.yml

@@ -16,7 +16,7 @@ jobs:
         enable-cache: true
         cache-dependency-glob: uv.lock
     - name: Sync dependencies
-      run: uv sync --locked --no-default-groups --group dev
+      run: uv sync --locked --no-default-groups --group dev --no-install-project
     - name: Cache pre-commit hook environments
       uses: actions/cache@v5
       with:
@@ -25,4 +25,6 @@ jobs:
         restore-keys: |
           pre-commit-${{ runner.os }}-
     - name: Run pre-commit
-      run: uv run pre-commit run --all-files --show-diff-on-failure
+      run: uv run --no-sync pre-commit run --all-files --show-diff-on-failure
+    - name: Run Pyright
+      run: uv run --no-sync pyright src/interpolatepy

interpolatepy-3.3.1/.github/workflows/publish.yml

@@ -0,0 +1,54 @@
+name: Publish
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build-sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - uses: astral-sh/setup-uv@v8.1.0
+      - name: Build source distribution
+        run: uv build --sdist
+      - uses: actions/upload-artifact@v6
+        with:
+          name: dist-sdist
+          path: dist/*.tar.gz
+
+  build-wheels:
+    name: Build wheels on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-15-intel, macos-latest]
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-python@v6
+      - name: Install cibuildwheel
+        run: python -m pip install cibuildwheel==4.2.0
+      - name: Build and test wheels
+        run: python -m cibuildwheel --output-dir wheelhouse
+      - uses: actions/upload-artifact@v6
+        with:
+          name: dist-wheel-${{ matrix.os }}
+          path: wheelhouse/*.whl
+
+  publish:
+    needs: [build-sdist, build-wheels]
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+    environment: pypi
+    steps:
+      - uses: actions/download-artifact@v5
+        with:
+          pattern: dist-*
+          path: dist
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@release/v1

{interpolatepy-3.2.2 → interpolatepy-3.3.1}/.github/workflows/test.yml

@@ -14,6 +14,8 @@ jobs:
         os: [ubuntu-latest, macos-latest]
         python-version: ['3.11', '3.12', '3.13']
     env:
+      INTERPOLATEPY_NO_CPP: '1'
+      PYTHONPATH: src
       UV_PYTHON: ${{ matrix.python-version }}
     steps:
       - uses: actions/checkout@v6
@@ -23,9 +25,9 @@ jobs:
           enable-cache: true
           cache-dependency-glob: uv.lock
       - name: Sync dependencies
-        run: uv sync --locked --no-default-groups --group test
+        run: uv sync --locked --no-default-groups --group test --no-install-project
       - name: Testing with coverage
-        run: uv run pytest tests --cov=interpolatepy --cov-report=xml --cov-report=term-missing
+        run: uv run --no-sync pytest tests --cov=interpolatepy --cov-report=xml --cov-report=term-missing
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@v6
         with:
@@ -38,6 +40,7 @@ jobs:
   python-examples:
     runs-on: ubuntu-latest
     env:
+      PYTHONPATH: src
       UV_PYTHON: '3.12'
     steps:
       - uses: actions/checkout@v6
@@ -47,13 +50,14 @@ jobs:
           enable-cache: true
           cache-dependency-glob: uv.lock
       - name: Sync dependencies
-        run: uv sync --locked --no-default-groups --group test
+        run: uv sync --locked --no-default-groups --group test --no-install-project
       - name: Run Python examples with the fallback backend
-        run: uv run python -m scripts.check_python_examples --backend python
+        run: uv run --no-sync python -m scripts.check_python_examples --backend python
 
   native:
     runs-on: ubuntu-latest
     env:
+      PYTHONPATH: src
       UV_PYTHON: '3.12'
     steps:
       - uses: actions/checkout@v6
@@ -63,25 +67,25 @@ jobs:
           enable-cache: true
           cache-dependency-glob: uv.lock
       - name: Sync dependencies
-        run: uv sync --locked --no-default-groups --group test
+        run: uv sync --locked --no-default-groups --group test --no-install-project
       - name: Configure C++ tests, examples, and Python bindings
         run: |
           cmake -S cpp -B build/cpp \
             -DINTERPOLATECPP_BUILD_TESTS=ON \
             -DINTERPOLATECPP_BUILD_EXAMPLES=ON \
             -DINTERPOLATECPP_BUILD_BINDINGS=ON \
-            -DPython_EXECUTABLE=$(uv run python -c 'import sys; print(sys.executable)')
+            -DPython_EXECUTABLE=$(uv run --no-sync python -c 'import sys; print(sys.executable)')
       - name: Build native targets
         run: cmake --build build/cpp --parallel 4
       - name: Run C++ tests and examples
         run: ctest --test-dir build/cpp --output-on-failure
       - name: Activate the native Python backend
-        run: cp build/cpp/bindings/interpolatecpp_py*.so interpolatepy/
+        run: cp build/cpp/bindings/interpolatecpp_py*.so src/interpolatepy/
       - name: Run native adapter regressions
-        run: uv run pytest tests/test_backend.py tests/test_native_adapter_api.py
+        run: uv run --no-sync pytest tests/test_backend.py tests/test_native_adapter_api.py
       - name: Run documentation snippets with the native backend
         env:
           MPLBACKEND: Agg
-        run: uv run python -m scripts.check_doc_snippets
+        run: uv run --no-sync python -m scripts.check_doc_snippets
       - name: Run Python examples with the native backend
-        run: uv run python -m scripts.check_python_examples --backend native
+        run: uv run --no-sync python -m scripts.check_python_examples --backend native

{interpolatepy-3.2.2 → interpolatepy-3.3.1}/.gitignore

@@ -148,3 +148,12 @@ cpp/build/
 *.so
 *.dylib
 compile_commands.json
+
+################################
+########### GRAPHIFY ###########
+################################
+# Generated graph: keep the human-readable report (and wiki, if built), drop the
+# 9 MB of graph.json/graph.html plus caches that churn on every `graphify update`.
+graphify-out/*
+!graphify-out/GRAPH_REPORT.md
+!graphify-out/wiki/

{interpolatepy-3.2.2 → interpolatepy-3.3.1}/ALGORITHMS.md

@@ -1,6 +1,6 @@
 # InterpolatePy algorithm guide
 
-This page is a compact map of the algorithms exposed by InterpolatePy 3.2.1.
+This page is a compact map of the algorithms exposed by InterpolatePy 3.3.1.
 For constructor signatures and complete method documentation, use the
 [API reference](docs/api-reference.md). For worked code, use the
 [tutorials](docs/user-guide.md) and [`examples/`](examples/).
@@ -23,6 +23,8 @@ For constructor signatures and complete method documentation, use the
 | Interpolate two orientations | `Quaternion.slerp()` | Shortest-path spherical interpolation |
 | Interpolate orientation keyframes | `QuaternionSpline` | Piecewise SLERP/SQUAD selected explicitly or automatically |
 | Require a smooth SQUAD-style orientation trajectory | `SquadC2` | Virtual endpoints and smooth angular derivative evaluation |
+| Reduce curvature globally across orientation keyframes | `SpringQuaternionInterpolation` | Numerical SPRING relaxation with fixed keyframes |
+| Solve continuous natural Riemannian cubics | `ShootingQuaternionInterpolation` | Sparse multiple shooting with nine unknowns per keyframe interval |
 | Interpolate rotations in logarithmic coordinates | `LogQuaternionInterpolation` | B-spline interpolation of continuous rotation vectors |
 | Decouple rotation angle and axis | `ModifiedLogQuaternionInterpolation` | Separate angle and unit-axis spline state |
 | Describe a 3D line or circle geometrically | `LinearPath` or `CircularPath` | Arc-length parameterized position and geometric derivatives |
@@ -99,7 +101,7 @@ Scalar and NumPy-array times are supported. Times are clipped to the planned
 duration. Inspect `get_duration()` and `get_phase_durations()` for timing.
 
 `TrapezoidalTrajectory.generate_trajectory()` returns a callable and duration.
-Its `TrajectoryParams` lives in `interpolatepy.trapezoidal`; the top-level
+Its `TrajectoryParams` lives in `interpolatepy.motion.trapezoidal`; the top-level
 `interpolatepy.TrajectoryParams` is the distinct multipoint polynomial
 configuration class.
 
@@ -122,6 +124,36 @@ equality when sign is irrelevant.
 the quaternion trajectory protocol. `SquadC2` adds virtual endpoints and
 derivative-aware interpolation.
 
+`SpringQuaternionInterpolation` globally relaxes a sampled piecewise-SLERP
+curve to reduce tangential curvature while keeping keyframes fixed. It has a
+higher one-time construction cost than the closed-form methods, so compare
+setup and repeated evaluation separately. The runnable
+[`spring_quaternion_ex.py`](examples/spring_quaternion_ex.py) example plots
+SPRING beside multiple shooting, LQI, mLQI, piecewise SLERP, SQUAD, and
+SQUAD-C2 and measures both costs on the active backend. A second figure repeats
+the acceleration-energy comparison for the smoothest methods alone, which the
+shared scale of the overview figure flattens.
+
+For the same discrete SPRING problem, `SpringConfig(solver="gauss_newton")`
+replaces only the final-grid optimizer with a banded Gauss-Newton solve.
+Coarse solves remain identical to the default `"gradient_descent"`. Check `converged` and `stage_gradient_norms` rather than
+assuming a finite iteration budget reached a solution. `final_iterations`
+can increase just the final-grid budget without changing coarse inputs.
+[`spring_solver_benchmark.py`](examples/spring_solver_benchmark.py) compares
+both solvers at a common tolerance and reports the angular difference.
+
+`ShootingQuaternionInterpolation` solves the natural Riemannian cubic equations
+using independent integrations between keyframes, analytic sensitivities, and
+sparse damped Newton steps. Orientation, body angular velocity, and angular
+acceleration match at knots; endpoint acceleration is zero. Its `9*(K-1)`
+unknowns depend on keyframe count, not output resolution. This is a local
+stationary solution of continuous squared covariant acceleration, not a
+replacement for SPRING's discrete chord-parameterized objective or a guarantee
+of global minimality. The C++ implementation is selected automatically when
+available; the NumPy/SciPy reference remains available. Run
+[`shooting_quaternion_benchmark.py`](examples/shooting_quaternion_benchmark.py)
+to compare construction and sampling costs against different SPRING grids.
+
 The logarithmic interpolators support B-spline degrees 3, 4, and 5 and, since
 3.2.0, accept as few as two quaternion waypoints. `evaluate_velocity()` and
 `evaluate_acceleration()` return derivatives of the interpolated internal

{interpolatepy-3.2.2/InterpolatePy.egg-info → interpolatepy-3.3.1}/PKG-INFO

@@ -1,18 +1,12 @@
 Metadata-Version: 2.4
 Name: InterpolatePy
-Version: 3.2.2
+Version: 3.3.1
 Summary: A comprehensive Python library for generating smooth trajectories and curves with precise control over position, velocity, acceleration, and jerk profiles
-Author-email: Giorgio Medico <giorgio.medico11@gmail.com>
-Maintainer-email: Giorgio Medico <giorgio.medico11@gmail.com>
-License-Expression: MIT
-Project-URL: Homepage, https://github.com/GiorgioMedico/InterpolatePy
-Project-URL: Bug Tracker, https://github.com/GiorgioMedico/InterpolatePy/issues
 Keywords: interpolation,trajectory planning,motion profiles,robotics,b-splines,cubic splines,frenet frames,path generation,motion control
-Platform: unix
-Platform: linux
-Platform: osx
-Platform: cygwin
-Platform: win32
+Author-Email: Giorgio Medico <giorgio.medico11@gmail.com>
+Maintainer-Email: Giorgio Medico <giorgio.medico11@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
 Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
@@ -31,13 +25,14 @@ Classifier: Topic :: Scientific/Engineering :: Visualization
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Programming Language :: C++
+Project-URL: Homepage, https://github.com/GiorgioMedico/InterpolatePy
+Project-URL: Bug Tracker, https://github.com/GiorgioMedico/InterpolatePy/issues
 Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
 Requires-Dist: numpy>=1.26
-Requires-Dist: matplotlib>=3.6
 Requires-Dist: scipy>=1.11
-Dynamic: license-file
+Provides-Extra: plot
+Requires-Dist: matplotlib>=3.6; extra == "plot"
+Description-Content-Type: text/markdown
 
 # InterpolatePy
 
@@ -61,8 +56,12 @@ at import time.
 python -m pip install InterpolatePy
 ```
 
-InterpolatePy 3.2.1 requires Python 3.11 or newer, NumPy 1.26 or newer,
-SciPy 1.11 or newer, and Matplotlib 3.6 or newer.
+InterpolatePy 3.3.1 requires Python 3.11 or newer, NumPy 1.26 or newer,
+and SciPy 1.11 or newer. Install plotting support when needed:
+
+```bash
+python -m pip install "InterpolatePy[plot]"
+```
 
 ## Quick start
 
@@ -104,7 +103,7 @@ component, or `evaluate_full()` for all four.
 | Scalar splines | `CubicSpline`, `CubicSmoothingSpline`, `CubicSplineWithAcceleration1`, `CubicSplineWithAcceleration2` | Smooth scalar waypoint trajectories and noisy data |
 | B-splines | `BSpline`, `BSplineInterpolator`, `CubicBSplineInterpolation`, `ApproximationBSpline`, `SmoothingCubicBSpline` | Parametric curves, interpolation, approximation, and smoothing |
 | Motion profiles | `DoubleSTrajectory`, `TrapezoidalTrajectory`, `PolynomialTrajectory`, `ParabolicBlendTrajectory` | Bounded or boundary-conditioned scalar motion |
-| Rotations | `Quaternion`, `QuaternionSpline`, `SquadC2`, `LogQuaternionInterpolation`, `ModifiedLogQuaternionInterpolation` | Orientation interpolation without Euler-angle singularities |
+| Rotations | `Quaternion`, `QuaternionSpline`, `SquadC2`, `SpringQuaternionInterpolation`, `ShootingQuaternionInterpolation`, `LogQuaternionInterpolation`, `ModifiedLogQuaternionInterpolation` | Orientation interpolation without Euler-angle singularities |
 | Paths and utilities | `LinearPath`, `CircularPath`, Frenet-frame helpers, `linear_traj`, `solve_tridiagonal` | Geometric paths, moving frames, and numerical helpers |
 
 Degrees 3, 4, and 5 of `BSplineInterpolator`,
@@ -117,7 +116,8 @@ See the [algorithm selection guide](ALGORITHMS.md), the
 
 ## Optional C++ backend
 
-The package falls back to Python automatically when the extension is absent:
+Platform wheels include the compiled backend. The package falls back to Python
+automatically when the extension is absent:
 
 ```python
 import interpolatepy
@@ -126,9 +126,9 @@ print(interpolatepy.HAS_CPP)
 ```
 
 Set `INTERPOLATEPY_NO_CPP=1` before importing the package to force the Python
-implementation. The standard Python package does not need a compiler. Building
-the native library or Python extension from a source checkout requires CMake
-3.21+, a C++20 compiler, and network access for CMake's fetched dependencies;
+implementation. Installing a published wheel does not need a compiler. Building
+from a source distribution or source checkout requires CMake 3.21+, a C++20
+compiler, and network access for CMake's fetched dependencies;
 see the [installation guide](docs/installation.md#optional-c-backend).
 
 ## Development

{interpolatepy-3.2.2 → interpolatepy-3.3.1}/README.md

@@ -20,8 +20,12 @@ at import time.
 python -m pip install InterpolatePy
 ```
 
-InterpolatePy 3.2.1 requires Python 3.11 or newer, NumPy 1.26 or newer,
-SciPy 1.11 or newer, and Matplotlib 3.6 or newer.
+InterpolatePy 3.3.1 requires Python 3.11 or newer, NumPy 1.26 or newer,
+and SciPy 1.11 or newer. Install plotting support when needed:
+
+```bash
+python -m pip install "InterpolatePy[plot]"
+```
 
 ## Quick start
 
@@ -63,7 +67,7 @@ component, or `evaluate_full()` for all four.
 | Scalar splines | `CubicSpline`, `CubicSmoothingSpline`, `CubicSplineWithAcceleration1`, `CubicSplineWithAcceleration2` | Smooth scalar waypoint trajectories and noisy data |
 | B-splines | `BSpline`, `BSplineInterpolator`, `CubicBSplineInterpolation`, `ApproximationBSpline`, `SmoothingCubicBSpline` | Parametric curves, interpolation, approximation, and smoothing |
 | Motion profiles | `DoubleSTrajectory`, `TrapezoidalTrajectory`, `PolynomialTrajectory`, `ParabolicBlendTrajectory` | Bounded or boundary-conditioned scalar motion |
-| Rotations | `Quaternion`, `QuaternionSpline`, `SquadC2`, `LogQuaternionInterpolation`, `ModifiedLogQuaternionInterpolation` | Orientation interpolation without Euler-angle singularities |
+| Rotations | `Quaternion`, `QuaternionSpline`, `SquadC2`, `SpringQuaternionInterpolation`, `ShootingQuaternionInterpolation`, `LogQuaternionInterpolation`, `ModifiedLogQuaternionInterpolation` | Orientation interpolation without Euler-angle singularities |
 | Paths and utilities | `LinearPath`, `CircularPath`, Frenet-frame helpers, `linear_traj`, `solve_tridiagonal` | Geometric paths, moving frames, and numerical helpers |
 
 Degrees 3, 4, and 5 of `BSplineInterpolator`,
@@ -76,7 +80,8 @@ See the [algorithm selection guide](ALGORITHMS.md), the
 
 ## Optional C++ backend
 
-The package falls back to Python automatically when the extension is absent:
+Platform wheels include the compiled backend. The package falls back to Python
+automatically when the extension is absent:
 
 ```python
 import interpolatepy
@@ -85,9 +90,9 @@ print(interpolatepy.HAS_CPP)
 ```
 
 Set `INTERPOLATEPY_NO_CPP=1` before importing the package to force the Python
-implementation. The standard Python package does not need a compiler. Building
-the native library or Python extension from a source checkout requires CMake
-3.21+, a C++20 compiler, and network access for CMake's fetched dependencies;
+implementation. Installing a published wheel does not need a compiler. Building
+from a source distribution or source checkout requires CMake 3.21+, a C++20
+compiler, and network access for CMake's fetched dependencies;
 see the [installation guide](docs/installation.md#optional-c-backend).
 
 ## Development

{interpolatepy-3.2.2 → interpolatepy-3.3.1}/cpp/CMakeLists.txt

@@ -1,6 +1,13 @@
 cmake_minimum_required(VERSION 3.21)
+
+if(DEFINED SKBUILD_PROJECT_VERSION)
+    set(INTERPOLATECPP_VERSION "${SKBUILD_PROJECT_VERSION}")
+else()
+    set(INTERPOLATECPP_VERSION "3.3.1")
+endif()
+
 project(InterpolateCpp
-    VERSION 0.1.0
+    VERSION "${INTERPOLATECPP_VERSION}"
     LANGUAGES CXX
     DESCRIPTION "C++ port of InterpolatePy trajectory planning library"
 )
@@ -9,6 +16,9 @@ set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(PYBIND11_FINDPYTHON ON)
+
+include(GNUInstallDirs)
 
 # Options
 option(INTERPOLATECPP_BUILD_TESTS "Build tests" ON)
@@ -24,13 +34,17 @@ configure_file(
 # Dependencies via FetchContent
 include(FetchContent)
 
-FetchContent_Declare(
-    Eigen
-    GIT_REPOSITORY https://gitlab.com/libeigen/eigen.git
-    GIT_TAG 3.4.0
-    GIT_SHALLOW TRUE
-    SYSTEM
-)
+find_package(Eigen3 3.4 CONFIG QUIET)
+
+if(NOT Eigen3_FOUND)
+    FetchContent_Declare(
+        Eigen
+        GIT_REPOSITORY https://gitlab.com/libeigen/eigen.git
+        GIT_TAG 3.4.0
+        GIT_SHALLOW TRUE
+        SYSTEM
+    )
+endif()
 
 if(INTERPOLATECPP_BUILD_TESTS)
     FetchContent_Declare(
@@ -41,7 +55,7 @@ if(INTERPOLATECPP_BUILD_TESTS)
     )
 endif()
 
-if(INTERPOLATECPP_BUILD_BINDINGS)
+if(INTERPOLATECPP_BUILD_BINDINGS AND NOT SKBUILD)
     FetchContent_Declare(
         pybind11
         GIT_REPOSITORY https://github.com/pybind/pybind11.git
@@ -50,12 +64,14 @@ if(INTERPOLATECPP_BUILD_BINDINGS)
     )
 endif()
 
-# Make Eigen available (suppress its tests and docs)
-set(BUILD_TESTING OFF CACHE BOOL "" FORCE)
-set(EIGEN_BUILD_TESTING OFF CACHE BOOL "" FORCE)
-set(EIGEN_BUILD_DOC OFF CACHE BOOL "" FORCE)
-FetchContent_MakeAvailable(Eigen)
-set(BUILD_TESTING ON CACHE BOOL "" FORCE)
+# Make the fallback Eigen dependency available without building its tests or docs.
+if(NOT Eigen3_FOUND)
+    set(BUILD_TESTING OFF CACHE BOOL "" FORCE)
+    set(EIGEN_BUILD_TESTING OFF CACHE BOOL "" FORCE)
+    set(EIGEN_BUILD_DOC OFF CACHE BOOL "" FORCE)
+    FetchContent_MakeAvailable(Eigen)
+    set(BUILD_TESTING ON CACHE BOOL "" FORCE)
+endif()
 
 # Library sources
 set(INTERPOLATECPP_SOURCES
@@ -79,6 +95,11 @@ set(INTERPOLATECPP_SOURCES
     src/quaternion.cpp
     src/quaternion_spline.cpp
     src/squad_c2.cpp
+    src/spring_quaternion_interpolation.cpp
+    src/spring_solver.cpp
+    src/spring_gauss_newton.cpp
+    src/shooting_quaternion_interpolation.cpp
+    src/shooting_solver.cpp
     src/log_quaternion_interpolation.cpp
     src/modified_log_quaternion_interpolation.cpp
     # Phase 5: Path
@@ -106,6 +127,13 @@ set_target_properties(interpolatecpp PROPERTIES
     VISIBILITY_INLINES_HIDDEN ON
 )
 
+# INTERPOLATECPP_API must export while building the library and stay empty for a
+# static one; without this MSVC marks every symbol dllimport and the link fails.
+target_compile_definitions(interpolatecpp
+    PRIVATE INTERPOLATECPP_EXPORTS
+    PUBLIC $<$<NOT:$<BOOL:${BUILD_SHARED_LIBS}>>:INTERPOLATECPP_STATIC_DEFINE>
+)
+
 target_compile_options(interpolatecpp PRIVATE
     $<$<CXX_COMPILER_ID:GNU,Clang,AppleClang>:
         -Wall -Wextra -Wpedantic -Wconversion -Wshadow
@@ -124,7 +152,10 @@ endif()
 
 # Bindings
 if(INTERPOLATECPP_BUILD_BINDINGS)
-    FetchContent_MakeAvailable(pybind11)
+    find_package(pybind11 CONFIG QUIET)
+    if(NOT pybind11_FOUND)
+        FetchContent_MakeAvailable(pybind11)
+    endif()
     add_subdirectory(bindings)
 endif()
 
@@ -134,8 +165,6 @@ if(INTERPOLATECPP_BUILD_EXAMPLES)
 endif()
 
 # Install rules
-include(GNUInstallDirs)
-
 install(TARGETS interpolatecpp
     EXPORT InterpolateCppTargets
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}

{interpolatepy-3.2.2 → interpolatepy-3.3.1}/cpp/bindings/CMakeLists.txt

@@ -22,5 +22,6 @@ target_link_libraries(interpolatecpp_py
 )
 
 install(TARGETS interpolatecpp_py
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    LIBRARY DESTINATION interpolatepy COMPONENT python
+    RUNTIME DESTINATION interpolatepy COMPONENT python
 )

{interpolatepy-3.2.2 → interpolatepy-3.3.1}/cpp/bindings/bind_quaternion.cpp

@@ -6,6 +6,8 @@
 #include <interpolatecpp/quat/modified_log_quaternion_interpolation.hpp>
 #include <interpolatecpp/quat/quaternion.hpp>
 #include <interpolatecpp/quat/quaternion_spline.hpp>
+#include <interpolatecpp/quat/spring_quaternion_interpolation.hpp>
+#include <interpolatecpp/quat/shooting_quaternion_interpolation.hpp>
 #include <interpolatecpp/quat/squad_c2.hpp>
 
 namespace py = pybind11;
@@ -106,6 +108,82 @@ void bind_quaternion(py::module_& m) {
         .def_property_readonly("t_max", &SquadC2::t_max)
         .def_property_readonly("validate_continuity", &SquadC2::validate_continuity);
 
+    // SpringConfig
+    py::class_<SpringConfig>(quat_mod, "SpringConfig")
+        .def(py::init<>())
+        .def_readwrite("num_samples", &SpringConfig::num_samples)
+        .def_readwrite("iterations", &SpringConfig::iterations)
+        .def_readwrite("refinement_levels", &SpringConfig::refinement_levels)
+        .def_readwrite("step_size", &SpringConfig::step_size)
+        .def_readwrite("norm_penalty", &SpringConfig::norm_penalty)
+        .def_readwrite("keyframe_curvature_weight",
+                       &SpringConfig::keyframe_curvature_weight)
+        .def_readwrite("tolerance", &SpringConfig::tolerance)
+        .def_readwrite("solver", &SpringConfig::solver)
+        .def_readwrite("final_iterations", &SpringConfig::final_iterations);
+
+    // SpringQuaternionInterpolation
+    py::class_<SpringQuaternionInterpolation>(quat_mod,
+                                               "SpringQuaternionInterpolation")
+        .def(py::init<const std::vector<double>&,
+                      const std::vector<Quaternion>&, SpringConfig>(),
+             py::arg("time_points"), py::arg("quaternions"),
+             py::arg("config") = SpringConfig{},
+             py::call_guard<py::gil_scoped_release>())
+        .def("evaluate", &SpringQuaternionInterpolation::evaluate, py::arg("t"))
+        .def("evaluate_velocity",
+             &SpringQuaternionInterpolation::evaluate_velocity, py::arg("t"))
+        .def("evaluate_acceleration",
+             &SpringQuaternionInterpolation::evaluate_acceleration, py::arg("t"))
+        .def("generate_trajectory",
+             &SpringQuaternionInterpolation::generate_trajectory,
+             py::arg("num_points") = 100)
+        .def("get_time_points", &SpringQuaternionInterpolation::time_points)
+        .def("get_quaternions", &SpringQuaternionInterpolation::quaternions)
+        .def("get_sample_times", &SpringQuaternionInterpolation::sample_times)
+        .def("get_samples", &SpringQuaternionInterpolation::samples)
+        .def("get_keyframe_indices",
+             &SpringQuaternionInterpolation::keyframe_indices)
+        .def("get_refinement_sample_counts",
+             &SpringQuaternionInterpolation::refinement_sample_counts)
+        .def("get_stage_energy_history",
+             &SpringQuaternionInterpolation::stage_energy_history)
+        .def("get_stage_gradient_norms", &SpringQuaternionInterpolation::stage_gradient_norms)
+        .def_property_readonly("converged", &SpringQuaternionInterpolation::converged)
+        .def_property_readonly("initial_energy",
+                               &SpringQuaternionInterpolation::initial_energy)
+        .def_property_readonly("final_energy",
+                               &SpringQuaternionInterpolation::final_energy)
+        .def_property_readonly("iterations_run",
+                               &SpringQuaternionInterpolation::iterations_run)
+        .def_property_readonly("t_min", &SpringQuaternionInterpolation::t_min)
+        .def_property_readonly("t_max", &SpringQuaternionInterpolation::t_max);
+
+    py::class_<ShootingConfig>(quat_mod, "ShootingConfig")
+        .def(py::init<>())
+        .def_readwrite("tolerance", &ShootingConfig::tolerance)
+        .def_readwrite("max_iterations", &ShootingConfig::max_iterations)
+        .def_readwrite("integration_steps", &ShootingConfig::integration_steps)
+        .def_readwrite("max_integration_steps", &ShootingConfig::max_integration_steps);
+
+    py::class_<ShootingQuaternionInterpolation>(quat_mod, "ShootingQuaternionInterpolation")
+        .def(py::init<const std::vector<double>&, const std::vector<Quaternion>&, ShootingConfig>(),
+             py::arg("time_points"), py::arg("quaternions"), py::arg("config") = ShootingConfig{},
+             py::call_guard<py::gil_scoped_release>())
+        .def("evaluate", &ShootingQuaternionInterpolation::evaluate, py::arg("t"))
+        .def("evaluate_velocity", &ShootingQuaternionInterpolation::evaluate_velocity, py::arg("t"))
+        .def("evaluate_acceleration", &ShootingQuaternionInterpolation::evaluate_acceleration, py::arg("t"))
+        .def("generate_trajectory", &ShootingQuaternionInterpolation::generate_trajectory, py::arg("num_points") = 100)
+        .def("get_time_points", &ShootingQuaternionInterpolation::time_points)
+        .def("get_quaternions", &ShootingQuaternionInterpolation::quaternions)
+        .def_property_readonly("iterations_run", &ShootingQuaternionInterpolation::iterations_run)
+        .def_property_readonly("integration_steps", &ShootingQuaternionInterpolation::integration_steps)
+        .def_property_readonly("num_variables", &ShootingQuaternionInterpolation::num_variables)
+        .def_property_readonly("residual_norm", &ShootingQuaternionInterpolation::residual_norm)
+        .def_property_readonly("acceleration_energy", &ShootingQuaternionInterpolation::acceleration_energy)
+        .def_property_readonly("t_min", &ShootingQuaternionInterpolation::t_min)
+        .def_property_readonly("t_max", &ShootingQuaternionInterpolation::t_max);
+
     // LogQuaternionInterpolation
     py::class_<LogQuaternionInterpolation>(quat_mod, "LogQuaternionInterpolation")
         .def(py::init<const std::vector<double>&, const std::vector<Quaternion>&, int,

{interpolatepy-3.2.2 → interpolatepy-3.3.1}/cpp/examples/CMakeLists.txt

@@ -16,6 +16,7 @@ set(EXAMPLE_SOURCES
     parabolic_linear_example.cpp
     # Phase 4: Quaternion
     quaternion_example.cpp
+    spring_quaternion_example.cpp
     # Phase 5: Paths & Concepts
     paths_example.cpp
     concepts_example.cpp