0032285: Coding Rules - get rid of generic methods in GCPnts_TangentialDeflection

src/GCPnts/FILES

@@ -10,7 +10,6 @@ GCPnts_QuasiUniformDeflection.cxx
 GCPnts_QuasiUniformDeflection.pxx
 GCPnts_QuasiUniformDeflection.hxx
 GCPnts_TangentialDeflection.cxx
-GCPnts_TangentialDeflection.pxx
 GCPnts_TangentialDeflection.hxx
 GCPnts_UniformAbscissa.cxx
 GCPnts_UniformAbscissa.pxx

src/GCPnts/GCPnts_TangentialDeflection.hxx

@@ -26,16 +26,13 @@
 #include <Adaptor3d_Curve.hxx>
 #include <Adaptor2d_Curve2d.hxx>
 
-class Standard_ConstructionError;
-class Standard_OutOfRange;
-
 //! Computes a set of  points on a curve from package
 //! Adaptor3d  such  as between  two successive   points
 //! P1(u1)and P2(u2) :
-//!
+//! @code
 //! . ||P1P3^P3P2||/||P1P3||*||P3P2||<AngularDeflection
 //! . ||P1P2^P1P3||/||P1P2||<CurvatureDeflection
-//!
+//! @endcode
 //! where P3 is the point of abscissa ((u1+u2)/2), with
 //! u1 the abscissa of the point P1 and u2 the abscissa
 //! of the point P2.
@@ -47,107 +44,220 @@ class Standard_OutOfRange;
 //! and CurvatureDeflection > gp::Resolution() must be
 //! satisfied at the construction time.
 //!
-//! A  minimum  number of points  can  be fixed   for a
+//! A minimum number of points can be fixed for a linear or circular element.
-//! linear or circular element.
 //! Example:
-//! Handle(Geom_BezierCurve) C = new Geom_BezierCurve (Poles);
+//! @code
-//! GeomAdaptor_Curve Curve (C);
+//! Handle(Geom_BezierCurve) aCurve = new Geom_BezierCurve (thePoles);
-//! Real CDeflect = 0.01;  //Curvature deflection
+//! GeomAdaptor_Curve aCurveAdaptor (aCurve);
-//! Real ADeflect = 0.09; //Angular deflection
+//! double aCDeflect  = 0.01; // Curvature deflection
+//! double anADeflect = 0.09; // Angular   deflection
 //!
-//! GCPnts_TangentialDeflection PointsOnCurve;
+//! GCPnts_TangentialDeflection aPointsOnCurve;
-//! PointsOnCurve.Initialize (Curve, ADeflect, CDeflect);
+//! aPointsOnCurve.Initialize (aCurveAdaptor, anADeflect, aCDeflect);
-//!
+//! for (int i = 1; i <= aPointsOnCurve.NbPoints(); ++i)
-//! Real U;
+//! {
-//! gp_Pnt P;
+//!   double aU   = aPointsOnCurve.Parameter (i);
-//! for (Integer i=1; i<=PointsOnCurve.NbPoints();i++) {
+//!   gp_Pnt aPnt = aPointsOnCurve.Value (i);
-//! U = PointsOnCurve.Parameter (i);
-//! P = PointsOnCurve.Value (i);
 //! }
-
+//! @endcode
 class GCPnts_TangentialDeflection 
 {
 public:
 
-//
   DEFINE_STANDARD_ALLOC
 
-  
+  //! Empty constructor.
+  //! @sa Initialize()
   Standard_EXPORT GCPnts_TangentialDeflection();
-  
+
-  Standard_EXPORT GCPnts_TangentialDeflection(const Adaptor3d_Curve& C, const Standard_Real AngularDeflection, const Standard_Real CurvatureDeflection, const Standard_Integer MinimumOfPoints = 2, const Standard_Real UTol = 1.0e-9, const Standard_Real theMinLen = 1.0e-7);
+  //! Constructor for 3D curve.
-  
+  //! @param theC [in] 3d curve
-  Standard_EXPORT GCPnts_TangentialDeflection(const Adaptor3d_Curve& C, const Standard_Real FirstParameter, const Standard_Real LastParameter, const Standard_Real AngularDeflection, const Standard_Real CurvatureDeflection, const Standard_Integer MinimumOfPoints = 2, const Standard_Real UTol = 1.0e-9, const Standard_Real theMinLen = 1.0e-7);
+  //! @param theAngularDeflection   [in] angular deflection in radians
-  
+  //! @param theCurvatureDeflection [in] linear deflection
-  Standard_EXPORT GCPnts_TangentialDeflection(const Adaptor2d_Curve2d& C, const Standard_Real AngularDeflection, const Standard_Real CurvatureDeflection, const Standard_Integer MinimumOfPoints = 2, const Standard_Real UTol = 1.0e-9, const Standard_Real theMinLen = 1.0e-7);
+  //! @param theMinimumOfPoints [in] minimum number of points
-  
+  //! @param theUTol   [in] tolerance in curve parametric scope
-  Standard_EXPORT GCPnts_TangentialDeflection(const Adaptor2d_Curve2d& C, const Standard_Real FirstParameter, const Standard_Real LastParameter, const Standard_Real AngularDeflection, const Standard_Real CurvatureDeflection, const Standard_Integer MinimumOfPoints = 2, const Standard_Real UTol = 1.0e-9, const Standard_Real theMinLen = 1.0e-7);
+  //! @param theMinLen [in] minimal length
-  
+  Standard_EXPORT GCPnts_TangentialDeflection (const Adaptor3d_Curve& theC,
-  Standard_EXPORT void Initialize (const Adaptor3d_Curve& C, const Standard_Real AngularDeflection, const Standard_Real CurvatureDeflection, const Standard_Integer MinimumOfPoints = 2, const Standard_Real UTol = 1.0e-9, const Standard_Real theMinLen = 1.0e-7);
+                                               const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
-  
+                                               const Standard_Integer theMinimumOfPoints = 2,
-  Standard_EXPORT void Initialize (const Adaptor3d_Curve& C, const Standard_Real FirstParameter, const Standard_Real LastParameter, const Standard_Real AngularDeflection, const Standard_Real CurvatureDeflection, const Standard_Integer MinimumOfPoints = 2, const Standard_Real UTol = 1.0e-9, const Standard_Real theMinLen = 1.0e-7);
+                                               const Standard_Real theUTol = 1.0e-9,
-  
+                                               const Standard_Real theMinLen = 1.0e-7);
-  Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Real AngularDeflection, const Standard_Real CurvatureDeflection, const Standard_Integer MinimumOfPoints = 2, const Standard_Real UTol = 1.0e-9, const Standard_Real theMinLen = 1.0e-7);
+
-  
+  //! Constructor for 3D curve with restricted range.
-  Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Real FirstParameter, const Standard_Real LastParameter, const Standard_Real AngularDeflection, const Standard_Real CurvatureDeflection, const Standard_Integer MinimumOfPoints = 2, const Standard_Real UTol = 1.0e-9, const Standard_Real theMinLen = 1.0e-7);
+  //! @param theC [in] 3d curve
-  
+  //! @param theFirstParameter [in] first parameter on curve
+  //! @param theLastParameter  [in] last  parameter on curve
+  //! @param theAngularDeflection   [in] angular deflection in radians
+  //! @param theCurvatureDeflection [in] linear deflection
+  //! @param theMinimumOfPoints [in] minimum number of points
+  //! @param theUTo  l [in] tolerance in curve parametric scope
+  //! @param theMinLen [in] minimal length
+  Standard_EXPORT GCPnts_TangentialDeflection (const Adaptor3d_Curve& theC,
+                                               const Standard_Real theFirstParameter, const Standard_Real theLastParameter,
+                                               const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
+                                               const Standard_Integer theMinimumOfPoints = 2,
+                                               const Standard_Real theUTol = 1.0e-9,
+                                               const Standard_Real theMinLen = 1.0e-7);
+
+  //! Constructor for 2D curve.
+  //! @param theC [in] 2d curve
+  //! @param theAngularDeflection   [in] angular deflection in radians
+  //! @param theCurvatureDeflection [in] linear deflection
+  //! @param theMinimumOfPoints [in] minimum number of points
+  //! @param theUTol   [in] tolerance in curve parametric scope
+  //! @param theMinLen [in] minimal length
+  Standard_EXPORT GCPnts_TangentialDeflection (const Adaptor2d_Curve2d& theC,
+                                               const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
+                                               const Standard_Integer theMinimumOfPoints = 2,
+                                               const Standard_Real theUTol = 1.0e-9,
+                                               const Standard_Real theMinLen = 1.0e-7);
+
+  //! Constructor for 2D curve with restricted range.
+  //! @param theC [in] 2d curve
+  //! @param theFirstParameter [in] first parameter on curve
+  //! @param theLastParameter  [in] last  parameter on curve
+  //! @param theAngularDeflection   [in] angular deflection in radians
+  //! @param theCurvatureDeflection [in] linear deflection
+  //! @param theMinimumOfPoints [in] minimum number of points
+  //! @param theUTol   [in] tolerance in curve parametric scope
+  //! @param theMinLen [in] minimal length
+  Standard_EXPORT GCPnts_TangentialDeflection (const Adaptor2d_Curve2d& theC,
+                                               const Standard_Real theFirstParameter, const Standard_Real theLastParameter,
+                                               const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
+                                               const Standard_Integer theMinimumOfPoints = 2,
+                                               const Standard_Real theUTol = 1.0e-9,
+                                               const Standard_Real theMinLen = 1.0e-7);
+
+  //! Initialize algorithm for 3D curve.
+  //! @param theC [in] 3d curve
+  //! @param theAngularDeflection   [in] angular deflection in radians
+  //! @param theCurvatureDeflection [in] linear deflection
+  //! @param theMinimumOfPoints [in] minimum number of points
+  //! @param theUTol   [in] tolerance in curve parametric scope
+  //! @param theMinLen [in] minimal length
+  Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
+                                   const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
+                                   const Standard_Integer theMinimumOfPoints = 2,
+                                   const Standard_Real theUTol = 1.0e-9,
+                                   const Standard_Real theMinLen = 1.0e-7);
+
+  //! Initialize algorithm for 3D curve with restricted range.
+  //! @param theC [in] 3d curve
+  //! @param theFirstParameter [in] first parameter on curve
+  //! @param theLastParameter  [in] last  parameter on curve
+  //! @param theAngularDeflection   [in] angular deflection in radians
+  //! @param theCurvatureDeflection [in] linear deflection
+  //! @param theMinimumOfPoints [in] minimum number of points
+  //! @param theUTol   [in] tolerance in curve parametric scope
+  //! @param theMinLen [in] minimal length
+  Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
+                                   const Standard_Real theFirstParameter, const Standard_Real theLastParameter,
+                                   const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
+                                   const Standard_Integer theMinimumOfPoints = 2,
+                                   const Standard_Real theUTol = 1.0e-9,
+                                   const Standard_Real theMinLen = 1.0e-7);
+
+  //! Initialize algorithm for 2D curve.
+  //! @param theC [in] 2d curve
+  //! @param theAngularDeflection   [in] angular deflection in radians
+  //! @param theCurvatureDeflection [in] linear deflection
+  //! @param theMinimumOfPoints [in] minimum number of points
+  //! @param theUTol   [in] tolerance in curve parametric scope
+  //! @param theMinLen [in] minimal length
+  Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& theC,
+                                   const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
+                                   const Standard_Integer theMinimumOfPoints = 2,
+                                   const Standard_Real theUTol = 1.0e-9,
+                                   const Standard_Real theMinLen = 1.0e-7);
+
+  //! Initialize algorithm for 2D curve with restricted range.
+  //! @param theC [in] 2d curve
+  //! @param theFirstParameter [in] first parameter on curve
+  //! @param theLastParameter  [in] last  parameter on curve
+  //! @param theAngularDeflection   [in] angular deflection in radians
+  //! @param theCurvatureDeflection [in] linear deflection
+  //! @param theMinimumOfPoints [in] minimum number of points
+  //! @param theUTol   [in] tolerance in curve parametric scope
+  //! @param theMinLen [in] minimal length
+  Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& theC,
+                                   const Standard_Real theFirstParameter, const Standard_Real theLastParameter,
+                                   const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
+                                   const Standard_Integer theMinimumOfPoints = 2,
+                                   const Standard_Real theUTol = 1.0e-9,
+                                   const Standard_Real theMinLen = 1.0e-7);
+
   //! Add point to already calculated points (or replace existing)
   //! Returns index of new added point
   //! or founded with parametric tolerance (replaced if theIsReplace is true)
-  Standard_EXPORT Standard_Integer AddPoint (const gp_Pnt& thePnt, const Standard_Real theParam, const Standard_Boolean theIsReplace = Standard_True);
+  Standard_EXPORT Standard_Integer AddPoint (const gp_Pnt& thePnt,
-  
+                                             const Standard_Real theParam,
+                                             const Standard_Boolean theIsReplace = Standard_True);
+
   Standard_Integer NbPoints () const
   {
-    return parameters.Length ();
+    return myParameters.Length ();
   }
-  
+
   Standard_Real Parameter (const Standard_Integer I) const
   {
-    return parameters.Value (I);
+    return myParameters.Value (I);
   }
-  
+
   gp_Pnt Value (const Standard_Integer I) const
   {
-    return points.Value (I);
+    return myPoints.Value (I);
   }
-  
+
   //! Computes angular step for the arc using the given parameters.
-  Standard_EXPORT static Standard_Real ArcAngularStep (const Standard_Real theRadius, const Standard_Real theLinearDeflection, const Standard_Real theAngularDeflection, const Standard_Real theMinLength);
+  Standard_EXPORT static Standard_Real ArcAngularStep (const Standard_Real theRadius,
+                                                       const Standard_Real theLinearDeflection,
+                                                       const Standard_Real theAngularDeflection,
+                                                       const Standard_Real theMinLength);
 
 private:
-  
-  Standard_EXPORT void PerformLinear (const Adaptor3d_Curve& C);
-  
-  Standard_EXPORT void PerformLinear (const Adaptor2d_Curve2d& C);
-  
-  Standard_EXPORT void PerformCircular (const Adaptor3d_Curve& C);
-  
-  Standard_EXPORT void PerformCircular (const Adaptor2d_Curve2d& C);
-  
-  Standard_EXPORT void PerformCurve (const Adaptor3d_Curve& C);
-  
-  Standard_EXPORT void PerformCurve (const Adaptor2d_Curve2d& C);
-  
-  Standard_EXPORT void EvaluateDu (const Adaptor3d_Curve& C, const Standard_Real U, gp_Pnt& P, Standard_Real& Du, Standard_Boolean& NotDone) const;
-  
-  Standard_EXPORT void EvaluateDu (const Adaptor2d_Curve2d& C, const Standard_Real U, gp_Pnt& P, Standard_Real& Du, Standard_Boolean& NotDone) const;
 
-  Standard_EXPORT void EstimDefl (const Adaptor3d_Curve& C, const Standard_Real U1, const Standard_Real U2, 
+  template<class TheCurve>
-                                  Standard_Real& MaxDefl, Standard_Real& UMax);
+  void initialize (const TheCurve& theC,
-  
+                   const Standard_Real theFirstParameter, const Standard_Real theLastParameter,
-  Standard_EXPORT void EstimDefl (const Adaptor2d_Curve2d& C, const Standard_Real U1, const Standard_Real U2, 
+                   const Standard_Real theAngularDeflection, const Standard_Real theCurvatureDeflection,
-                                  Standard_Real& MaxDefl, Standard_Real& UMax);
+                   const Standard_Integer theMinimumOfPoints,
+                   const Standard_Real theUTol,
+                   const Standard_Real theMinLen);
+
+  template<class TheCurve>
+  void PerformLinear (const TheCurve& theC);
+
+  template<class TheCurve>
+  void PerformCircular (const TheCurve& theC);
+
+  //! Respecting the angle and the deflection,
+  //! we impose a minimum number of points on a curve.
+  template<class TheCurve>
+  void PerformCurve (const TheCurve& theC);
+
+  template<class TheCurve>
+  void EvaluateDu (const TheCurve& theC,
+                   const Standard_Real theU,
+                   gp_Pnt& theP,
+                   Standard_Real& theDu,
+                   Standard_Boolean& theNotDone) const;
+
+  //! Estimation of maximal deflection for interval [theU1, theU2]
+  template<class TheCurve>
+  void EstimDefl (const TheCurve& theC,
+                  const Standard_Real theU1, const Standard_Real theU2,
+                  Standard_Real& theMaxDefl, Standard_Real& theUMax);
 
 private:
-  Standard_Real angularDeflection;
+  Standard_Real myAngularDeflection;
-  Standard_Real curvatureDeflection;
+  Standard_Real myCurvatureDeflection;
-  Standard_Real uTol;
+  Standard_Real myUTol;
-  Standard_Integer minNbPnts;
+  Standard_Integer myMinNbPnts;
   Standard_Real myMinLen;
-  Standard_Real lastu;
+  Standard_Real myLastU;
-  Standard_Real firstu;
+  Standard_Real myFirstu;
-  TColgp_SequenceOfPnt points;
+  TColgp_SequenceOfPnt   myPoints;
-  TColStd_SequenceOfReal parameters;
+  TColStd_SequenceOfReal myParameters;
 };
 
 #endif // _GCPnts_TangentialDeflection_HeaderFile

src/GCPnts/GCPnts_TangentialDeflection.pxx

@@ -1,687 +0,0 @@
-// Created on: 1996-11-08
-// Created by: Jean Claude VAUTHIER
-// Copyright (c) 1996-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.
-
-#include <GCPnts_DeflectionType.hxx>
-#include <Standard_ConstructionError.hxx>
-#include <Precision.hxx>
-#include <gp_XYZ.hxx>
-#include <gp_Pnt.hxx>
-#include <gp_Vec.hxx>
-#include <gp.hxx>
-#include <NCollection_List.hxx>
-#include <math_PSO.hxx>
-#include <math_BrentMinimum.hxx>
-
-#define Us3 0.3333333333333333333333333333
-
-void GCPnts_TangentialDeflection::EvaluateDu (
-  const TheCurve& C,
-  const Standard_Real      U,
-  gp_Pnt&   P,
-  Standard_Real&     Du,
-  Standard_Boolean&  NotDone) const {
-
-  gp_Vec T, N;
-  D2 (C, U, P, T, N);
-  Standard_Real Lt   = T.Magnitude ();
-  Standard_Real LTol = Precision::Confusion ();
-  if (Lt > LTol && N.Magnitude () > LTol) {
-    Standard_Real Lc = N.CrossMagnitude (T);
-    Standard_Real Ln = Lc/Lt;
-    if (Ln > LTol) {
-      Du = sqrt (8.0 * Max(curvatureDeflection, myMinLen) / Ln);
-      NotDone = Standard_False;
-    }
-  }
-}
-
-
-//=======================================================================
-//function : GCPnts_TangentialDeflection
-//purpose  : 
-//=======================================================================
-
-GCPnts_TangentialDeflection::GCPnts_TangentialDeflection (
- const TheCurve&        C,
- const Standard_Real    AngularDeflection,
- const Standard_Real    CurvatureDeflection,
- const Standard_Integer MinimumOfPoints,
- const Standard_Real    UTol,
- const Standard_Real    theMinLen)
-
-{ 
-  Initialize (C,AngularDeflection,CurvatureDeflection,MinimumOfPoints,UTol,theMinLen); 
-}
-
-
-//=======================================================================
-//function : GCPnts_TangentialDeflection
-//purpose  : 
-//=======================================================================
-
-GCPnts_TangentialDeflection::GCPnts_TangentialDeflection (
- const TheCurve&        C,
- const Standard_Real    FirstParameter,
- const Standard_Real    LastParameter,
- const Standard_Real    AngularDeflection,
- const Standard_Real    CurvatureDeflection,
- const Standard_Integer MinimumOfPoints,
- const Standard_Real    UTol,
- const Standard_Real    theMinLen)
-
-{ 
-  Initialize (C, 
-        FirstParameter, 
-        LastParameter,
-        AngularDeflection, 
-        CurvatureDeflection, 
-        MinimumOfPoints,
-        UTol, theMinLen);
-}
-
-
-
-//=======================================================================
-//function : Initialize
-//purpose  : 
-//=======================================================================
-
-void GCPnts_TangentialDeflection::Initialize (
- const TheCurve&        C, 
- const Standard_Real    AngularDeflection, 
- const Standard_Real    CurvatureDeflection,
- const Standard_Integer MinimumOfPoints,
- const Standard_Real    UTol,
- const Standard_Real    theMinLen)
-
-{
-  Initialize (C, 
-              C.FirstParameter (), 
-              C.LastParameter (),
-              AngularDeflection, 
-              CurvatureDeflection,
-              MinimumOfPoints,
-              UTol, theMinLen);
-}
-
-
-//=======================================================================
-//function : Initialize
-//purpose  : 
-//=======================================================================
-
-void GCPnts_TangentialDeflection::Initialize (
- const TheCurve&        C, 
- const Standard_Real    FirstParameter, 
- const Standard_Real    LastParameter,
- const Standard_Real    AngularDeflection, 
- const Standard_Real    CurvatureDeflection,
- const Standard_Integer MinimumOfPoints,
- const Standard_Real    UTol,
- const Standard_Real    theMinLen)
-
-{
-  
-  Standard_ConstructionError_Raise_if (CurvatureDeflection < Precision::Confusion () ||
-                                       AngularDeflection < Precision::Angular (),
-                                       "GCPnts_TangentialDeflection::Initialize - Zero Deflection")
-
- parameters.Clear ();
- points    .Clear ();
- if (FirstParameter < LastParameter) {
-   firstu = FirstParameter;
-   lastu  = LastParameter;
- }
- else {
-   lastu  = FirstParameter;
-   firstu = LastParameter;
- }
- uTol                = UTol;
- angularDeflection   = AngularDeflection;
- curvatureDeflection = CurvatureDeflection;
- minNbPnts           = Max (MinimumOfPoints, 2);
- myMinLen            = Max(theMinLen, Precision::Confusion());
-
- switch (C.GetType()) {
-
- case GeomAbs_Line:   
-   PerformLinear (C);
-   break;
-
- case GeomAbs_Circle: 
-   PerformCircular (C);
-   break;
-
- case GeomAbs_BSplineCurve:
-   {
-     Handle_TheBSplineCurve BS = C.BSpline() ;
-     if (BS->NbPoles() == 2 ) PerformLinear (C);
-     else                     PerformCurve  (C);
-     break;
-   }
- case GeomAbs_BezierCurve:
-   {
-     Handle_TheBezierCurve  BZ = C.Bezier(); 
-     if (BZ->NbPoles() == 2) PerformLinear (C);
-     else                    PerformCurve  (C);
-     break;
-   }
- default: PerformCurve (C);
-   
- }
-}
-
-
-//=======================================================================
-//function : PerformLinear
-//purpose  : 
-//=======================================================================
-
-void GCPnts_TangentialDeflection::PerformLinear (const TheCurve& C) {
-
-  gp_Pnt P;
-  D0 (C, firstu, P);
-  parameters.Append (firstu);
-  points    .Append (P);
-  if (minNbPnts > 2)
-  {
-    Standard_Real Du = (lastu - firstu) / minNbPnts;
-    Standard_Real U = firstu + Du;
-    for (Standard_Integer i = 2; i < minNbPnts; i++)
-    {
-      D0 (C, U, P);
-      parameters.Append (U);
-      points    .Append (P);
-      U += Du;
-    }
-  }
-  D0 (C, lastu, P);
-  parameters.Append (lastu);
-  points    .Append (P);
-}
-
-//=======================================================================
-//function : PerformCircular
-//purpose  : 
-//=======================================================================
-
-void GCPnts_TangentialDeflection::PerformCircular (const TheCurve& C) 
-{
-  // akm 8/01/02 : check the radius before divide by it
-  Standard_Real dfR = C.Circle().Radius();
-  Standard_Real Du = GCPnts_TangentialDeflection::ArcAngularStep(
-    dfR, curvatureDeflection, angularDeflection, myMinLen);
-    
-  const Standard_Real aDiff = lastu - firstu;
-  // Round up number of points to satisfy curvatureDeflection more precisely
-  Standard_Integer NbPoints = (Standard_Integer)Min(Ceiling(aDiff / Du), 1.0e+6);
-  NbPoints = Max(NbPoints, minNbPnts - 1);
-  Du       = aDiff / NbPoints;
-
-  gp_Pnt P;
-  Standard_Real U = firstu;
-  for (Standard_Integer i = 1; i <= NbPoints; i++)
-  {
-    D0 (C, U, P);
-    parameters.Append (U);
-    points    .Append (P);
-    U += Du;
-  }
-  D0 (C, lastu, P);
-  parameters.Append (lastu);
-  points    .Append (P);
-}
-
-
-//=======================================================================
-//function : PerformCurve
-//purpose  : On respecte ll'angle et la fleche, on peut imposer un nombre
-//           minimum de points sur un element lineaire
-//=======================================================================
-void GCPnts_TangentialDeflection::PerformCurve (const TheCurve& C)
-
-{
-  Standard_Integer i, j;       
-  gp_XYZ V1, V2;
-  gp_Pnt MiddlePoint, CurrentPoint, LastPoint;   
-  Standard_Real Du, Dusave, MiddleU, L1, L2;
-
-  Standard_Real U1       = firstu;   
-  Standard_Real LTol     = Precision::Confusion ();  //protection longueur nulle
-  Standard_Real ATol     = 1.e-2 * angularDeflection;
-  if(ATol > 1.e-2)
-    ATol = 1.e-2;
-  else if(ATol < 1.e-7)
-    ATol = 1.e-7;
-
-  D0 (C, lastu, LastPoint);
-
-  //Initialization du calcul
-
-  Standard_Boolean NotDone = Standard_True;
-  Dusave = (lastu - firstu)*Us3;
-  Du     = Dusave;
-  EvaluateDu (C, U1, CurrentPoint, Du, NotDone);
-  parameters.Append (U1);
-  points    .Append (CurrentPoint);
-
-  // Used to detect "isLine" current bspline and in Du computation in general handling.
-  Standard_Integer NbInterv = C.NbIntervals(GeomAbs_CN);
-  TColStd_Array1OfReal Intervs(1, NbInterv+1);
-  C.Intervals(Intervs, GeomAbs_CN);
-
-  if (NotDone || Du > 5. * Dusave) {
-    //C'est soit une droite, soit une singularite :
-    V1 = (LastPoint.XYZ() - CurrentPoint.XYZ());
-    L1 = V1.Modulus ();
-    if (L1 > LTol)
-    {
-      //Si c'est une droite on verifie en calculant minNbPoints :
-      Standard_Boolean IsLine   = Standard_True;
-      Standard_Integer NbPoints = (minNbPnts > 3) ? minNbPnts : 3;
-      switch (C.GetType()) {
-      case GeomAbs_BSplineCurve:
-        {
-          Handle_TheBSplineCurve BS = C.BSpline() ;
-          NbPoints = Max(BS->Degree() + 1, NbPoints);
-          break;
-        }
-      case GeomAbs_BezierCurve:
-        {
-          Handle_TheBezierCurve  BZ = C.Bezier();
-          NbPoints = Max(BZ->Degree() + 1, NbPoints);
-          break;
-        }
-      default:
-      ;}
-      ////
-      Standard_Real param = 0.;
-      for (i = 1; i <= NbInterv && IsLine; ++i)
-      {
-        // Avoid usage intervals out of [firstu, lastu].
-        if ((Intervs(i+1) < firstu) ||
-            (Intervs(i)   > lastu))
-        {
-          continue;
-        }
-        // Fix border points in applicable intervals, to avoid be out of target interval.
-        if ((Intervs(i)   < firstu) &&
-            (Intervs(i+1) > firstu))
-        {
-          Intervs(i) = firstu;
-        }
-        if ((Intervs(i)   < lastu) &&
-            (Intervs(i+1) > lastu))
-        {
-          Intervs(i + 1) = lastu;
-        }
-
-        Standard_Real delta = (Intervs(i+1) - Intervs(i))/NbPoints;
-        for (j = 1; j <= NbPoints && IsLine; ++j)
-        {
-          param = Intervs(i) + j*delta;
-          D0 (C, param, MiddlePoint);
-          V2 = (MiddlePoint.XYZ() - CurrentPoint.XYZ());
-          L2 = V2.Modulus ();
-          if (L2 > LTol)
-          {
-            const Standard_Real aAngle = V2.CrossMagnitude(V1)/(L1*L2);
-            IsLine = (aAngle < ATol);
-          }
-        }
-      }
-
-      if (IsLine)
-      {
-        parameters.Clear();
-        points    .Clear();
-
-        PerformLinear(C);
-        return;
-      }
-      else
-      {
-        //c'etait une singularite on continue :
-        //Du = Dusave;
-        EvaluateDu (C, param, MiddlePoint, Du, NotDone);
-      }
-    }
-    else
-    {
-      Du = (lastu-firstu)/2.1;
-      MiddleU = firstu + Du;
-      D0 (C, MiddleU, MiddlePoint);
-      V1 = (MiddlePoint.XYZ() - CurrentPoint.XYZ());
-      L1 = V1.Modulus ();
-      if (L1 < LTol)
-      {
-        // L1 < LTol C'est une courbe de longueur nulle, calcul termine :
-        // on renvoi un segment de 2 points   (protection)
-        parameters.Append (lastu);
-        points    .Append (LastPoint);
-        return;
-      }
-    }
-  }
-
-  if (Du > Dusave) Du = Dusave;
-  else             Dusave = Du;
-
-  if (Du < uTol) {
-    Du = lastu - firstu;
-    if (Du < uTol) {
-      parameters.Append (lastu);
-      points    .Append (LastPoint);
-      return;
-    }
-  }
-
-  //Traitement normal pour une courbe
-  Standard_Boolean MorePoints = Standard_True;
-  Standard_Real U2            = firstu;   
-  Standard_Real AngleMax      = angularDeflection * 0.5;  //car on prend le point milieu
-  Standard_Integer aIdx[2] = {Intervs.Lower(), Intervs.Lower()}; // Indexes of intervals of U1 and U2, used to handle non-uniform case.
-  Standard_Boolean isNeedToCheck = Standard_False;
-  gp_Pnt aPrevPoint = points.Last();
-
-  while (MorePoints) {
-    aIdx[0] = getIntervalIdx(U1, Intervs, aIdx[0]);
-    U2 += Du;
-
-    if (U2 >= lastu) {                       //Bout de courbe
-      U2 = lastu;
-      CurrentPoint = LastPoint;
-      Du = U2-U1;
-      Dusave = Du;
-    }
-    else D0 (C, U2, CurrentPoint);           //Point suivant
-
-    Standard_Real Coef = 0.0, ACoef = 0., FCoef = 0.;
-    Standard_Boolean Correction, TooLarge, TooSmall;
-    TooLarge   = Standard_False;
-    Correction = Standard_True;
-    TooSmall = Standard_False;
-
-    while (Correction) {                     //Ajustement Du
-      if (isNeedToCheck)
-      {
-        aIdx[1] = getIntervalIdx(U2, Intervs, aIdx[0]);
-        if (aIdx[1] > aIdx[0]) // Jump to another polynom.
-        {
-          if (Du > (Intervs(aIdx[0] + 1) - Intervs(aIdx[0]) ) * Us3) // Set Du to the smallest value and check deflection on it.
-          {
-            Du = (Intervs(aIdx[0] + 1) - Intervs(aIdx[0]) ) * Us3;
-            U2 = U1 + Du;
-            if (U2 > lastu)
-              U2 = lastu;
-            D0 (C, U2, CurrentPoint);
-          }
-        }
-      }
-      MiddleU = (U1+U2)*0.5;                 //Verif / au point milieu
-      D0 (C, MiddleU, MiddlePoint);
-
-      V1 = (CurrentPoint.XYZ() - aPrevPoint.XYZ()); //Critere de fleche
-      V2 = (MiddlePoint.XYZ()  - aPrevPoint.XYZ());
-      L1 = V1.Modulus ();
-
-      FCoef = (L1 > myMinLen) ? 
-        V1.CrossMagnitude(V2)/(L1*curvatureDeflection) : 0.0;
-
-      V1 = (CurrentPoint.XYZ() - MiddlePoint.XYZ()); //Critere d'angle
-      L1 = V1.Modulus ();
-      L2 = V2.Modulus ();
-      if (L1 > myMinLen && L2 > myMinLen)
-      {
-        Standard_Real angg = V1.CrossMagnitude(V2) / (L1 * L2);
-        ACoef = angg / AngleMax;
-      }
-      else
-        ACoef = 0.0;
-
-      //On retient le plus penalisant
-      Coef = Max(ACoef, FCoef);
-
-      if (isNeedToCheck && Coef < 0.55)
-      {
-        isNeedToCheck = Standard_False;
-        Du = Dusave;
-        U2 = U1 + Du;
-        if (U2 > lastu)
-          U2 = lastu;
-        D0 (C, U2, CurrentPoint);
-        continue;
-      }
-
-      if (Coef <= 1.0) {
-        if (Abs (lastu-U2) < uTol) {
-          parameters.Append (lastu);
-          points    .Append (LastPoint);
-          MorePoints = Standard_False;
-          Correction = Standard_False;
-        }
-        else {
-          if (Coef >= 0.55 || TooLarge) { 
-            parameters.Append (U2);
-            points    .Append (CurrentPoint);
-            aPrevPoint = CurrentPoint;
-            Correction = Standard_False;
-            isNeedToCheck = Standard_True;
-          }
-          else if (TooSmall) {
-            Correction = Standard_False;
-            aPrevPoint = CurrentPoint;
-          }
-          else {
-            TooSmall = Standard_True;
-            //Standard_Real UUU2 = U2;
-            Du += Min((U2-U1)*(1.-Coef), Du*Us3);
-
-            U2 = U1 + Du;
-            if (U2 > lastu)
-              U2 = lastu;
-            D0 (C, U2, CurrentPoint);
-          }
-        }
-      }
-      else {
-
-        if (Coef >= 1.5) {
-          if (!aPrevPoint.IsEqual(points.Last(), Precision::Confusion()))
-          {
-            parameters.Append (U1);
-            points    .Append (aPrevPoint);
-          }
-          U2 = MiddleU;
-          Du  = U2-U1;
-          CurrentPoint = MiddlePoint;
-        }
-        else {
-          Du*=0.9;
-          U2 = U1 + Du;
-          D0 (C, U2, CurrentPoint);
-          TooLarge = Standard_True;
-        }
-
-      }
-    }
-    
-    Du  = U2-U1;
-
-    if (MorePoints) {
-      if (U1 > firstu) {
-        if (FCoef > ACoef) {
-          //La fleche est critere de decoupage
-          EvaluateDu (C, U2, CurrentPoint, Du, NotDone);
-          if (NotDone) {
-            Du += (Du-Dusave)*(Du/Dusave);
-            if (Du > 1.5 * Dusave) Du = 1.5  * Dusave;
-            if (Du < 0.75* Dusave) Du = 0.75 * Dusave;
-          }
-        }
-        else {
-          //L'angle est le critere de decoupage
-          Du += (Du-Dusave)*(Du/Dusave);
-          if (Du > 1.5 * Dusave) Du = 1.5  * Dusave;
-          if (Du < 0.75* Dusave) Du = 0.75 * Dusave;
-        }
-      }
-      
-      if (Du < uTol) {
-        Du = lastu - U2;
-        if (Du < uTol) {
-          parameters.Append (lastu);
-          points    .Append (LastPoint);
-          MorePoints = Standard_False;
-        }
-        else if (Du*Us3 > uTol) Du*=Us3;
-      }
-      U1 = U2;
-      Dusave = Du;
-    }
-  }
-  //Recalage avant dernier point :
-  i = points.Length()-1;
-//  Real d = points (i).Distance (points (i+1));
-// if (Abs(parameters (i) - parameters (i+1))<= 0.000001 || d < Precision::Confusion()) {
-//    cout<<"deux points confondus"<<endl;
-//    parameters.Remove (i+1);
-//    points.Remove (i+1);
-//    i--;
-//  }
-  if (i >= 2) {
-    MiddleU = parameters (i-1);
-    MiddleU = (lastu + MiddleU)*0.5;
-    D0 (C, MiddleU, MiddlePoint);
-    parameters.SetValue (i, MiddleU);
-    points    .SetValue (i, MiddlePoint);
-  }
-
-  //-- On rajoute des points aux milieux des segments si le nombre
-  //-- mini de points n'est pas atteint
-  //--
-  Standard_Integer Nbp = points.Length();
-
-  //std::cout << "GCPnts_TangentialDeflection: Number of Points (" << Nbp << " " << minNbPnts << " )" << std::endl;
-
-  while(Nbp < minNbPnts)
-  { 
-    for (i = 2; i <= Nbp; i += 2)
-    {
-      MiddleU = (parameters.Value(i-1)+parameters.Value(i))*0.5;
-      D0 (C, MiddleU, MiddlePoint); 
-      parameters.InsertBefore(i,MiddleU);
-      points.InsertBefore(i,MiddlePoint);
-      Nbp++;
-    }
-  }
-  //Additional check for intervals
-  Standard_Real MinLen2 = myMinLen * myMinLen;
-  Standard_Integer MaxNbp = 10 * Nbp;
-  for(i = 1; i < Nbp; ++i)
-  {
-    U1 = parameters(i);
-    U2 = parameters(i + 1);
-
-    if (U2 - U1 <= uTol)
-    {
-      continue;
-    }
-
-    // Check maximal deflection on interval;
-    Standard_Real dmax = 0.;
-    Standard_Real umax = 0.;
-    Standard_Real amax = 0.;
-    EstimDefl(C, U1, U2, dmax, umax);
-    const gp_Pnt& P1 = points(i);
-    const gp_Pnt& P2 = points(i+1);
-    D0(C, umax, MiddlePoint);
-    amax = EstimAngl(P1, MiddlePoint, P2);
-    if(dmax > curvatureDeflection || amax > AngleMax)
-    {
-      if(umax - U1 > uTol && U2 - umax > uTol)
-      {
-        if (P1.SquareDistance(MiddlePoint) > MinLen2 && P2.SquareDistance(MiddlePoint) > MinLen2)
-        {
-          parameters.InsertAfter(i, umax);
-          points.InsertAfter(i, MiddlePoint);
-          ++Nbp;
-          --i; //To compensate ++i in loop header: i must point to first part of split interval
-          if(Nbp > MaxNbp)
-          {
-            break;
-          }
-        }
-      }
-    }
-  }
-  // 
-}
-
-//=======================================================================
-//function : EstimDefl
-//purpose  : Estimation of maximal deflection for interval [U1, U2]
-//           
-//=======================================================================
-void GCPnts_TangentialDeflection::EstimDefl (const TheCurve& C,
-                            const Standard_Real U1, const Standard_Real U2, 
-                            Standard_Real& MaxDefl, Standard_Real& UMax)
-{
-  Standard_Real Du = (lastu - firstu);
-  //
-  TheMaxCurvLinDist aFunc(C, U1, U2);
-  //
-  const Standard_Integer aNbIter = 100;
-  Standard_Real reltol = Max(1.e-3, 2.*uTol/((Abs(U1) + Abs(U2))));
-  //
-  math_BrentMinimum anOptLoc(reltol, aNbIter, uTol);
-  anOptLoc.Perform(aFunc, U1, (U1+U2)/2., U2);
-  if(anOptLoc.IsDone())
-  {
-    MaxDefl = Sqrt(-anOptLoc.Minimum());
-    UMax = anOptLoc.Location();
-    return;
-  }
-  //
-  math_Vector aLowBorder(1,1);
-  math_Vector aUppBorder(1,1);
-  math_Vector aSteps(1,1);
-  //
-  aSteps(1) = Max(0.1 * Du, 100. * uTol);
-  Standard_Integer aNbParticles = Max(8, RealToInt(32 * (U2 - U1) / Du));
-  //
-  aLowBorder(1) = U1;
-  aUppBorder(1) = U2;
-  //
-  //
-  Standard_Real aValue;
-  math_Vector aT(1,1);
-  TheMaxCurvLinDistMV aFuncMV(aFunc);
-
-  math_PSO aFinder(&aFuncMV, aLowBorder, aUppBorder, aSteps, aNbParticles); 
-  aFinder.Perform(aSteps, aValue, aT);
-  //
-  anOptLoc.Perform(aFunc, Max(aT(1) - aSteps(1), U1) , aT(1), Min(aT(1) + aSteps(1),U2));
-  if(anOptLoc.IsDone())
-  {
-    MaxDefl = Sqrt(-anOptLoc.Minimum());
-    UMax = anOptLoc.Location();
-    return;
-  }
-  MaxDefl = Sqrt(-aValue);
-  UMax = aT(1);
-  //
-}