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

File indexing completed on 2026-10-05 09:21:11

 // Created on: 1997-09-30
 // Created by: Roman BORISOV
 // Copyright (c) 1997-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 _Approx_CurveOnSurface_HeaderFile
 #define _Approx_CurveOnSurface_HeaderFile
 
 #include <Adaptor2d_Curve2d.hxx>
 #include <Adaptor3d_Surface.hxx>
 #include <GeomAbs_Shape.hxx>
 
 class Geom_BSplineCurve;
 class Geom2d_BSplineCurve;
 
 //! Approximation of curve on surface
 class Approx_CurveOnSurface
 {
 public:
   DEFINE_STANDARD_ALLOC
 
   //! This constructor calls perform method. This constructor is deprecated.
   Standard_DEPRECATED(
     "This constructor is deprecated. Use other constructor and perform method instead.")
   Standard_EXPORT Approx_CurveOnSurface(const occ::handle<Adaptor2d_Curve2d>& C2D,
                                         const occ::handle<Adaptor3d_Surface>& Surf,
                                         const double                          First,
                                         const double                          Last,
                                         const double                          Tol,
                                         const GeomAbs_Shape                   Continuity,
                                         const int                             MaxDegree,
                                         const int                             MaxSegments,
                                         const bool                            Only3d = false,
                                         const bool                            Only2d = false);
 
   //! This constructor does not call perform method.
   //! @param theC2D   2D Curve to be approximated in 3D.
   //! @param theSurf  Surface where 2D curve is located.
   //! @param theFirst First parameter of resulting curve.
   //! @param theFirst Last parameter of resulting curve.
   //! @param theTol   Computation tolerance.
   Standard_EXPORT Approx_CurveOnSurface(const occ::handle<Adaptor2d_Curve2d>& theC2D,
                                         const occ::handle<Adaptor3d_Surface>& theSurf,
                                         const double                          theFirst,
                                         const double                          theLast,
                                         const double                          theTol);
 
   Standard_EXPORT bool IsDone() const;
 
   Standard_EXPORT bool HasResult() const;
 
   Standard_EXPORT occ::handle<Geom_BSplineCurve> Curve3d() const;
 
   Standard_EXPORT double MaxError3d() const;
 
   Standard_EXPORT occ::handle<Geom2d_BSplineCurve> Curve2d() const;
 
   Standard_EXPORT double MaxError2dU() const;
 
   //! returns the maximum errors relatively to the U component or the V component of the
   //! 2d Curve
   Standard_EXPORT double MaxError2dV() const;
 
   //! Constructs the 3d curve. Input parameters are ignored when the input curve is
   //! U-isoline or V-isoline.
   //! @param theMaxSegments Maximal number of segments in the resulting spline.
   //! @param theMaxDegree   Maximal degree of the result.
   //! @param theContinuity  Resulting continuity.
   //! @param theOnly3d      Determines building only 3D curve.
   //! @param theOnly2d      Determines building only 2D curve.
   Standard_EXPORT void Perform(const int           theMaxSegments,
                                const int           theMaxDegree,
                                const GeomAbs_Shape theContinuity,
                                const bool          theOnly3d = false,
                                const bool          theOnly2d = false);
 
 protected:
   //! Checks whether the 2d curve is a isoline. It can be represented by b-spline, bezier,
   //! or geometric line. This line should have natural parameterization.
   //! @param theC2D       Trimmed curve to be checked.
   //! @param theIsU       Flag indicating that line is u const.
   //! @param theParam     Line parameter.
   //! @param theIsForward Flag indicating forward parameterization on a isoline.
   //! @return true when 2d curve is a line and false otherwise.
   bool isIsoLine(const occ::handle<Adaptor2d_Curve2d>& theC2D,
                  bool&                                 theIsU,
                  double&                               theParam,
                  bool&                                 theIsForward) const;
 
   //! Builds 3D curve for a isoline. This method takes corresponding isoline from
   //! the input surface.
   //! @param theC2D   Trimmed curve to be approximated.
   //! @param theIsU   Flag indicating that line is u const.
   //! @param theParam Line parameter.
   //! @param theIsForward Flag indicating forward parameterization on a isoline.
   //! @return true when 3d curve is built and false otherwise.
   bool buildC3dOnIsoLine(const occ::handle<Adaptor2d_Curve2d>& theC2D,
                          const bool                            theIsU,
                          const double                          theParam,
                          const bool                            theIsForward);
 
 private:
   Approx_CurveOnSurface& operator=(const Approx_CurveOnSurface&) = delete;
 
 private:
   //! Input curve.
   const occ::handle<Adaptor2d_Curve2d> myC2D;
 
   //! Input surface.
   const occ::handle<Adaptor3d_Surface> mySurf;
 
   //! First parameter of the result.
   const double myFirst;
 
   //! Last parameter of the result.
   const double myLast;
 
   //! Tolerance.
   double myTol;
 
   occ::handle<Geom2d_BSplineCurve> myCurve2d;
   occ::handle<Geom_BSplineCurve>   myCurve3d;
   bool                             myIsDone;
   bool                             myHasResult;
   double                           myError3d;
   double                           myError2dU;
   double                           myError2dV;
 };
 
 #endif // _Approx_CurveOnSurface_HeaderFile

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