EIC code displayed by LXR master/​include/​opencascade/​ElCLib.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-09-14 09:14:13

 // Created on: 1991-09-10
 // Created by: Michel Chauvat
 // Copyright (c) 1991-1999 Matra Datavision
 // Copyright (c) 1999-2014 OPEN CASCADE SAS
 //
 // This file is part of Open CASCADE Technology software library.
 //
 // This library is free software; you can redistribute it and/or modify it under
 // the terms of the GNU Lesser General Public License version 2.1 as published
 // by the Free Software Foundation, with special exception defined in the file
 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
 // distribution for complete text of the license and disclaimer of any warranty.
 //
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
 #ifndef _ElCLib_HeaderFile
 #define _ElCLib_HeaderFile
 
 #include <Standard.hxx>
 #include <Standard_DefineAlloc.hxx>
 #include <Standard_Handle.hxx>
 
 #include <gp_Pnt.hxx>
 #include <gp_Vec.hxx>
 #include <gp_Pnt2d.hxx>
 #include <gp_Vec2d.hxx>
 class gp_Pnt;
 class gp_Lin;
 class gp_Circ;
 class gp_Elips;
 class gp_Hypr;
 class gp_Parab;
 class gp_Vec;
 class gp_Lin2d;
 class gp_Circ2d;
 class gp_Elips2d;
 class gp_Hypr2d;
 class gp_Parab2d;
 class gp_Pnt2d;
 class gp_Vec2d;
 class gp_Ax1;
 class gp_Ax2;
 class gp_Ax2d;
 class gp_Ax22d;
 class gp_Dir;
 class gp_Dir2d;
 
 //! Provides functions for basic geometric computations on
 //! elementary curves such as conics and lines in 2D and 3D space.
 //! This includes:
 //! -   calculation of a point or derived vector on a 2D or
 //! 3D curve where:
 //! -   the curve is provided by the gp package, or
 //! defined in reference form (as in the gp package),
 //! and
 //! -   the point is defined by a parameter,
 //! -   evaluation of the parameter corresponding to a point
 //! on a 2D or 3D curve from gp,
 //! -   various elementary computations which allow you to
 //! position parameterized values within the period of a curve.
 //! Notes:
 //! -   ElCLib stands for Elementary Curves Library.
 //! -   If the curves provided by the gp package are not
 //! explicitly parameterized, they still have an implicit
 //! parameterization, analogous to that which they infer
 //! for the equivalent Geom or Geom2d curves.
 class ElCLib
 {
 public:
   DEFINE_STANDARD_ALLOC
 
   //! Return a value in the range <UFirst, ULast> by
   //! adding or removing the period <ULast - UFirst> to
   //! <U>.
   //! ATTENTION!!!
   //!   It is expected but not checked that (ULast > UFirst)
   Standard_EXPORT static double InPeriod(const double U, const double UFirst, const double ULast);
 
   //! Adjust U1 and U2 in the parametric range UFirst
   //! Ulast of a periodic curve, where ULast -
   //! UFirst is its period. To do this, this function:
   //! -   sets U1 in the range [ UFirst, ULast ] by
   //! adding/removing the period to/from the value U1, then
   //! -   sets U2 in the range [ U1, U1 + period ] by
   //! adding/removing the period to/from the value U2.
   //! Precision is used to test the equalities.
   Standard_EXPORT static void AdjustPeriodic(const double UFirst,
                                              const double ULast,
                                              const double Precision,
                                              double&      U1,
                                              double&      U2);
 
   //! For elementary curves (lines, circles and conics) from
   //! the gp package, computes the point of parameter U.
   //! The result is either:
   //! -   a gp_Pnt point for a curve in 3D space, or
   //! -   a gp_Pnt2d point for a curve in 2D space.
   static gp_Pnt Value(const double U, const gp_Lin& L);
 
   static gp_Pnt Value(const double U, const gp_Circ& C);
 
   static gp_Pnt Value(const double U, const gp_Elips& E);
 
   static gp_Pnt Value(const double U, const gp_Hypr& H);
 
   static gp_Pnt Value(const double U, const gp_Parab& Prb);
 
   //! For elementary curves (lines, circles and conics) from the
   //! gp package, computes:
   //! -   the point P of parameter U, and
   //! -   the first derivative vector V1 at this point.
   //! The results P and V1 are either:
   //! -   a gp_Pnt point and a gp_Vec vector, for a curve in 3D space, or
   //! -   a gp_Pnt2d point and a gp_Vec2d vector, for a curve in 2D space.
   static void D1(const double U, const gp_Lin& L, gp_Pnt& P, gp_Vec& V1);
 
   static void D1(const double U, const gp_Circ& C, gp_Pnt& P, gp_Vec& V1);
 
   static void D1(const double U, const gp_Elips& E, gp_Pnt& P, gp_Vec& V1);
 
   static void D1(const double U, const gp_Hypr& H, gp_Pnt& P, gp_Vec& V1);
 
   static void D1(const double U, const gp_Parab& Prb, gp_Pnt& P, gp_Vec& V1);
 
   //! For elementary curves (circles and conics) from the gp
   //! package, computes:
   //! - the point P of parameter U, and
   //! - the first and second derivative vectors V1 and V2 at this point.
   //! The results, P, V1 and V2, are either:
   //! -   a gp_Pnt point and two gp_Vec vectors, for a curve in 3D space, or
   //! -   a gp_Pnt2d point and two gp_Vec2d vectors, for a curve in 2D space.
   static void D2(const double U, const gp_Circ& C, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2);
 
   static void D2(const double U, const gp_Elips& E, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2);
 
   static void D2(const double U, const gp_Hypr& H, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2);
 
   static void D2(const double U, const gp_Parab& Prb, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2);
 
   //! For elementary curves (circles, ellipses and hyperbolae)
   //! from the gp package, computes:
   //! -   the point P of parameter U, and
   //! -   the first, second and third derivative vectors V1, V2
   //! and V3 at this point.
   //! The results, P, V1, V2 and V3, are either:
   //! -   a gp_Pnt point and three gp_Vec vectors, for a curve in 3D space, or
   //! -   a gp_Pnt2d point and three gp_Vec2d vectors, for a curve in 2D space.
   static void D3(const double U, const gp_Circ& C, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3);
 
   static void D3(const double U, const gp_Elips& E, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3);
 
   static void D3(const double U, const gp_Hypr& H, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3);
 
   //! For elementary curves (lines, circles and conics) from
   //! the gp package, computes the vector corresponding to
   //! the Nth derivative at the point of parameter U. The result is either:
   //! -   a gp_Vec vector for a curve in 3D space, or
   //! -   a gp_Vec2d vector for a curve in 2D space.
   //! In the following functions N is the order of derivation
   //! and should be greater than 0
   static gp_Vec DN(const double U, const gp_Lin& L, const int N);
 
   static gp_Vec DN(const double U, const gp_Circ& C, const int N);
 
   static gp_Vec DN(const double U, const gp_Elips& E, const int N);
 
   static gp_Vec DN(const double U, const gp_Hypr& H, const int N);
 
   static gp_Vec DN(const double U, const gp_Parab& Prb, const int N);
 
   static gp_Pnt2d Value(const double U, const gp_Lin2d& L);
 
   static gp_Pnt2d Value(const double U, const gp_Circ2d& C);
 
   static gp_Pnt2d Value(const double U, const gp_Elips2d& E);
 
   static gp_Pnt2d Value(const double U, const gp_Hypr2d& H);
 
   static gp_Pnt2d Value(const double U, const gp_Parab2d& Prb);
 
   static void D1(const double U, const gp_Lin2d& L, gp_Pnt2d& P, gp_Vec2d& V1);
 
   static void D1(const double U, const gp_Circ2d& C, gp_Pnt2d& P, gp_Vec2d& V1);
 
   static void D1(const double U, const gp_Elips2d& E, gp_Pnt2d& P, gp_Vec2d& V1);
 
   static void D1(const double U, const gp_Hypr2d& H, gp_Pnt2d& P, gp_Vec2d& V1);
 
   static void D1(const double U, const gp_Parab2d& Prb, gp_Pnt2d& P, gp_Vec2d& V1);
 
   static void D2(const double U, const gp_Circ2d& C, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2);
 
   static void D2(const double U, const gp_Elips2d& E, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2);
 
   static void D2(const double U, const gp_Hypr2d& H, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2);
 
   static void D2(const double U, const gp_Parab2d& Prb, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2);
 
   static void D3(const double     U,
                  const gp_Circ2d& C,
                  gp_Pnt2d&        P,
                  gp_Vec2d&        V1,
                  gp_Vec2d&        V2,
                  gp_Vec2d&        V3);
 
   static void D3(const double      U,
                  const gp_Elips2d& E,
                  gp_Pnt2d&         P,
                  gp_Vec2d&         V1,
                  gp_Vec2d&         V2,
                  gp_Vec2d&         V3);
 
   //! In the following functions N is the order of derivation
   //! and should be greater than 0
   static void D3(const double     U,
                  const gp_Hypr2d& H,
                  gp_Pnt2d&        P,
                  gp_Vec2d&        V1,
                  gp_Vec2d&        V2,
                  gp_Vec2d&        V3);
 
   static gp_Vec2d DN(const double U, const gp_Lin2d& L, const int N);
 
   static gp_Vec2d DN(const double U, const gp_Circ2d& C, const int N);
 
   static gp_Vec2d DN(const double U, const gp_Elips2d& E, const int N);
 
   static gp_Vec2d DN(const double U, const gp_Hypr2d& H, const int N);
 
   static gp_Vec2d DN(const double U, const gp_Parab2d& Prb, const int N);
 
   //! Curve evaluation
   //! The following basis functions compute the derivatives on
   //! elementary curves defined by their geometric characteristics.
   //! These functions can be called without constructing a conic
   //! from package gp. They are called by the previous functions.
   //! Example :
   //! A circle is defined by its position and its radius.
   Standard_EXPORT static gp_Pnt LineValue(const double U, const gp_Ax1& Pos);
 
   Standard_EXPORT static gp_Pnt CircleValue(const double U, const gp_Ax2& Pos, const double Radius);
 
   Standard_EXPORT static gp_Pnt EllipseValue(const double  U,
                                              const gp_Ax2& Pos,
                                              const double  MajorRadius,
                                              const double  MinorRadius);
 
   Standard_EXPORT static gp_Pnt HyperbolaValue(const double  U,
                                                const gp_Ax2& Pos,
                                                const double  MajorRadius,
                                                const double  MinorRadius);
 
   Standard_EXPORT static gp_Pnt ParabolaValue(const double  U,
                                               const gp_Ax2& Pos,
                                               const double  Focal);
 
   Standard_EXPORT static void LineD1(const double U, const gp_Ax1& Pos, gp_Pnt& P, gp_Vec& V1);
 
   Standard_EXPORT static void CircleD1(const double  U,
                                        const gp_Ax2& Pos,
                                        const double  Radius,
                                        gp_Pnt&       P,
                                        gp_Vec&       V1);
 
   Standard_EXPORT static void EllipseD1(const double  U,
                                         const gp_Ax2& Pos,
                                         const double  MajorRadius,
                                         const double  MinorRadius,
                                         gp_Pnt&       P,
                                         gp_Vec&       V1);
 
   Standard_EXPORT static void HyperbolaD1(const double  U,
                                           const gp_Ax2& Pos,
                                           const double  MajorRadius,
                                           const double  MinorRadius,
                                           gp_Pnt&       P,
                                           gp_Vec&       V1);
 
   Standard_EXPORT static void ParabolaD1(const double  U,
                                          const gp_Ax2& Pos,
                                          const double  Focal,
                                          gp_Pnt&       P,
                                          gp_Vec&       V1);
 
   Standard_EXPORT static void CircleD2(const double  U,
                                        const gp_Ax2& Pos,
                                        const double  Radius,
                                        gp_Pnt&       P,
                                        gp_Vec&       V1,
                                        gp_Vec&       V2);
 
   Standard_EXPORT static void EllipseD2(const double  U,
                                         const gp_Ax2& Pos,
                                         const double  MajorRadius,
                                         const double  MinorRadius,
                                         gp_Pnt&       P,
                                         gp_Vec&       V1,
                                         gp_Vec&       V2);
 
   Standard_EXPORT static void HyperbolaD2(const double  U,
                                           const gp_Ax2& Pos,
                                           const double  MajorRadius,
                                           const double  MinorRadius,
                                           gp_Pnt&       P,
                                           gp_Vec&       V1,
                                           gp_Vec&       V2);
 
   Standard_EXPORT static void ParabolaD2(const double  U,
                                          const gp_Ax2& Pos,
                                          const double  Focal,
                                          gp_Pnt&       P,
                                          gp_Vec&       V1,
                                          gp_Vec&       V2);
 
   Standard_EXPORT static void CircleD3(const double  U,
                                        const gp_Ax2& Pos,
                                        const double  Radius,
                                        gp_Pnt&       P,
                                        gp_Vec&       V1,
                                        gp_Vec&       V2,
                                        gp_Vec&       V3);
 
   Standard_EXPORT static void EllipseD3(const double  U,
                                         const gp_Ax2& Pos,
                                         const double  MajorRadius,
                                         const double  MinorRadius,
                                         gp_Pnt&       P,
                                         gp_Vec&       V1,
                                         gp_Vec&       V2,
                                         gp_Vec&       V3);
 
   Standard_EXPORT static void HyperbolaD3(const double  U,
                                           const gp_Ax2& Pos,
                                           const double  MajorRadius,
                                           const double  MinorRadius,
                                           gp_Pnt&       P,
                                           gp_Vec&       V1,
                                           gp_Vec&       V2,
                                           gp_Vec&       V3);
 
   //! In the following functions N is the order of derivation
   //! and should be greater than 0
   Standard_EXPORT static gp_Vec LineDN(const double U, const gp_Ax1& Pos, const int N);
 
   Standard_EXPORT static gp_Vec CircleDN(const double  U,
                                          const gp_Ax2& Pos,
                                          const double  Radius,
                                          const int     N);
 
   Standard_EXPORT static gp_Vec EllipseDN(const double  U,
                                           const gp_Ax2& Pos,
                                           const double  MajorRadius,
                                           const double  MinorRadius,
                                           const int     N);
 
   Standard_EXPORT static gp_Vec HyperbolaDN(const double  U,
                                             const gp_Ax2& Pos,
                                             const double  MajorRadius,
                                             const double  MinorRadius,
                                             const int     N);
 
   Standard_EXPORT static gp_Vec ParabolaDN(const double  U,
                                            const gp_Ax2& Pos,
                                            const double  Focal,
                                            const int     N);
 
   Standard_EXPORT static gp_Pnt2d LineValue(const double U, const gp_Ax2d& Pos);
 
   Standard_EXPORT static gp_Pnt2d CircleValue(const double    U,
                                               const gp_Ax22d& Pos,
                                               const double    Radius);
 
   Standard_EXPORT static gp_Pnt2d EllipseValue(const double    U,
                                                const gp_Ax22d& Pos,
                                                const double    MajorRadius,
                                                const double    MinorRadius);
 
   Standard_EXPORT static gp_Pnt2d HyperbolaValue(const double    U,
                                                  const gp_Ax22d& Pos,
                                                  const double    MajorRadius,
                                                  const double    MinorRadius);
 
   Standard_EXPORT static gp_Pnt2d ParabolaValue(const double    U,
                                                 const gp_Ax22d& Pos,
                                                 const double    Focal);
 
   Standard_EXPORT static void LineD1(const double U, const gp_Ax2d& Pos, gp_Pnt2d& P, gp_Vec2d& V1);
 
   Standard_EXPORT static void CircleD1(const double    U,
                                        const gp_Ax22d& Pos,
                                        const double    Radius,
                                        gp_Pnt2d&       P,
                                        gp_Vec2d&       V1);
 
   Standard_EXPORT static void EllipseD1(const double    U,
                                         const gp_Ax22d& Pos,
                                         const double    MajorRadius,
                                         const double    MinorRadius,
                                         gp_Pnt2d&       P,
                                         gp_Vec2d&       V1);
 
   Standard_EXPORT static void HyperbolaD1(const double    U,
                                           const gp_Ax22d& Pos,
                                           const double    MajorRadius,
                                           const double    MinorRadius,
                                           gp_Pnt2d&       P,
                                           gp_Vec2d&       V1);
 
   Standard_EXPORT static void ParabolaD1(const double    U,
                                          const gp_Ax22d& Pos,
                                          const double    Focal,
                                          gp_Pnt2d&       P,
                                          gp_Vec2d&       V1);
 
   Standard_EXPORT static void CircleD2(const double    U,
                                        const gp_Ax22d& Pos,
                                        const double    Radius,
                                        gp_Pnt2d&       P,
                                        gp_Vec2d&       V1,
                                        gp_Vec2d&       V2);
 
   Standard_EXPORT static void EllipseD2(const double    U,
                                         const gp_Ax22d& Pos,
                                         const double    MajorRadius,
                                         const double    MinorRadius,
                                         gp_Pnt2d&       P,
                                         gp_Vec2d&       V1,
                                         gp_Vec2d&       V2);
 
   Standard_EXPORT static void HyperbolaD2(const double    U,
                                           const gp_Ax22d& Pos,
                                           const double    MajorRadius,
                                           const double    MinorRadius,
                                           gp_Pnt2d&       P,
                                           gp_Vec2d&       V1,
                                           gp_Vec2d&       V2);
 
   Standard_EXPORT static void ParabolaD2(const double    U,
                                          const gp_Ax22d& Pos,
                                          const double    Focal,
                                          gp_Pnt2d&       P,
                                          gp_Vec2d&       V1,
                                          gp_Vec2d&       V2);
 
   Standard_EXPORT static void CircleD3(const double    U,
                                        const gp_Ax22d& Pos,
                                        const double    Radius,
                                        gp_Pnt2d&       P,
                                        gp_Vec2d&       V1,
                                        gp_Vec2d&       V2,
                                        gp_Vec2d&       V3);
 
   Standard_EXPORT static void EllipseD3(const double    U,
                                         const gp_Ax22d& Pos,
                                         const double    MajorRadius,
                                         const double    MinorRadius,
                                         gp_Pnt2d&       P,
                                         gp_Vec2d&       V1,
                                         gp_Vec2d&       V2,
                                         gp_Vec2d&       V3);
 
   //! In the following functions N is the order of derivation
   //! and should be greater than 0
   Standard_EXPORT static void HyperbolaD3(const double    U,
                                           const gp_Ax22d& Pos,
                                           const double    MajorRadius,
                                           const double    MinorRadius,
                                           gp_Pnt2d&       P,
                                           gp_Vec2d&       V1,
                                           gp_Vec2d&       V2,
                                           gp_Vec2d&       V3);
 
   Standard_EXPORT static gp_Vec2d LineDN(const double U, const gp_Ax2d& Pos, const int N);
 
   Standard_EXPORT static gp_Vec2d CircleDN(const double    U,
                                            const gp_Ax22d& Pos,
                                            const double    Radius,
                                            const int       N);
 
   Standard_EXPORT static gp_Vec2d EllipseDN(const double    U,
                                             const gp_Ax22d& Pos,
                                             const double    MajorRadius,
                                             const double    MinorRadius,
                                             const int       N);
 
   Standard_EXPORT static gp_Vec2d HyperbolaDN(const double    U,
                                               const gp_Ax22d& Pos,
                                               const double    MajorRadius,
                                               const double    MinorRadius,
                                               const int       N);
 
   //! The following functions compute the parametric value corresponding
   //! to a given point on a elementary curve. The point should be on the
   //! curve.
   Standard_EXPORT static gp_Vec2d ParabolaDN(const double    U,
                                              const gp_Ax22d& Pos,
                                              const double    Focal,
                                              const int       N);
 
   //! Computes the parameter value of the point P on the given curve.
   //! Note: In its local coordinate system, the parametric
   //! equation of the curve is given by the following:
   //! -   for the line L: P(U) = Po + U*Vo
   //! where Po is the origin and Vo the unit vector of its positioning axis.
   //! -   for the circle C: X(U) = Radius*std::cos(U), Y(U) = Radius*Sin(U)
   //! -   for the ellipse E: X(U) = MajorRadius*std::cos(U). Y(U) = MinorRadius*Sin(U)
   //! -   for the hyperbola H: X(U) = MajorRadius*Ch(U), Y(U) = MinorRadius*Sh(U)
   //! -   for the parabola Prb:
   //! X(U) = U**2 / (2*p)
   //! Y(U) = U
   //! where p is the distance between the focus and the directrix.
   //! Warning
   //! The point P must be on the curve. These functions are
   //! not protected, however, and if point P is not on the
   //! curve, an exception may be raised.
   static double Parameter(const gp_Lin& L, const gp_Pnt& P);
 
   //! parametrization
   //! P (U) = L.Location() + U * L.Direction()
   static double Parameter(const gp_Lin2d& L, const gp_Pnt2d& P);
 
   static double Parameter(const gp_Circ& C, const gp_Pnt& P);
 
   //! parametrization
   //! In the local coordinate system of the circle
   //! X (U) = Radius * Cos (U)
   //! Y (U) = Radius * Sin (U)
   static double Parameter(const gp_Circ2d& C, const gp_Pnt2d& P);
 
   static double Parameter(const gp_Elips& E, const gp_Pnt& P);
 
   //! parametrization
   //! In the local coordinate system of the Ellipse
   //! X (U) = MajorRadius * Cos (U)
   //! Y (U) = MinorRadius * Sin (U)
   static double Parameter(const gp_Elips2d& E, const gp_Pnt2d& P);
 
   static double Parameter(const gp_Hypr& H, const gp_Pnt& P);
 
   //! parametrization
   //! In the local coordinate system of the Hyperbola
   //! X (U) = MajorRadius * Ch (U)
   //! Y (U) = MinorRadius * Sh (U)
   static double Parameter(const gp_Hypr2d& H, const gp_Pnt2d& P);
 
   static double Parameter(const gp_Parab& Prb, const gp_Pnt& P);
 
   //! parametrization
   //! In the local coordinate system of the parabola
   //! Y**2 = (2*P) * X where P is the distance between the focus
   //! and the directrix.
   static double Parameter(const gp_Parab2d& Prb, const gp_Pnt2d& P);
 
   Standard_EXPORT static double LineParameter(const gp_Ax1& Pos, const gp_Pnt& P);
 
   //! parametrization
   //! P (U) = L.Location() + U * L.Direction()
   Standard_EXPORT static double LineParameter(const gp_Ax2d& Pos, const gp_Pnt2d& P);
 
   Standard_EXPORT static double CircleParameter(const gp_Ax2& Pos, const gp_Pnt& P);
 
   //! Pos is the Axis of the Circle
   //! parametrization
   //! In the local coordinate system of the circle
   //! X (U) = Radius * Cos (U)
   //! Y (U) = Radius * Sin (U)
   Standard_EXPORT static double CircleParameter(const gp_Ax22d& Pos, const gp_Pnt2d& P);
 
   Standard_EXPORT static double EllipseParameter(const gp_Ax2& Pos,
                                                  const double  MajorRadius,
                                                  const double  MinorRadius,
                                                  const gp_Pnt& P);
 
   //! Pos is the Axis of the Ellipse
   //! parametrization
   //! In the local coordinate system of the Ellipse
   //! X (U) = MajorRadius * Cos (U)
   //! Y (U) = MinorRadius * Sin (U)
   Standard_EXPORT static double EllipseParameter(const gp_Ax22d& Pos,
                                                  const double    MajorRadius,
                                                  const double    MinorRadius,
                                                  const gp_Pnt2d& P);
 
   Standard_EXPORT static double HyperbolaParameter(const gp_Ax2& Pos,
                                                    const double  MajorRadius,
                                                    const double  MinorRadius,
                                                    const gp_Pnt& P);
 
   //! Pos is the Axis of the Hyperbola
   //! parametrization
   //! In the local coordinate system of the Hyperbola
   //! X (U) = MajorRadius * Ch (U)
   //! Y (U) = MinorRadius * Sh (U)
   Standard_EXPORT static double HyperbolaParameter(const gp_Ax22d& Pos,
                                                    const double    MajorRadius,
                                                    const double    MinorRadius,
                                                    const gp_Pnt2d& P);
 
   Standard_EXPORT static double ParabolaParameter(const gp_Ax2& Pos, const gp_Pnt& P);
 
   //! Pos is the mirror axis of the parabola
   //! parametrization
   //! In the local coordinate system of the parabola
   //! Y**2 = (2*P) * X where P is the distance between the focus
   //! and the directrix.
   //! The following functions build a 3d curve from a
   //! 2d curve at a given position defined with an Ax2.
   Standard_EXPORT static double ParabolaParameter(const gp_Ax22d& Pos, const gp_Pnt2d& P);
 
   Standard_EXPORT static gp_Pnt To3d(const gp_Ax2& Pos, const gp_Pnt2d& P);
 
   Standard_EXPORT static gp_Vec To3d(const gp_Ax2& Pos, const gp_Vec2d& V);
 
   Standard_EXPORT static gp_Dir To3d(const gp_Ax2& Pos, const gp_Dir2d& V);
 
   Standard_EXPORT static gp_Ax1 To3d(const gp_Ax2& Pos, const gp_Ax2d& A);
 
   Standard_EXPORT static gp_Ax2 To3d(const gp_Ax2& Pos, const gp_Ax22d& A);
 
   Standard_EXPORT static gp_Lin To3d(const gp_Ax2& Pos, const gp_Lin2d& L);
 
   Standard_EXPORT static gp_Circ To3d(const gp_Ax2& Pos, const gp_Circ2d& C);
 
   Standard_EXPORT static gp_Elips To3d(const gp_Ax2& Pos, const gp_Elips2d& E);
 
   Standard_EXPORT static gp_Hypr To3d(const gp_Ax2& Pos, const gp_Hypr2d& H);
 
   //! These functions build a 3D geometric entity from a 2D geometric entity.
   //! The "X Axis" and the "Y Axis" of the global coordinate
   //! system (i.e. 2D space) are lined up respectively with the
   //! "X Axis" and "Y Axis" of the 3D coordinate system, Pos.
   Standard_EXPORT static gp_Parab To3d(const gp_Ax2& Pos, const gp_Parab2d& Prb);
 };
 
 #include <ElCLib.lxx>
 
 #endif // _ElCLib_HeaderFile

This page was automatically generated by the 2.3.7 LXR engine. The LXR team