Add CurveReversed class and enhance CurveExtended and CurveRepametrized bindings in Python

Author: ssg-aero

gbs/curveReversed.h

@@ -0,0 +1,60 @@
+#pragma once
+#include <memory>
+#include <gbs/bscurve.h>
+namespace gbs {
+/**
+ * @brief A curve that reverses the parameterization of an underlying curve.
+ *
+ * This class is useful for creating curves that need to be evaluated in reverse,
+ * such as when dealing with control points that are defined in reverse order.
+ */
+template <typename T, size_t dim> class CurveReversed : public Curve<T, dim> 
+{
+private:
+    /**
+     * @brief The underlying curve to be extended.
+     */
+    std::shared_ptr<Curve<T, dim>> m_curve;
+
+public:
+    /**
+     * @brief Construct a new CurveReversed object.
+     *
+     * @param crv Shared pointer to the underlying curve.
+     */
+    CurveReversed(std::shared_ptr<Curve<T, dim>> crv)
+        : m_curve(std::move(crv))
+    {
+    }
+
+    /**
+     * @brief Evaluate the curve (and optionally its derivatives) at the parameter \p u.
+     *
+     * This method reverses the parameterization of the underlying curve.
+     *
+     * @param u The parameter value at which to evaluate the curve.
+     * @param d The order of derivative to compute (0 for value, 1 for first derivative).
+     * @return std::array<T, dim> The evaluated value or derivative at \p u.
+     */
+    virtual auto value(T u, size_t d = 0) const -> std::array<T, dim> override
+    {
+        auto u1 = m_curve->bounds()[0];
+        auto u2 = m_curve->bounds()[1];
+
+        u = u2 - (u - u1); // Reverse the parameterization
+        T sign = (d % 2 == 0) ? 1 : -1;
+
+        return sign * m_curve->value(u, d);
+    }
+
+    virtual auto bounds() const -> std::array<T, 2> override
+    {
+        return m_curve->bounds();
+    }
+
+    const auto & basisCurve() const
+    {
+        return m_curve;
+    }
+};
+} // namespace gbs

gbs/curveextended.h

@@ -156,6 +156,16 @@ class CurveExtended : public Curve<T, dim>
             std::numeric_limits<T>::max()
         };
     }
+
+    const auto & basisCurve() const
+    {
+        return m_curve;
+    }
+
+    bool isClamped() const
+    {
+        return m_clamped;
+    }
 };
 
 } // namespace gbs

gbs/curvereparametrized.h

@@ -8,7 +8,7 @@ namespace gbs{
     class CurveReparametrized : public Curve<T,dim>
     {
         const std::shared_ptr<Curve<T,dim>>   m_p_crv;
-        const BSCfunction<T> m_f_u;
+        BSCfunction<T> m_f_u;
     public:
         CurveReparametrized(const std::shared_ptr<Curve<T,dim>> &crv, const BSCfunction<T> &f_u) : m_p_crv{crv}, m_f_u{f_u} {}
         /**

gbs/curves

@@ -7,4 +7,6 @@
 #include <gbs/curveonsurface.h>
 #include <gbs/curvetrimmed.h>
 #include <gbs/curvecomposite.h>
-#include <gbs/curveextended.h>
+#include <gbs/curveextended.h>
+#include <gbs/curvereparametrized.h>
+#include <gbs/curveReversed.h>

python/gbsBindCurves.h

@@ -259,7 +259,24 @@ inline void gbs_bind_curves(py::module &m)
         , py::arg("crv")
         , py::arg("clamped") = false
         )
-    ;
+        .def("basisCurve", &gbs::CurveExtended<T, dim>::basisCurve, "Get the basis curve")
+        .def("isClamped", &gbs::CurveExtended<T, dim>::isClamped, "Check if the curve is clamped")
+        .def(py::pickle(
+            [](CurveExtended<T, dim> &crv) {
+                return py::make_tuple(// __getstate__
+                        crv.basisCurve(),
+                        crv.isClamped()
+                );
+            },
+            [](py::tuple t) { // __setstate__
+                if (t.size() != 2)
+                    throw std::runtime_error("Invalid state!");
+                return CurveExtended<T, dim>{
+                    t[0].cast<std::shared_ptr<gbs::Curve<T, dim>>>(),
+                    t[1].cast<bool>()
+                };
+            }
+        ));
 
 
     py::class_<
@@ -268,4 +285,55 @@ inline void gbs_bind_curves(py::module &m)
             gbs::Curve<T, dim>
     >(m, add_ext<dim>("CurveOffset_func_base").c_str() );
 
+
+    py::class_<
+            gbs::CurveReversed<T, dim>, 
+            std::shared_ptr<gbs::CurveReversed<T, dim>>, 
+            gbs::Curve<T, dim>
+    >(m, add_ext<dim>("CurveReversed").c_str())
+    .def(py::init<std::shared_ptr<gbs::Curve<T, dim>>>(), py::arg("crv"))
+    .def("basisCurve",&gbs::CurveReversed<T, dim>::basisCurve)
+    .def(py::pickle(
+        [](CurveReversed<T, dim> &crv) {
+            return py::make_tuple(// __getstate__
+                crv.basisCurve()
+            );
+        },
+        [](py::tuple t) { // __setstate__
+            if (t.size() != 1)
+                throw std::runtime_error("Invalid state!");
+            return CurveReversed<T, dim>{
+                t[0].cast<std::shared_ptr<gbs::Curve<T, dim>>>()
+            };
+        }
+    ))
+    ;
+
+    py::class_<
+            gbs::CurveReparametrized<T, dim>, 
+            std::shared_ptr<gbs::CurveReparametrized<T, dim>>, 
+            gbs::Curve<T, dim>
+        >(m, add_ext<dim>("CurveReparametrized").c_str())
+        .def(py::init<const std::shared_ptr<gbs::Curve<T, dim>> &, const BSCfunction<T> &>(),
+                py::arg("crv"), py::arg("f_u"))
+        .def("basisCurve",&gbs::CurveReparametrized<T, dim>::basisCurve)
+        .def("paramFunction",&gbs::CurveReparametrized<T, dim>::paramFunction)
+        .def("setParamFunction",&gbs::CurveReparametrized<T, dim>::setParamFunction, py::arg("f_u"))
+        .def(py::pickle(
+                [](CurveReparametrized<T, dim> &crv) {
+                return py::make_tuple(// __getstate__
+                        crv.basisCurve(),
+                        crv.paramFunction()
+                );
+                },
+                [](py::tuple t) { // __setstate__
+                if (t.size() != 2)
+                        throw std::runtime_error("Invalid state!");
+                return CurveReparametrized<T, dim>{
+                        t[0].cast<std::shared_ptr<gbs::Curve<T, dim>>>(),
+                        t[1].cast<BSCfunction<T>>()
+                };
+                }
+        ))
+    ;
 }