occtl_curves2d.h

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_CURVES2D_H
#define OCCTL_CURVES2D_H
 
#include <stddef.h>
#include <stdint.h>
 
#include "occtl_core.h"
#include "occtl_curves_common.h"
#include "occtl_geom.h"
 
#ifdef __cplusplus
extern "C"
{
#endif
 
typedef struct occtl_graph occtl_graph_t;
 
typedef struct occtl_curve2d_circle_tangent_to_two_radius_info
{
  uint32_t
    struct_version; 
  const void*                        p_next;      
  occtl_rep_id_t                     curve_a;     
  occtl_curve2d_tangency_qualifier_t qualifier_a; 
  occtl_rep_id_t                     curve_b;     
  occtl_curve2d_tangency_qualifier_t qualifier_b; 
  double                             radius;      
  double tolerance; 
} occtl_curve2d_circle_tangent_to_two_radius_info_t;
 
#define OCCTL_CURVE2D_CIRCLE_TANGENT_TO_TWO_RADIUS_INFO_VERSION_1 1u
 
#define OCCTL_CURVE2D_CIRCLE_TANGENT_TO_TWO_RADIUS_INFO_INIT                                       \
  {OCCTL_CURVE2D_CIRCLE_TANGENT_TO_TWO_RADIUS_INFO_VERSION_1,                                      \
   NULL,                                                                                           \
   {0},                                                                                            \
   OCCTL_GEOM_TANGENCY_UNQUALIFIED,                                                                \
   {0},                                                                                            \
   OCCTL_GEOM_TANGENCY_UNQUALIFIED,                                                                \
   0.0,                                                                                            \
   1.0e-9}
 
OCCTL_API void OCCTL_CALL occtl_curve2d_circle_tangent_to_two_radius_info_init(
  occtl_curve2d_circle_tangent_to_two_radius_info_t* info);
 
typedef struct occtl_curve2d_blend_arc_info
{
  uint32_t       struct_version; 
  const void*    p_next;         
  occtl_rep_id_t curve_a;        
  occtl_curve2d_tangency_qualifier_t qualifier_a; 
  occtl_rep_id_t                     curve_b;     
  occtl_curve2d_tangency_qualifier_t qualifier_b; 
  double                             radius;      
  int32_t long_arc;  
  double  tolerance; 
} occtl_curve2d_blend_arc_info_t;
 
#define OCCTL_CURVE2D_BLEND_ARC_INFO_VERSION_1 1u
 
#define OCCTL_CURVE2D_BLEND_ARC_INFO_INIT                                                          \
  {OCCTL_CURVE2D_BLEND_ARC_INFO_VERSION_1,                                                         \
   NULL,                                                                                           \
   {0},                                                                                            \
   OCCTL_GEOM_TANGENCY_UNQUALIFIED,                                                                \
   {0},                                                                                            \
   OCCTL_GEOM_TANGENCY_UNQUALIFIED,                                                                \
   0.0,                                                                                            \
   0,                                                                                              \
   1.0e-9}
 
OCCTL_API void OCCTL_CALL occtl_curve2d_blend_arc_info_init(occtl_curve2d_blend_arc_info_t* info);
 
typedef struct occtl_curve2d_line_tangent_to_two_info
{
  uint32_t       struct_version; 
  const void*    p_next;         
  occtl_rep_id_t curve_a;        
  occtl_curve2d_tangency_qualifier_t qualifier_a; 
  occtl_rep_id_t                     curve_b;     
  occtl_curve2d_tangency_qualifier_t qualifier_b; 
  double tolerance; 
} occtl_curve2d_line_tangent_to_two_info_t;
 
#define OCCTL_CURVE2D_LINE_TANGENT_TO_TWO_INFO_VERSION_1 1u
 
#define OCCTL_CURVE2D_LINE_TANGENT_TO_TWO_INFO_INIT                                                \
  {OCCTL_CURVE2D_LINE_TANGENT_TO_TWO_INFO_VERSION_1,                                               \
   NULL,                                                                                           \
   {0},                                                                                            \
   OCCTL_GEOM_TANGENCY_UNQUALIFIED,                                                                \
   {0},                                                                                            \
   OCCTL_GEOM_TANGENCY_UNQUALIFIED,                                                                \
   1.0e-9}
 
OCCTL_API void OCCTL_CALL
  occtl_curve2d_line_tangent_to_two_info_init(occtl_curve2d_line_tangent_to_two_info_t* info);
 
typedef struct occtl_curve2d_line_tangent_through_point_info
{
  uint32_t struct_version; 
  const void*                        p_next;    
  occtl_rep_id_t                     curve;     
  occtl_curve2d_tangency_qualifier_t qualifier; 
  occtl_point2_t                     point;     
  double tolerance; 
} occtl_curve2d_line_tangent_through_point_info_t;
 
#define OCCTL_CURVE2D_LINE_TANGENT_THROUGH_POINT_INFO_VERSION_1 1u
 
#define OCCTL_CURVE2D_LINE_TANGENT_THROUGH_POINT_INFO_INIT                                         \
  {OCCTL_CURVE2D_LINE_TANGENT_THROUGH_POINT_INFO_VERSION_1,                                        \
   NULL,                                                                                           \
   {0},                                                                                            \
   OCCTL_GEOM_TANGENCY_UNQUALIFIED,                                                                \
   {0.0, 0.0},                                                                                     \
   1.0e-9}
 
OCCTL_API void OCCTL_CALL occtl_curve2d_line_tangent_through_point_info_init(
  occtl_curve2d_line_tangent_through_point_info_t* info);
 
typedef struct occtl_curve2d_line_tangent_with_angle_info
{
  uint32_t    struct_version; 
  const void* p_next;         
  occtl_rep_id_t                     curve;     
  occtl_curve2d_tangency_qualifier_t qualifier; 
  occtl_geom2d_line_t reference_line;           
  double              angle_radians; 
  int32_t use_initial_parameter; 
  double
    initial_parameter; 
  double tolerance;    
} occtl_curve2d_line_tangent_with_angle_info_t;
 
#define OCCTL_CURVE2D_LINE_TANGENT_WITH_ANGLE_INFO_VERSION_1 1u
 
#define OCCTL_CURVE2D_LINE_TANGENT_WITH_ANGLE_INFO_INIT                                            \
  {OCCTL_CURVE2D_LINE_TANGENT_WITH_ANGLE_INFO_VERSION_1,                                           \
   NULL,                                                                                           \
   {0},                                                                                            \
   OCCTL_GEOM_TANGENCY_UNQUALIFIED,                                                                \
   {{{0.0, 0.0}, {1.0, 0.0}}},                                                                     \
   0.0,                                                                                            \
   0,                                                                                              \
   0.0,                                                                                            \
   1.0e-9}
 
OCCTL_API void OCCTL_CALL occtl_curve2d_line_tangent_with_angle_info_init(
  occtl_curve2d_line_tangent_with_angle_info_t* info);
 
typedef struct occtl_curve2d_circle_tangent_to_three_info
{
  uint32_t    struct_version; 
  const void* p_next;         
  occtl_rep_id_t                     curve_a;     
  occtl_curve2d_tangency_qualifier_t qualifier_a; 
  occtl_rep_id_t                     curve_b;     
  occtl_curve2d_tangency_qualifier_t qualifier_b; 
  occtl_rep_id_t                     curve_c;     
  occtl_curve2d_tangency_qualifier_t qualifier_c; 
  double initial_parameter_a; 
  double initial_parameter_b; 
  double initial_parameter_c; 
  double tolerance;           
} occtl_curve2d_circle_tangent_to_three_info_t;
 
#define OCCTL_CURVE2D_CIRCLE_TANGENT_TO_THREE_INFO_VERSION_1 1u
 
#define OCCTL_CURVE2D_CIRCLE_TANGENT_TO_THREE_INFO_INIT                                            \
  {OCCTL_CURVE2D_CIRCLE_TANGENT_TO_THREE_INFO_VERSION_1,                                           \
   NULL,                                                                                           \
   {0},                                                                                            \
   OCCTL_GEOM_TANGENCY_UNQUALIFIED,                                                                \
   {0},                                                                                            \
   OCCTL_GEOM_TANGENCY_UNQUALIFIED,                                                                \
   {0},                                                                                            \
   OCCTL_GEOM_TANGENCY_UNQUALIFIED,                                                                \
   0.0,                                                                                            \
   0.0,                                                                                            \
   0.0,                                                                                            \
   1.0e-9}
 
OCCTL_API void OCCTL_CALL occtl_curve2d_circle_tangent_to_three_info_init(
  occtl_curve2d_circle_tangent_to_three_info_t* info);
 
typedef struct occtl_curve2d_circle_tangent_fixed_center_info
{
  uint32_t
    struct_version; 
  const void*                        p_next;    
  occtl_rep_id_t                     curve;     
  occtl_curve2d_tangency_qualifier_t qualifier; 
  occtl_point2_t                     center;    
  double tolerance; 
} occtl_curve2d_circle_tangent_fixed_center_info_t;
 
#define OCCTL_CURVE2D_CIRCLE_TANGENT_FIXED_CENTER_INFO_VERSION_1 1u
 
#define OCCTL_CURVE2D_CIRCLE_TANGENT_FIXED_CENTER_INFO_INIT                                        \
  {OCCTL_CURVE2D_CIRCLE_TANGENT_FIXED_CENTER_INFO_VERSION_1,                                       \
   NULL,                                                                                           \
   {0},                                                                                            \
   OCCTL_GEOM_TANGENCY_UNQUALIFIED,                                                                \
   {0.0, 0.0},                                                                                     \
   1.0e-9}
 
OCCTL_API void OCCTL_CALL occtl_curve2d_circle_tangent_fixed_center_info_init(
  occtl_curve2d_circle_tangent_fixed_center_info_t* info);
 
typedef struct occtl_curve2d_circle_tangent_center_on_curve_info
{
  uint32_t
    struct_version; 
  const void*                        p_next;      
  occtl_rep_id_t                     curve_a;     
  occtl_curve2d_tangency_qualifier_t qualifier_a; 
  occtl_rep_id_t                     curve_b;     
  occtl_curve2d_tangency_qualifier_t qualifier_b; 
  occtl_rep_id_t center_curve; 
  double initial_parameter_a;  
  double initial_parameter_b;  
  double initial_parameter_center; 
  double tolerance;                
} occtl_curve2d_circle_tangent_center_on_curve_info_t;
 
#define OCCTL_CURVE2D_CIRCLE_TANGENT_CENTER_ON_CURVE_INFO_VERSION_1 1u
 
#define OCCTL_CURVE2D_CIRCLE_TANGENT_CENTER_ON_CURVE_INFO_INIT                                     \
  {OCCTL_CURVE2D_CIRCLE_TANGENT_CENTER_ON_CURVE_INFO_VERSION_1,                                    \
   NULL,                                                                                           \
   {0},                                                                                            \
   OCCTL_GEOM_TANGENCY_UNQUALIFIED,                                                                \
   {0},                                                                                            \
   OCCTL_GEOM_TANGENCY_UNQUALIFIED,                                                                \
   {0},                                                                                            \
   0.0,                                                                                            \
   0.0,                                                                                            \
   0.0,                                                                                            \
   1.0e-9}
 
OCCTL_API void OCCTL_CALL occtl_curve2d_circle_tangent_center_on_curve_info_init(
  occtl_curve2d_circle_tangent_center_on_curve_info_t* info);
 
typedef struct occtl_curve2d_circle_tangent_on_curve_radius_info
{
  uint32_t
    struct_version; 
  const void*                        p_next;    
  occtl_rep_id_t                     curve;     
  occtl_curve2d_tangency_qualifier_t qualifier; 
  occtl_rep_id_t center_curve; 
  double         radius;       
  double         tolerance;    
} occtl_curve2d_circle_tangent_on_curve_radius_info_t;
 
#define OCCTL_CURVE2D_CIRCLE_TANGENT_ON_CURVE_RADIUS_INFO_VERSION_1 1u
 
#define OCCTL_CURVE2D_CIRCLE_TANGENT_ON_CURVE_RADIUS_INFO_INIT                                     \
  {OCCTL_CURVE2D_CIRCLE_TANGENT_ON_CURVE_RADIUS_INFO_VERSION_1,                                    \
   NULL,                                                                                           \
   {0},                                                                                            \
   OCCTL_GEOM_TANGENCY_UNQUALIFIED,                                                                \
   {0},                                                                                            \
   0.0,                                                                                            \
   1.0e-9}
 
OCCTL_API void OCCTL_CALL occtl_curve2d_circle_tangent_on_curve_radius_info_init(
  occtl_curve2d_circle_tangent_on_curve_radius_info_t* info);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_create_tangent_circle_to_two_radius(
  occtl_graph_t*                                           graph,
  const occtl_curve2d_circle_tangent_to_two_radius_info_t* info,
  size_t                                                   solution_index,
  occtl_geom2d_circle_t*                                   out_circle,
  size_t*                                                  out_count);
 
OCCTL_API occtl_status_t OCCTL_CALL
  occtl_curve2d_create_blend_arc(occtl_graph_t*                        graph,
                                 const occtl_curve2d_blend_arc_info_t* info,
                                 size_t                                solution_index,
                                 occtl_rep_id_t*                       out_id,
                                 size_t*                               out_count);
 
OCCTL_API occtl_status_t OCCTL_CALL
  occtl_curve2d_create_tangent_line_to_two(occtl_graph_t*                                  graph,
                                           const occtl_curve2d_line_tangent_to_two_info_t* info,
                                           size_t               solution_index,
                                           occtl_geom2d_line_t* out_line,
                                           size_t*              out_count);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_create_tangent_line_through_point(
  occtl_graph_t*                                         graph,
  const occtl_curve2d_line_tangent_through_point_info_t* info,
  size_t                                                 solution_index,
  occtl_geom2d_line_t*                                   out_line,
  size_t*                                                out_count);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_create_tangent_line_with_angle(
  occtl_graph_t*                                      graph,
  const occtl_curve2d_line_tangent_with_angle_info_t* info,
  size_t                                              solution_index,
  occtl_geom2d_line_t*                                out_line,
  size_t*                                             out_count);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_create_tangent_circle_to_three(
  occtl_graph_t*                                      graph,
  const occtl_curve2d_circle_tangent_to_three_info_t* info,
  size_t                                              solution_index,
  occtl_geom2d_circle_t*                              out_circle,
  size_t*                                             out_count);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_create_tangent_circle_fixed_center(
  occtl_graph_t*                                          graph,
  const occtl_curve2d_circle_tangent_fixed_center_info_t* info,
  size_t                                                  solution_index,
  occtl_geom2d_circle_t*                                  out_circle,
  size_t*                                                 out_count);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_create_tangent_circle_center_on_curve(
  occtl_graph_t*                                             graph,
  const occtl_curve2d_circle_tangent_center_on_curve_info_t* info,
  size_t                                                     solution_index,
  occtl_geom2d_circle_t*                                     out_circle,
  size_t*                                                    out_count);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_create_tangent_circle_on_curve_radius(
  occtl_graph_t*                                             graph,
  const occtl_curve2d_circle_tangent_on_curve_radius_info_t* info,
  size_t                                                     solution_index,
  occtl_geom2d_circle_t*                                     out_circle,
  size_t*                                                    out_count);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_create_line(occtl_graph_t*      graph,
                                                              occtl_geom2d_line_t line,
                                                              occtl_rep_id_t*     out_id);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_create_circle(occtl_graph_t*        graph,
                                                                occtl_geom2d_circle_t circle,
                                                                occtl_rep_id_t*       out_id);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_create_ellipse(occtl_graph_t*         graph,
                                                                 occtl_geom2d_ellipse_t ellipse,
                                                                 occtl_rep_id_t*        out_id);
 
OCCTL_API occtl_status_t OCCTL_CALL
  occtl_curve2d_create_hyperbola(occtl_graph_t*           graph,
                                 occtl_geom2d_hyperbola_t hyperbola,
                                 occtl_rep_id_t*          out_id);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_create_parabola(occtl_graph_t*          graph,
                                                                  occtl_geom2d_parabola_t parabola,
                                                                  occtl_rep_id_t*         out_id);
 
typedef struct occtl_curve2d_bspline_create_info
{
  uint32_t    struct_version;  
  const void* p_next;          
  const occtl_point2_t* poles; 
  size_t                pole_count;
  const double*         weights; 
  const double*         knots;   
  const int32_t*        multiplicities; 
  size_t                knot_count;
  int32_t               degree;
  int32_t               is_periodic;
} occtl_curve2d_bspline_create_info_t;
 
#define OCCTL_CURVE2D_BSPLINE_CREATE_INFO_VERSION_1 1u
 
#define OCCTL_CURVE2D_BSPLINE_CREATE_INFO_INIT                                                     \
  {OCCTL_CURVE2D_BSPLINE_CREATE_INFO_VERSION_1, NULL, NULL, 0, NULL, NULL, NULL, 0, 0, 0}
 
OCCTL_API void OCCTL_CALL
  occtl_curve2d_bspline_create_info_init(occtl_curve2d_bspline_create_info_t* info);
 
OCCTL_API occtl_status_t OCCTL_CALL
  occtl_curve2d_create_bspline(occtl_graph_t*                             graph,
                               const occtl_curve2d_bspline_create_info_t* info,
                               occtl_rep_id_t*                            out_id);
 
typedef struct occtl_curve2d_bezier_create_info
{
  uint32_t              struct_version; 
  const void*           p_next;         
  const occtl_point2_t* poles;
  size_t                pole_count;
  const double*         weights; 
} occtl_curve2d_bezier_create_info_t;
 
#define OCCTL_CURVE2D_BEZIER_CREATE_INFO_VERSION_1 1u
 
#define OCCTL_CURVE2D_BEZIER_CREATE_INFO_INIT                                                      \
  {OCCTL_CURVE2D_BEZIER_CREATE_INFO_VERSION_1, NULL, NULL, 0, NULL}
 
OCCTL_API void OCCTL_CALL
  occtl_curve2d_bezier_create_info_init(occtl_curve2d_bezier_create_info_t* info);
 
OCCTL_API occtl_status_t OCCTL_CALL
  occtl_curve2d_create_bezier(occtl_graph_t*                            graph,
                              const occtl_curve2d_bezier_create_info_t* info,
                              occtl_rep_id_t*                           out_id);
 
OCCTL_API occtl_status_t OCCTL_CALL
  occtl_curve2d_create_trimmed(occtl_graph_t*                           graph,
                               const occtl_curve_trimmed_create_info_t* info,
                               occtl_rep_id_t*                          out_id);
 
typedef struct occtl_curve2d_offset_create_info
{
  uint32_t       struct_version; 
  const void*    p_next;         
  occtl_rep_id_t basis;          
  double         offset;         
} occtl_curve2d_offset_create_info_t;
 
#define OCCTL_CURVE2D_OFFSET_CREATE_INFO_VERSION_1 1u
 
#define OCCTL_CURVE2D_OFFSET_CREATE_INFO_INIT                                                      \
  {OCCTL_CURVE2D_OFFSET_CREATE_INFO_VERSION_1, NULL, {0}, 0.0}
 
OCCTL_API void OCCTL_CALL
  occtl_curve2d_offset_create_info_init(occtl_curve2d_offset_create_info_t* info);
 
OCCTL_API occtl_status_t OCCTL_CALL
  occtl_curve2d_create_offset(occtl_graph_t*                            graph,
                              const occtl_curve2d_offset_create_info_t* info,
                              occtl_rep_id_t*                           out_id);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_reverse(occtl_graph_t*  graph,
                                                          occtl_rep_id_t  curve_id,
                                                          occtl_rep_id_t* out_id);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_transformed(occtl_graph_t*  graph,
                                                              occtl_rep_id_t  curve_id,
                                                              double          translate_x,
                                                              double          translate_y,
                                                              double          rotate_angle,
                                                              double          scale_x,
                                                              double          scale_y,
                                                              occtl_rep_id_t* out_id);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_translated(occtl_graph_t*  graph,
                                                             occtl_rep_id_t  curve_id,
                                                             occtl_vector2_t delta,
                                                             occtl_rep_id_t* out_id);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_rotated(occtl_graph_t*  graph,
                                                          occtl_rep_id_t  curve_id,
                                                          double          angle,
                                                          occtl_rep_id_t* out_id);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_scaled(occtl_graph_t*  graph,
                                                         occtl_rep_id_t  curve_id,
                                                         occtl_point2_t  origin,
                                                         double          factor,
                                                         occtl_rep_id_t* out_id);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_length(const occtl_graph_t* graph,
                                                         occtl_rep_id_t       curve_id,
                                                         double*              out_length);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_project_point(const occtl_graph_t* graph,
                                                                occtl_rep_id_t       curve_id,
                                                                occtl_point2_t       point,
                                                                double*              out_param,
                                                                double*              out_distance);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_parameter_of_point(const occtl_graph_t* graph,
                                                                     occtl_rep_id_t       curve_id,
                                                                     occtl_point2_t       point,
                                                                     double* out_param);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_kind(const occtl_graph_t* graph,
                                                       occtl_rep_id_t       curve_id,
                                                       occtl_curve_kind_t*  out_kind);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_is_periodic(const occtl_graph_t* graph,
                                                              occtl_rep_id_t       curve_id,
                                                              int32_t*             out_is_periodic);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_is_closed(const occtl_graph_t* graph,
                                                            occtl_rep_id_t       curve_id,
                                                            int32_t*             out_is_closed);
 
OCCTL_API occtl_status_t OCCTL_CALL
  occtl_curve2d_continuity(occtl_graph_t*           graph,
                           occtl_rep_id_t           curve_id,
                           occtl_geom_continuity_t* out_continuity);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_parameter_range(const occtl_graph_t* graph,
                                                                  occtl_rep_id_t       curve_id,
                                                                  double*              out_u_min,
                                                                  double*              out_u_max);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_as_line(const occtl_graph_t* graph,
                                                          occtl_rep_id_t       curve_id,
                                                          occtl_geom2d_line_t* out_line);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_as_circle(const occtl_graph_t*   graph,
                                                            occtl_rep_id_t         curve_id,
                                                            occtl_geom2d_circle_t* out_circle);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_as_ellipse(const occtl_graph_t*    graph,
                                                             occtl_rep_id_t          curve_id,
                                                             occtl_geom2d_ellipse_t* out_ellipse);
 
OCCTL_API occtl_status_t OCCTL_CALL
  occtl_curve2d_as_hyperbola(occtl_graph_t*            graph,
                             occtl_rep_id_t            curve_id,
                             occtl_geom2d_hyperbola_t* out_hyperbola);
 
OCCTL_API occtl_status_t OCCTL_CALL
  occtl_curve2d_as_parabola(occtl_graph_t*           graph,
                            occtl_rep_id_t           curve_id,
                            occtl_geom2d_parabola_t* out_parabola);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_as_trimmed(const occtl_graph_t* graph,
                                                             occtl_rep_id_t       curve_id,
                                                             double*              out_u_first,
                                                             double*              out_u_last);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_as_offset(const occtl_graph_t* graph,
                                                            occtl_rep_id_t       curve_id,
                                                            double*              out_offset);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_bspline_degree(const occtl_graph_t* graph,
                                                                 occtl_rep_id_t       curve_id,
                                                                 int32_t*             out_degree);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_bspline_pole_count(const occtl_graph_t* graph,
                                                                     occtl_rep_id_t       curve_id,
                                                                     size_t* out_count);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_bspline_knot_count(const occtl_graph_t* graph,
                                                                     occtl_rep_id_t       curve_id,
                                                                     size_t* out_count);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_bspline_is_rational(const occtl_graph_t* graph,
                                                                      occtl_rep_id_t       curve_id,
                                                                      int32_t* out_is_rational);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_bezier_degree(const occtl_graph_t* graph,
                                                                occtl_rep_id_t       curve_id,
                                                                int32_t*             out_degree);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_bezier_pole_count(const occtl_graph_t* graph,
                                                                    occtl_rep_id_t       curve_id,
                                                                    size_t*              out_count);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_bezier_is_rational(const occtl_graph_t* graph,
                                                                     occtl_rep_id_t       curve_id,
                                                                     int32_t* out_is_rational);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_bspline_poles(const occtl_graph_t* graph,
                                                                occtl_rep_id_t       curve_id,
                                                                occtl_point2_t*      out_buf,
                                                                size_t               capacity,
                                                                size_t*              out_count);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_bspline_knots(const occtl_graph_t* graph,
                                                                occtl_rep_id_t       curve_id,
                                                                double*              out_buf,
                                                                size_t               capacity,
                                                                size_t*              out_count);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_bspline_multiplicities(const occtl_graph_t* graph,
                                                                         occtl_rep_id_t curve_id,
                                                                         int32_t*       out_buf,
                                                                         size_t         capacity,
                                                                         size_t*        out_count);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_bspline_weights(const occtl_graph_t* graph,
                                                                  occtl_rep_id_t       curve_id,
                                                                  double*              out_buf,
                                                                  size_t               capacity,
                                                                  size_t*              out_count);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_bspline_flat_knots(const occtl_graph_t* graph,
                                                                     occtl_rep_id_t       curve_id,
                                                                     double*              out_buf,
                                                                     size_t               capacity,
                                                                     size_t* out_count);
 
OCCTL_API occtl_status_t OCCTL_CALL
  occtl_curve2d_bspline_poles_view(occtl_graph_t*         graph,
                                   occtl_rep_id_t         curve_id,
                                   const occtl_point2_t** out_data,
                                   size_t*                out_count);
 
typedef struct occtl_curve2d_bspline
{
  uint32_t    struct_version; 
  const void* p_next;         
  int32_t degree;          
  int32_t is_rational;     
  int32_t is_periodic;     
  int32_t is_closed;       
  int32_t continuity;      
  size_t  pole_count;      
  size_t  knot_count;      
  size_t  flat_knot_count; 
  const occtl_point2_t* poles;   
  const double*         weights; 
  const double*  knots;          
  const int32_t* multiplicities; 
  const double*  flat_knots;     
} occtl_curve2d_bspline_t;
 
#define OCCTL_CURVE2D_BSPLINE_VERSION_1 1u
 
#define OCCTL_CURVE2D_BSPLINE_INIT                                                                 \
  {OCCTL_CURVE2D_BSPLINE_VERSION_1, NULL, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL}
 
OCCTL_API void OCCTL_CALL occtl_curve2d_bspline_init(occtl_curve2d_bspline_t* out);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_as_bspline(const occtl_graph_t*     graph,
                                                             occtl_rep_id_t           curve_id,
                                                             occtl_curve2d_bspline_t* out);
 
OCCTL_API occtl_status_t OCCTL_CALL
  occtl_curve2d_to_bezier_segments(occtl_graph_t*                               graph,
                                   occtl_rep_id_t                               curve_id,
                                   const occtl_curve_bezier_segments_options_t* options,
                                   occtl_rep_id_t**                             out_segments,
                                   size_t*                                      out_count);
 
OCCTL_API void OCCTL_CALL occtl_curve2d_free_bezier_segments(occtl_rep_id_t* ids);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_eval_d0(const occtl_graph_t* graph,
                                                          occtl_rep_id_t       curve_id,
                                                          double               u,
                                                          occtl_point2_t*      out_point);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_eval_d1(const occtl_graph_t* graph,
                                                          occtl_rep_id_t       curve_id,
                                                          double               u,
                                                          occtl_point2_t*      out_point,
                                                          occtl_vector2_t*     out_d1);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_eval_d2(const occtl_graph_t* graph,
                                                          occtl_rep_id_t       curve_id,
                                                          double               u,
                                                          occtl_point2_t*      out_point,
                                                          occtl_vector2_t*     out_d1,
                                                          occtl_vector2_t*     out_d2);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_eval_d3(const occtl_graph_t* graph,
                                                          occtl_rep_id_t       curve_id,
                                                          double               u,
                                                          occtl_point2_t*      out_point,
                                                          occtl_vector2_t*     out_d1,
                                                          occtl_vector2_t*     out_d2,
                                                          occtl_vector2_t*     out_d3);
 
OCCTL_API occtl_status_t OCCTL_CALL occtl_curve2d_eval_dn(const occtl_graph_t* graph,
                                                          occtl_rep_id_t       curve_id,
                                                          double               u,
                                                          int32_t              n,
                                                          occtl_vector2_t*     out_derivative);
 
#ifdef __cplusplus
} /* extern "C" */
#endif
 
#endif /* OCCTL_CURVES2D_H */