Add Python bindings and make Matplot integration optional

This PR adds a pybind11-based pycddp package with bindings for solver options, dynamics, objectives, constraints, and solver execution, along with Python integration tests and packaging metadata.

It also makes Matplot-dependent includes and test links optional, adds CMake package installation metadata, and prepares the core library for shared-library consumers such as the Python module.

Author: astomodynamics

.gitignore

@@ -21,3 +21,11 @@ pdf_images/
 
 # Solver output
 solver_snopt.out
+
+# Python / uv
+.venv/
+uv.lock
+*.egg-info/
+__pycache__/
+*.so
+*.pyd

.python-version

@@ -0,0 +1 @@
+3.13

CMakeLists.txt

@@ -43,6 +43,8 @@ endif()
 
 # Options
 option(CDDP_CPP_BUILD_TESTS "Whether to build tests." ON)
+option(CDDP_CPP_BUILD_EXAMPLES "Whether to build examples." ON)
+option(CDDP_CPP_ENABLE_PLOTTING "Enable matplotplusplus for visualization." ON)
 
 # CasADi Configuration
 option(CDDP_CPP_CASADI "Whether to use CasADi" OFF)
@@ -92,14 +94,16 @@ endif()
 # Enable FetchContent for downloading dependencies
 include(FetchContent)
 
-# Matplotplusplus
-FetchContent_Declare(matplotplusplus
-  GIT_REPOSITORY https://github.com/alandefreitas/matplotplusplus
-  GIT_TAG origin/master) # or whatever tag you want
-FetchContent_GetProperties(matplotplusplus)
-if(NOT matplotplusplus_POPULATED)
-    FetchContent_Populate(matplotplusplus)
-    add_subdirectory(${matplotplusplus_SOURCE_DIR} ${matplotplusplus_BINARY_DIR} EXCLUDE_FROM_ALL)
+# Matplotplusplus (optional)
+if(CDDP_CPP_ENABLE_PLOTTING)
+  FetchContent_Declare(matplotplusplus
+    GIT_REPOSITORY https://github.com/alandefreitas/matplotplusplus
+    GIT_TAG origin/master)
+  FetchContent_GetProperties(matplotplusplus)
+  if(NOT matplotplusplus_POPULATED)
+      FetchContent_Populate(matplotplusplus)
+      add_subdirectory(${matplotplusplus_SOURCE_DIR} ${matplotplusplus_BINARY_DIR} EXCLUDE_FROM_ALL)
+  endif()
 endif()
 
 # autodiff
@@ -172,16 +176,23 @@ set(dynamics_model_srcs
   src/dynamics_model/euler_attitude.cpp
 )
 
-add_library(${PROJECT_NAME} 
+add_library(${PROJECT_NAME}
   ${cddp_core_srcs}
   ${dynamics_model_srcs}
 )
 
-target_link_libraries(${PROJECT_NAME} 
+# Enable position-independent code (required for Python shared library linking)
+set_target_properties(${PROJECT_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+target_link_libraries(${PROJECT_NAME}
   $<IF:$<BOOL:${Eigen3_FOUND}>,Eigen3::Eigen,>
-  matplot
   autodiff
-) 
+)
+
+if(CDDP_CPP_ENABLE_PLOTTING)
+  target_link_libraries(${PROJECT_NAME} matplot)
+  target_compile_definitions(${PROJECT_NAME} PUBLIC CDDP_HAS_MATPLOT)
+endif()
 
 if(NOT Eigen3_FOUND)
   target_include_directories(${PROJECT_NAME} PUBLIC ${EIGEN3_INCLUDE_DIRS})
@@ -258,11 +269,53 @@ if (CDDP_CPP_BUILD_TESTS)
 endif()
 
 # Build examples
-add_subdirectory(examples)
-
-# Cmake compile commmand:
-# $ mkdir build
-# $ cd build
-# $ cmake -DCDDP_CPP_BUILD_TESTS=ON -DCDDP_CPP_CASADI=ON ..
-# $ make -j4
-# $ make test
+if (CDDP_CPP_BUILD_EXAMPLES)
+  add_subdirectory(examples)
+endif()
+
+# Python bindings (optional)
+option(CDDP_CPP_BUILD_PYTHON "Build Python bindings" OFF)
+if(CDDP_CPP_BUILD_PYTHON)
+  add_subdirectory(python)
+endif()
+
+# Install targets
+include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+
+install(TARGETS ${PROJECT_NAME}
+  EXPORT cddpTargets
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)
+
+install(DIRECTORY include/cddp-cpp/
+  DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/cddp-cpp
+  FILES_MATCHING PATTERN "*.hpp"
+)
+
+install(EXPORT cddpTargets
+  FILE cddpTargets.cmake
+  NAMESPACE cddp::
+  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/cddp
+)
+
+configure_package_config_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/cmake/cddpConfig.cmake.in
+  ${CMAKE_CURRENT_BINARY_DIR}/cddpConfig.cmake
+  INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/cddp
+)
+
+write_basic_package_version_file(
+  ${CMAKE_CURRENT_BINARY_DIR}/cddpConfigVersion.cmake
+  VERSION ${PROJECT_VERSION}
+  COMPATIBILITY SameMajorVersion
+)
+
+install(FILES
+  ${CMAKE_CURRENT_BINARY_DIR}/cddpConfig.cmake
+  ${CMAKE_CURRENT_BINARY_DIR}/cddpConfigVersion.cmake
+  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/cddp
+)

cmake/cddpConfig.cmake.in

@@ -0,0 +1,7 @@
+@PACKAGE_INIT@
+
+include(CMakeFindDependencyMacro)
+find_dependency(Eigen3)
+
+include("${CMAKE_CURRENT_LIST_DIR}/cddpTargets.cmake")
+check_required_components(cddp)

include/cddp-cpp/cddp.hpp

@@ -57,6 +57,8 @@
 #include "dynamics_model/quaternion_attitude.hpp"
 #include "dynamics_model/mrp_attitude.hpp"
 
+#ifdef CDDP_HAS_MATPLOT
 #include "matplot/matplot.h"
+#endif
 
 #endif // CDDP_HPP

pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["scikit-build-core>=0.8", "pybind11>=2.12"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "pycddp"
+version = "0.1.0"
+description = "Python bindings for CDDP trajectory optimization"
+readme = "README.md"
+license = {text = "Apache-2.0"}
+requires-python = ">=3.10"
+dependencies = ["numpy>=1.22"]
+
+[project.optional-dependencies]
+test = ["pytest>=7.0"]
+viz = ["matplotlib>=3.5"]
+
+[dependency-groups]
+dev = ["pytest>=7.0", "matplotlib>=3.5"]
+
+[tool.scikit-build]
+cmake.args = ["-DCDDP_CPP_BUILD_PYTHON=ON", "-DCDDP_CPP_BUILD_TESTS=OFF", "-DCDDP_CPP_BUILD_EXAMPLES=OFF", "-DCDDP_CPP_ENABLE_PLOTTING=OFF"]
+wheel.packages = ["python/pycddp"]

python/CMakeLists.txt

@@ -0,0 +1,26 @@
+find_package(pybind11 CONFIG QUIET)
+if(NOT pybind11_FOUND)
+  message(STATUS "pybind11 not found, fetching...")
+  FetchContent_Declare(
+    pybind11
+    GIT_REPOSITORY https://github.com/pybind/pybind11.git
+    GIT_TAG v2.13.6
+  )
+  FetchContent_MakeAvailable(pybind11)
+endif()
+
+pybind11_add_module(_pycddp_core
+  src/main.cpp
+  src/bind_options.cpp
+  src/bind_dynamics.cpp
+  src/bind_objective.cpp
+  src/bind_constraints.cpp
+  src/bind_solver.cpp
+)
+
+target_link_libraries(_pycddp_core PRIVATE cddp)
+target_include_directories(_pycddp_core PRIVATE
+  ${CMAKE_SOURCE_DIR}/include/cddp-cpp
+)
+
+install(TARGETS _pycddp_core DESTINATION pycddp)

python/pycddp/__init__.py

@@ -0,0 +1,73 @@
+"""pycddp - Python bindings for CDDP trajectory optimization."""
+
+from pycddp._pycddp_core import (
+    # Enums
+    SolverType,
+    BarrierStrategy,
+
+    # Options
+    CDDPOptions,
+    BoxQPOptions,
+    LineSearchOptions,
+    RegularizationOptions,
+    BarrierOptions,
+    FilterOptions,
+    InteriorPointOptions,
+    LogBarrierOptions,
+    IPDDPOptions,
+    MSIPDDPOptions,
+
+    # Core solver
+    CDDP,
+    CDDPSolution,
+    SolutionHistory,
+
+    # Dynamics base
+    DynamicalSystem,
+
+    # Concrete dynamics models
+    Pendulum,
+    Unicycle,
+    Bicycle,
+    Car,
+    CartPole,
+    DubinsCar,
+    Forklift,
+    Acrobot,
+    Quadrotor,
+    QuadrotorRate,
+    Manipulator,
+    HCW,
+    SpacecraftLinearFuel,
+    SpacecraftNonlinear,
+    DreyfusRocket,
+    SpacecraftLanding2D,
+    SpacecraftROE,
+    SpacecraftTwobody,
+    LTISystem,
+    Usv3Dof,
+    EulerAttitude,
+    QuaternionAttitude,
+    MrpAttitude,
+
+    # Objectives
+    Objective,
+    QuadraticObjective,
+    NonlinearObjective,
+
+    # Constraints
+    Constraint,
+    ControlConstraint,
+    StateConstraint,
+    LinearConstraint,
+    BallConstraint,
+    PoleConstraint,
+    SecondOrderConeConstraint,
+    ThrustMagnitudeConstraint,
+    MaxThrustMagnitudeConstraint,
+
+)
+
+from pycddp._version import __version__
+
+__all__ = [name for name in dir() if not name.startswith("_")]

python/pycddp/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

python/src/bind_constraints.cpp

@@ -0,0 +1,68 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/eigen.h>
+#include <pybind11/stl.h>
+
+#include "cddp_core/constraint.hpp"
+
+namespace py = pybind11;
+
+template <typename T>
+using nodeleter = std::unique_ptr<T, py::nodelete>;
+
+void bind_constraints(py::module_& m) {
+    // Base Constraint class - py::nodelete so CDDP can take ownership
+    py::class_<cddp::Constraint, nodeleter<cddp::Constraint>>(m, "Constraint")
+        .def("evaluate", &cddp::Constraint::evaluate,
+             py::arg("state"), py::arg("control"), py::arg("index") = 0)
+        .def("get_lower_bound", &cddp::Constraint::getLowerBound)
+        .def("get_upper_bound", &cddp::Constraint::getUpperBound)
+        .def("get_state_jacobian", &cddp::Constraint::getStateJacobian,
+             py::arg("state"), py::arg("control"), py::arg("index") = 0)
+        .def("get_control_jacobian", &cddp::Constraint::getControlJacobian,
+             py::arg("state"), py::arg("control"), py::arg("index") = 0)
+        .def("compute_violation", &cddp::Constraint::computeViolation,
+             py::arg("state"), py::arg("control"), py::arg("index") = 0)
+        .def("get_dual_dim", &cddp::Constraint::getDualDim)
+        .def_property_readonly("name", &cddp::Constraint::getName);
+
+    py::class_<cddp::ControlConstraint, cddp::Constraint, nodeleter<cddp::ControlConstraint>>(m, "ControlConstraint")
+        .def(py::init<const Eigen::VectorXd&, const Eigen::VectorXd&, double>(),
+             py::arg("lower_bound"), py::arg("upper_bound"),
+             py::arg("scale_factor") = 1.0);
+
+    py::class_<cddp::StateConstraint, cddp::Constraint, nodeleter<cddp::StateConstraint>>(m, "StateConstraint")
+        .def(py::init<const Eigen::VectorXd&, const Eigen::VectorXd&, double>(),
+             py::arg("lower_bound"), py::arg("upper_bound"),
+             py::arg("scale_factor") = 1.0);
+
+    py::class_<cddp::LinearConstraint, cddp::Constraint, nodeleter<cddp::LinearConstraint>>(m, "LinearConstraint")
+        .def(py::init<const Eigen::MatrixXd&, const Eigen::VectorXd&, double>(),
+             py::arg("A"), py::arg("b"), py::arg("scale_factor") = 1.0);
+
+    py::class_<cddp::BallConstraint, cddp::Constraint, nodeleter<cddp::BallConstraint>>(m, "BallConstraint")
+        .def(py::init<double, const Eigen::VectorXd&, double>(),
+             py::arg("radius"), py::arg("center"),
+             py::arg("scale_factor") = 1.0)
+        .def("get_center", &cddp::BallConstraint::getCenter);
+
+    py::class_<cddp::PoleConstraint, cddp::Constraint, nodeleter<cddp::PoleConstraint>>(m, "PoleConstraint")
+        .def(py::init<const Eigen::VectorXd&, char, double, double, double>(),
+             py::arg("center"), py::arg("direction"),
+             py::arg("radius"), py::arg("length"),
+             py::arg("scale_factor") = 1.0);
+
+    py::class_<cddp::SecondOrderConeConstraint, cddp::Constraint, nodeleter<cddp::SecondOrderConeConstraint>>(m, "SecondOrderConeConstraint")
+        .def(py::init<const Eigen::Vector3d&, const Eigen::Vector3d&, double, double, const std::string&>(),
+             py::arg("cone_origin"), py::arg("opening_direction"),
+             py::arg("cone_angle_fov"), py::arg("epsilon") = 1e-6,
+             py::arg("name") = "SecondOrderConeConstraint");
+
+    py::class_<cddp::ThrustMagnitudeConstraint, cddp::Constraint, nodeleter<cddp::ThrustMagnitudeConstraint>>(m, "ThrustMagnitudeConstraint")
+        .def(py::init<double, double, double>(),
+             py::arg("min_thrust"), py::arg("max_thrust"),
+             py::arg("epsilon") = 1e-6);
+
+    py::class_<cddp::MaxThrustMagnitudeConstraint, cddp::Constraint, nodeleter<cddp::MaxThrustMagnitudeConstraint>>(m, "MaxThrustMagnitudeConstraint")
+        .def(py::init<double, double>(),
+             py::arg("max_thrust"), py::arg("epsilon") = 1e-6);
+}