curves.hpp

Go to the documentation of this file.

// Copyright (c) 2026 Capgemini Engineering Research and Development.
//
// This file is part of OCCT-Light software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Affero General Public License version 3 as published
// by the Free Software Foundation, with an option to use any later version.
// Consult the file LICENSE_AGPL_30.txt included in OCCT-Light distribution
// for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of a commercial
// license or contractual agreement.
//
// SPDX-License-Identifier: AGPL-3.0-or-later
 
#ifndef OCCTL_HPP_CURVES_HPP
#define OCCTL_HPP_CURVES_HPP
 
#include <occtl/occtl_curves.h>
 
#include <occtl-hpp/core.hpp>
#include <occtl-hpp/geom.hpp>
 
#include <cstdint>
#include <cstdlib>
#include <tuple>
#include <utility>
#include <vector>
 
#if defined(__cpp_lib_span) && __cpp_lib_span >= 202002L
  #include <span>
  #define OCCTL_HPP_HAS_SPAN 1
#else
  #define OCCTL_HPP_HAS_SPAN 0
#endif
 
namespace occtl
{
 
class Curve
{
public:
  Curve(occtl_graph_t* theGraph = nullptr, occtl_rep_id_t theId = occtl_rep_id_t{0}) noexcept
      : myGraph(theGraph),
        myId(theId)
  {
  }
 
  explicit operator bool() const noexcept { return myGraph != nullptr && myId.bits != 0; }
 
  occtl_graph_t* graph() const noexcept { return myGraph; }
 
  occtl_rep_id_t id() const noexcept { return myId; }
 
  Curve reversed() const
  {
    occtl_rep_id_t aId{};
    check(::occtl_curve_reverse(myGraph, myId, &aId));
    return Curve(myGraph, aId);
  }
 
  Curve transformed(const Transform& theTrsf) const
  {
    occtl_rep_id_t aId{};
    check(::occtl_curve_transformed(myGraph, myId, theTrsf.c_type(), &aId));
    return Curve(myGraph, aId);
  }
 
  Curve translated(const Vector3& theDelta) const
  {
    occtl_rep_id_t aId{};
    check(::occtl_curve_translated(myGraph, myId, theDelta.c_type(), &aId));
    return Curve(myGraph, aId);
  }
 
  Curve rotated(const Axis1Placement& theAxis, double theAngle) const
  {
    occtl_rep_id_t aId{};
    check(::occtl_curve_rotated(myGraph, myId, theAxis.c_type(), theAngle, &aId));
    return Curve(myGraph, aId);
  }
 
  Curve scaled(const Point3& theOrigin, double theFactor) const
  {
    occtl_rep_id_t aId{};
    check(::occtl_curve_scaled(myGraph, myId, theOrigin.c_type(), theFactor, &aId));
    return Curve(myGraph, aId);
  }
 
  double length() const
  {
    double aLen = 0.0;
    check(::occtl_curve_length(myGraph, myId, &aLen));
    return aLen;
  }
 
  std::pair<double, double> project_point(const Point3& thePoint) const
  {
    double aParam = 0.0;
    double aDist  = 0.0;
    check(::occtl_curve_project_point(myGraph, myId, thePoint.c_type(), &aParam, &aDist));
    return {aParam, aDist};
  }
 
  double parameter_of_point(const Point3& thePoint) const
  {
    double aParam = 0.0;
    check(::occtl_curve_parameter_of_point(myGraph, myId, thePoint.c_type(), &aParam));
    return aParam;
  }
 
  occtl_curve_kind_t kind() const
  {
    occtl_curve_kind_t aKind{};
    check(::occtl_curve_kind(myGraph, myId, &aKind));
    return aKind;
  }
 
  int32_t is_periodic() const
  {
    int32_t aVal = 0;
    check(::occtl_curve_is_periodic(myGraph, myId, &aVal));
    return aVal;
  }
 
  int32_t is_closed() const
  {
    int32_t aVal = 0;
    check(::occtl_curve_is_closed(myGraph, myId, &aVal));
    return aVal;
  }
 
  occtl_geom_continuity_t continuity() const
  {
    occtl_geom_continuity_t aCont{};
    check(::occtl_curve_continuity(myGraph, myId, &aCont));
    return aCont;
  }
 
  void parameter_range(double& theUMin, double& theUMax) const
  {
    check(::occtl_curve_parameter_range(myGraph, myId, &theUMin, &theUMax));
  }
 
  occtl_geom_line_t as_line() const
  {
    occtl_geom_line_t aOut{};
    check(::occtl_curve_as_line(myGraph, myId, &aOut));
    return aOut;
  }
 
  occtl_geom_circle_t as_circle() const
  {
    occtl_geom_circle_t aOut{};
    check(::occtl_curve_as_circle(myGraph, myId, &aOut));
    return aOut;
  }
 
  occtl_geom_ellipse_t as_ellipse() const
  {
    occtl_geom_ellipse_t aOut{};
    check(::occtl_curve_as_ellipse(myGraph, myId, &aOut));
    return aOut;
  }
 
  occtl_geom_hyperbola_t as_hyperbola() const
  {
    occtl_geom_hyperbola_t aOut{};
    check(::occtl_curve_as_hyperbola(myGraph, myId, &aOut));
    return aOut;
  }
 
  occtl_geom_parabola_t as_parabola() const
  {
    occtl_geom_parabola_t aOut{};
    check(::occtl_curve_as_parabola(myGraph, myId, &aOut));
    return aOut;
  }
 
  struct TrimmedView;
  struct OffsetView;
  struct BSplineView;
 
  inline TrimmedView as_trimmed() const;
 
  inline OffsetView as_offset() const;
 
  inline BSplineView as_bspline() const;
 
  int32_t bspline_degree() const
  {
    int32_t aVal = 0;
    check(::occtl_curve_bspline_degree(myGraph, myId, &aVal));
    return aVal;
  }
 
  size_t bspline_pole_count() const
  {
    size_t aVal = 0;
    check(::occtl_curve_bspline_pole_count(myGraph, myId, &aVal));
    return aVal;
  }
 
  size_t bspline_knot_count() const
  {
    size_t aVal = 0;
    check(::occtl_curve_bspline_knot_count(myGraph, myId, &aVal));
    return aVal;
  }
 
  int32_t bspline_is_rational() const
  {
    int32_t aVal = 0;
    check(::occtl_curve_bspline_is_rational(myGraph, myId, &aVal));
    return aVal;
  }
 
  int32_t bezier_degree() const
  {
    int32_t aVal = 0;
    check(::occtl_curve_bezier_degree(myGraph, myId, &aVal));
    return aVal;
  }
 
  size_t bezier_pole_count() const
  {
    size_t aVal = 0;
    check(::occtl_curve_bezier_pole_count(myGraph, myId, &aVal));
    return aVal;
  }
 
  int32_t bezier_is_rational() const
  {
    int32_t aVal = 0;
    check(::occtl_curve_bezier_is_rational(myGraph, myId, &aVal));
    return aVal;
  }
 
  std::vector<occtl_point3_t> bspline_poles() const
  {
    size_t aNb = 0;
    check(::occtl_curve_bspline_poles(myGraph, myId, nullptr, 0, &aNb));
    std::vector<occtl_point3_t> aVec(aNb);
    check(::occtl_curve_bspline_poles(myGraph, myId, aVec.data(), aNb, &aNb));
    return aVec;
  }
 
  std::vector<double> bspline_knots() const
  {
    size_t aNb = 0;
    check(::occtl_curve_bspline_knots(myGraph, myId, nullptr, 0, &aNb));
    std::vector<double> aVec(aNb);
    check(::occtl_curve_bspline_knots(myGraph, myId, aVec.data(), aNb, &aNb));
    return aVec;
  }
 
  std::vector<int32_t> bspline_multiplicities() const
  {
    size_t aNb = 0;
    check(::occtl_curve_bspline_multiplicities(myGraph, myId, nullptr, 0, &aNb));
    std::vector<int32_t> aVec(aNb);
    check(::occtl_curve_bspline_multiplicities(myGraph, myId, aVec.data(), aNb, &aNb));
    return aVec;
  }
 
  std::vector<double> bspline_weights() const
  {
    size_t aNb = 0;
    check(::occtl_curve_bspline_weights(myGraph, myId, nullptr, 0, &aNb));
    std::vector<double> aVec(aNb);
    check(::occtl_curve_bspline_weights(myGraph, myId, aVec.data(), aNb, &aNb));
    return aVec;
  }
 
  std::vector<double> bspline_flat_knots() const
  {
    size_t aNb = 0;
    check(::occtl_curve_bspline_flat_knots(myGraph, myId, nullptr, 0, &aNb));
    std::vector<double> aVec(aNb);
    check(::occtl_curve_bspline_flat_knots(myGraph, myId, aVec.data(), aNb, &aNb));
    return aVec;
  }
 
  const occtl_point3_t* bspline_poles_view(size_t& theCount) const
  {
    const occtl_point3_t* aData = nullptr;
    check(::occtl_curve_bspline_poles_view(myGraph, myId, &aData, &theCount));
    return aData;
  }
 
  static Curve from_line(occtl_graph_t* graph, const occtl_geom_line_t& theLine)
  {
    occtl_rep_id_t aId{};
    check(::occtl_curve_create_line(graph, theLine, &aId));
    return Curve(graph, aId);
  }
 
  static Curve from_circle(occtl_graph_t* graph, const occtl_geom_circle_t& theCircle)
  {
    occtl_rep_id_t aId{};
    check(::occtl_curve_create_circle(graph, theCircle, &aId));
    return Curve(graph, aId);
  }
 
  static Curve from_ellipse(occtl_graph_t* graph, const occtl_geom_ellipse_t& theEllipse)
  {
    occtl_rep_id_t aId{};
    check(::occtl_curve_create_ellipse(graph, theEllipse, &aId));
    return Curve(graph, aId);
  }
 
  static Curve from_hyperbola(occtl_graph_t* graph, const occtl_geom_hyperbola_t& theHyperbola)
  {
    occtl_rep_id_t aId{};
    check(::occtl_curve_create_hyperbola(graph, theHyperbola, &aId));
    return Curve(graph, aId);
  }
 
  static Curve from_parabola(occtl_graph_t* graph, const occtl_geom_parabola_t& theParabola)
  {
    occtl_rep_id_t aId{};
    check(::occtl_curve_create_parabola(graph, theParabola, &aId));
    return Curve(graph, aId);
  }
 
  static Curve from_bspline(occtl_graph_t* graph, const occtl_curve_bspline_create_info_t& theInfo)
  {
    occtl_rep_id_t aId{};
    check(::occtl_curve_create_bspline(graph, &theInfo, &aId));
    return Curve(graph, aId);
  }
 
  static Curve from_bezier(occtl_graph_t* graph, const occtl_curve_bezier_create_info_t& theInfo)
  {
    occtl_rep_id_t aId{};
    check(::occtl_curve_create_bezier(graph, &theInfo, &aId));
    return Curve(graph, aId);
  }
 
  static Curve from_trimmed(occtl_graph_t* graph, const occtl_curve_trimmed_create_info_t& theInfo)
  {
    occtl_rep_id_t aId{};
    check(::occtl_curve_create_trimmed(graph, &theInfo, &aId));
    return Curve(graph, aId);
  }
 
  static Curve from_offset(occtl_graph_t* graph, const occtl_curve_offset_create_info_t& theInfo)
  {
    occtl_rep_id_t aId{};
    check(::occtl_curve_create_offset(graph, &theInfo, &aId));
    return Curve(graph, aId);
  }
 
  static Curve from_interpolation(occtl_graph_t*                         graph,
                                  const occtl_curve_interpolated_info_t& theInfo)
  {
    occtl_rep_id_t aId{};
    check(::occtl_curve_create_interpolated(graph, &theInfo, &aId));
    return Curve(graph, aId);
  }
 
  static Curve from_approximation(occtl_graph_t*                         graph,
                                  const occtl_curve_approximated_info_t& theInfo)
  {
    occtl_rep_id_t aId{};
    check(::occtl_curve_create_approximated(graph, &theInfo, &aId));
    return Curve(graph, aId);
  }
 
  static Curve from_airfoil_naca4(occtl_graph_t*                          graph,
                                  const occtl_curve_airfoil_naca4_info_t& theInfo)
  {
    occtl_rep_id_t aId{};
    check(::occtl_curve_create_airfoil_naca4(graph, &theInfo, &aId));
    return Curve(graph, aId);
  }
 
  struct IntersectionPoint;
  std::vector<IntersectionPoint> intersect_with(const Curve& theOther) const;
 
  occtl_point3_t eval_d0(const double theU) const
  {
    occtl_point3_t aP{};
    check(::occtl_curve_eval_d0(myGraph, myId, theU, &aP));
    return aP;
  }
 
  std::pair<occtl_point3_t, occtl_vector3_t> eval_d1(const double theU) const
  {
    occtl_point3_t  aP{};
    occtl_vector3_t aD1{};
    check(::occtl_curve_eval_d1(myGraph, myId, theU, &aP, &aD1));
    return {aP, aD1};
  }
 
  std::tuple<occtl_point3_t, occtl_vector3_t, occtl_vector3_t> eval_d2(const double theU) const
  {
    occtl_point3_t  aP{};
    occtl_vector3_t aD1{}, aD2{};
    check(::occtl_curve_eval_d2(myGraph, myId, theU, &aP, &aD1, &aD2));
    return {aP, aD1, aD2};
  }
 
  std::tuple<occtl_point3_t, occtl_vector3_t, occtl_vector3_t, occtl_vector3_t> eval_d3(
    const double theU) const
  {
    occtl_point3_t  aP{};
    occtl_vector3_t aD1{}, aD2{}, aD3{};
    check(::occtl_curve_eval_d3(myGraph, myId, theU, &aP, &aD1, &aD2, &aD3));
    return {aP, aD1, aD2, aD3};
  }
 
  occtl_vector3_t eval_dn(const double theU, const int32_t theN) const
  {
    occtl_vector3_t aDN{};
    check(::occtl_curve_eval_dn(myGraph, myId, theU, theN, &aDN));
    return aDN;
  }
 
private:
  occtl_graph_t* myGraph;
  occtl_rep_id_t myId;
};
 
struct Curve::TrimmedView
{
  double u_first;
  double u_last;
};
 
struct Curve::OffsetView
{
  double          offset;
  occtl_vector3_t offset_dir;
};
 
struct Curve::IntersectionPoint
{
  occtl_point3_t point;   
  double         param_a; 
  double         param_b; 
};
 
inline Curve::TrimmedView Curve::as_trimmed() const
{
  double aU0 = 0.0;
  double aU1 = 0.0;
  check(::occtl_curve_as_trimmed(myGraph, myId, &aU0, &aU1));
  return {aU0, aU1};
}
 
inline Curve::OffsetView Curve::as_offset() const
{
  double          aOff = 0.0;
  occtl_vector3_t aDir{};
  check(::occtl_curve_as_offset(myGraph, myId, &aOff, &aDir));
  return {aOff, aDir};
}
 
struct Curve::BSplineView
{
  occtl_curve_bspline_t raw;
 
  int32_t degree() const noexcept { return raw.degree; }
 
  bool is_rational() const noexcept { return raw.is_rational != 0; }
 
  bool is_periodic() const noexcept { return raw.is_periodic != 0; }
 
  bool is_closed() const noexcept { return raw.is_closed != 0; }
 
  occtl_geom_continuity_t continuity() const noexcept
  {
    return static_cast<occtl_geom_continuity_t>(raw.continuity);
  }
 
  size_t pole_count() const noexcept { return raw.pole_count; }
 
  size_t knot_count() const noexcept { return raw.knot_count; }
 
  size_t flat_knot_count() const noexcept { return raw.flat_knot_count; }
 
#if OCCTL_HPP_HAS_SPAN
  std::span<const occtl_point3_t> poles() const noexcept { return {raw.poles, raw.pole_count}; }
 
  std::span<const double> weights() const noexcept
  {
    return raw.weights ? std::span<const double>{raw.weights, raw.pole_count}
                       : std::span<const double>{};
  }
 
  std::span<const double> knots() const noexcept { return {raw.knots, raw.knot_count}; }
 
  std::span<const int32_t> multiplicities() const noexcept
  {
    return {raw.multiplicities, raw.knot_count};
  }
 
  std::span<const double> flat_knots() const noexcept
  {
    return {raw.flat_knots, raw.flat_knot_count};
  }
#else
  const occtl_point3_t* poles() const noexcept { return raw.poles; }
 
  const double* weights() const noexcept { return raw.weights; }
 
  const double* knots() const noexcept { return raw.knots; }
 
  const int32_t* multiplicities() const noexcept { return raw.multiplicities; }
 
  const double* flat_knots() const noexcept { return raw.flat_knots; }
#endif
};
 
inline Curve::BSplineView Curve::as_bspline() const
{
  BSplineView aView{};
  aView.raw = OCCTL_CURVE_BSPLINE_INIT;
  check(::occtl_curve_as_bspline(myGraph, myId, &aView.raw));
  return aView;
}
 
inline std::vector<Curve::IntersectionPoint> Curve::intersect_with(const Curve& theOther) const
{
  const occtl_curve_intersection_point_t* aRaw = nullptr;
  size_t                                  aNb  = 0;
  check(::occtl_curve_intersect(myGraph, myId, theOther.myId, &aRaw, &aNb));
  std::vector<IntersectionPoint> aResult(aNb);
  for (size_t anI = 0; anI < aNb; ++anI)
  {
    aResult[anI] = {aRaw[anI].point, aRaw[anI].param_a, aRaw[anI].param_b};
  }
  std::free(const_cast<occtl_curve_intersection_point_t*>(aRaw));
  return aResult;
}
 
} // namespace occtl
 
#endif // OCCTL_HPP_CURVES_HPP