0024553: Deleting obsolete/unused ".gxx" files from "GCPnts"
authorabv <abv@opencascade.com>
Fri, 17 Jun 2016 08:36:49 +0000 (11:36 +0300)
committerbugmaster <bugmaster@opencascade.com>
Thu, 23 Jun 2016 15:14:40 +0000 (18:14 +0300)
Extension of files GXX is changed to "pxx" to avoid them to be copied to inc folder.
Code of inline functions contained in LXX files is merged to HXX files, LXX files are removed.

31 files changed:
src/GCPnts/FILES
src/GCPnts/GCPnts_AbscissaPoint.cxx
src/GCPnts/GCPnts_AbscissaPoint.gxx [deleted file]
src/GCPnts/GCPnts_AbscissaPoint.hxx
src/GCPnts/GCPnts_AbscissaPoint.lxx [deleted file]
src/GCPnts/GCPnts_AbscissaPoint.pxx [new file with mode: 0644]
src/GCPnts/GCPnts_QuasiUniformAbscissa.cxx
src/GCPnts/GCPnts_QuasiUniformAbscissa.gxx [deleted file]
src/GCPnts/GCPnts_QuasiUniformAbscissa.hxx
src/GCPnts/GCPnts_QuasiUniformAbscissa.lxx [deleted file]
src/GCPnts/GCPnts_QuasiUniformAbscissa.pxx [new file with mode: 0644]
src/GCPnts/GCPnts_QuasiUniformDeflection.cxx
src/GCPnts/GCPnts_QuasiUniformDeflection.gxx [deleted file]
src/GCPnts/GCPnts_QuasiUniformDeflection.hxx
src/GCPnts/GCPnts_QuasiUniformDeflection.lxx [deleted file]
src/GCPnts/GCPnts_QuasiUniformDeflection.pxx [new file with mode: 0644]
src/GCPnts/GCPnts_TangentialDeflection.cxx
src/GCPnts/GCPnts_TangentialDeflection.gxx [deleted file]
src/GCPnts/GCPnts_TangentialDeflection.hxx
src/GCPnts/GCPnts_TangentialDeflection.lxx [deleted file]
src/GCPnts/GCPnts_TangentialDeflection.pxx [new file with mode: 0644]
src/GCPnts/GCPnts_UniformAbscissa.cxx
src/GCPnts/GCPnts_UniformAbscissa.gxx [deleted file]
src/GCPnts/GCPnts_UniformAbscissa.hxx
src/GCPnts/GCPnts_UniformAbscissa.lxx [deleted file]
src/GCPnts/GCPnts_UniformAbscissa.pxx [new file with mode: 0644]
src/GCPnts/GCPnts_UniformDeflection.cxx
src/GCPnts/GCPnts_UniformDeflection.gxx [deleted file]
src/GCPnts/GCPnts_UniformDeflection.hxx
src/GCPnts/GCPnts_UniformDeflection.lxx [deleted file]
src/GCPnts/GCPnts_UniformDeflection.pxx [new file with mode: 0644]

index e5f0bed..29ead1d 100755 (executable)
@@ -1,29 +1,23 @@
 GCPnts_AbscissaPoint.cxx
-GCPnts_AbscissaPoint.gxx
+GCPnts_AbscissaPoint.pxx
 GCPnts_AbscissaPoint.hxx
-GCPnts_AbscissaPoint.lxx
 GCPnts_AbscissaType.hxx
 GCPnts_DeflectionType.hxx
 GCPnts_QuasiUniformAbscissa.cxx
-GCPnts_QuasiUniformAbscissa.gxx
+GCPnts_QuasiUniformAbscissa.pxx
 GCPnts_QuasiUniformAbscissa.hxx
-GCPnts_QuasiUniformAbscissa.lxx
 GCPnts_QuasiUniformDeflection.cxx
-GCPnts_QuasiUniformDeflection.gxx
+GCPnts_QuasiUniformDeflection.pxx
 GCPnts_QuasiUniformDeflection.hxx
-GCPnts_QuasiUniformDeflection.lxx
 GCPnts_TangentialDeflection.cxx
-GCPnts_TangentialDeflection.gxx
+GCPnts_TangentialDeflection.pxx
 GCPnts_TangentialDeflection.hxx
-GCPnts_TangentialDeflection.lxx
 GCPnts_UniformAbscissa.cxx
-GCPnts_UniformAbscissa.gxx
+GCPnts_UniformAbscissa.pxx
 GCPnts_UniformAbscissa.hxx
-GCPnts_UniformAbscissa.lxx
 GCPnts_UniformDeflection.cxx
-GCPnts_UniformDeflection.gxx
+GCPnts_UniformDeflection.pxx
 GCPnts_UniformDeflection.hxx
-GCPnts_UniformDeflection.lxx
 GCPnts_DistFunction.hxx
 GCPnts_DistFunction.cxx
 GCPnts_DistFunction2d.hxx
index 29c5ae5..a536647 100644 (file)
@@ -36,7 +36,7 @@ GCPnts_AbscissaPoint::GCPnts_AbscissaPoint()
 #define Handle_TheBezierCurve   Handle(Geom_BezierCurve)
 #define Handle_TheBSplineCurve  Handle(Geom_BSplineCurve)
 
-#include <GCPnts_AbscissaPoint.gxx>
+#include "GCPnts_AbscissaPoint.pxx"
 
 #undef TheCurve
 #undef Handle_TheBezierCurve
@@ -49,5 +49,4 @@ GCPnts_AbscissaPoint::GCPnts_AbscissaPoint()
 #define Handle_TheBezierCurve   Handle(Geom2d_BezierCurve)
 #define Handle_TheBSplineCurve  Handle(Geom2d_BSplineCurve)
 
-#include <GCPnts_AbscissaPoint.gxx>
-
+#include "GCPnts_AbscissaPoint.pxx"
diff --git a/src/GCPnts/GCPnts_AbscissaPoint.gxx b/src/GCPnts/GCPnts_AbscissaPoint.gxx
deleted file mode 100644 (file)
index 5cba7bb..0000000
+++ /dev/null
@@ -1,474 +0,0 @@
-// Created on: 1995-05-05
-// Created by: Modelistation
-// Copyright (c) 1995-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.
-
-// Dimension independant used to implement GCPnts_AbscissaPoint
-
-// compute the type 
-// and the length ratio if GCPnts_LengthParametrized
-#include <GCPnts_AbscissaType.hxx>
-#include <gp_Vec.hxx>
-#include <gp_Vec2d.hxx>
-#include <gp_Circ.hxx>
-#include <gp_Circ2d.hxx>
-#include <Precision.hxx>
-#include <TColStd_Array1OfReal.hxx>
-#include <BSplCLib.hxx>
-
-static GCPnts_AbscissaType computeType( const TheCurve& C,
-                                      Standard_Real& Ratio)
-{
-  GCPnts_AbscissaType LocalType ;
-
-  if (C.NbIntervals(GeomAbs_CN) > 1)
-    return GCPnts_AbsComposite;
-
-  switch (C.GetType()) {
-    
-  case GeomAbs_Line:
-    Ratio = 1.0e0 ;
-    return GCPnts_LengthParametrized;
-
-  case GeomAbs_Circle:
-    Ratio = C.Circle().Radius();
-    return GCPnts_LengthParametrized;
-
-  case GeomAbs_BezierCurve:
-    {
-      Handle_TheBezierCurve Bz = C.Bezier();
-      if ((Bz->NbPoles() == 2) && !(Bz->IsRational())) {
-       Ratio = Bz->DN(0,1).Magnitude();
-       LocalType =  GCPnts_LengthParametrized;
-      }
-      else
-       LocalType = GCPnts_Parametrized;
-      return LocalType ;
-    }
-  case GeomAbs_BSplineCurve:
-    {
-      Handle_TheBSplineCurve Bs = C.BSpline();
-      if ((Bs->NbPoles() == 2) && !(Bs->IsRational())) {
-       Ratio = Bs->DN(Bs->FirstParameter(),1).Magnitude();
-       LocalType = GCPnts_LengthParametrized;
-      }
-      else
-       LocalType = GCPnts_Parametrized;
-      return LocalType ; 
-    }
-    default:
-      return GCPnts_Parametrized;
-    
-  }
-}
-
-// compute a point at distance Abscis from parameter U0
-// using Ui as initial guess
-
-static void Compute(CPnts_AbscissaPoint& theComputer,
-                    const TheCurve& C,
-                    Standard_Real& Abscis,
-                   Standard_Real& U0,
-                   Standard_Real& Ui,
-                   const Standard_Real EPSILON) 
-{
-  // test for easy solution
-  if (Abs(Abscis) <= Precision::Confusion()) {
-    theComputer.SetParameter(U0);
-    return;
-  }
-
-  Standard_Real Ratio = 1.;
-  GCPnts_AbscissaType Type = computeType(C,Ratio);
-
-  switch (Type) {
-  case GCPnts_LengthParametrized : 
-    theComputer.SetParameter(U0 + Abscis / Ratio);
-    return;
-
-  case GCPnts_Parametrized : 
-    theComputer.Init(C);
-    theComputer.Perform(Abscis, U0, Ui, EPSILON);
-    return;
-
-  case GCPnts_AbsComposite : 
-    {
-      Standard_Integer NbIntervals = C.NbIntervals(GeomAbs_CN);
-      TColStd_Array1OfReal TI(1,NbIntervals+1);
-      C.Intervals(TI,GeomAbs_CN);
-      Standard_Real L = 0.0, sign = 1.;
-      Standard_Integer Index = 1;
-      BSplCLib::Hunt(TI,U0,Index);
-      Standard_Integer Direction = 1;
-      if (Abscis < 0) {
-       Direction = 0;
-       Abscis = -Abscis;
-       sign = -1.;
-      }
-
-      while ((Index >= 1) && (Index <= NbIntervals)) {
-
-       L = CPnts_AbscissaPoint::Length(C, U0, TI(Index+Direction));
-       if (Abs(L - Abscis) <= Precision::Confusion()) {
-         theComputer.SetParameter(TI(Index+Direction));
-         return;
-       }
-       if(L > Abscis) {
-         if ((Ui < TI(Index)) || (Ui > TI(Index+1))) {
-           Ui = (Abscis / L) * (TI(Index+1) - U0);
-           if (Direction)
-             Ui = U0 + Ui;
-           else
-             Ui = U0 - Ui;
-         }
-         theComputer.Init(C,TI(Index),TI(Index+1));
-         theComputer.Perform(sign*Abscis, U0, Ui, EPSILON);
-         return;
-       }
-       else {
-         U0 = TI(Index+Direction);
-         Abscis -= L;
-       }
-       if (Direction)
-         Index++;
-       else
-         Index--;
-      }
-
-      // Push a little bit outside the limits (hairy !!!)
-      Ui = U0 + 0.1;
-      theComputer.Init(C,U0,U0+0.2);
-      theComputer.Perform(sign*Abscis, U0, Ui, EPSILON);
-      return;
-    }
-    break;
-  }
-
-}
-
-// introduced by rbv for curvilinear parametrization
-// performs more apropriate tolerance managment
-
-static void AdvCompute(CPnts_AbscissaPoint& theComputer,
-                    const TheCurve& C,
-                    Standard_Real& Abscis,
-                   Standard_Real& U0,
-                   Standard_Real& Ui,
-                   const Standard_Real EPSILON) 
-{
-  Standard_Real Ratio;
-  GCPnts_AbscissaType Type = computeType(C,Ratio);
-
-  switch (Type) {
-  case GCPnts_LengthParametrized : 
-    theComputer.SetParameter(U0 + Abscis / Ratio);
-    return;
-
-  case GCPnts_Parametrized : 
-//    theComputer.Init(C);
-    theComputer.Init(C, EPSILON); //rbv's modification
-//
-    theComputer.AdvPerform(Abscis, U0, Ui, EPSILON);
-    return;
-
-  case GCPnts_AbsComposite : 
-    {
-      Standard_Integer NbIntervals = C.NbIntervals(GeomAbs_CN);
-      TColStd_Array1OfReal TI(1,NbIntervals+1);
-      C.Intervals(TI,GeomAbs_CN);
-      Standard_Real L = 0.0, sign = 1.;
-      Standard_Integer Index = 1;
-      BSplCLib::Hunt(TI,U0,Index);
-       
-      Standard_Integer Direction = 1;
-      if (Abscis < 0) {
-       Direction = 0;
-       Abscis = -Abscis;
-       sign = -1.;
-      }
-
-      if(Index == 0 && Direction > 0) {
-       L = CPnts_AbscissaPoint::Length(C, U0, TI(Index+Direction), EPSILON);
-       if (Abs(L - Abscis) <= /*Precision::Confusion()*/EPSILON) {
-         theComputer.SetParameter(TI(Index+Direction));
-         return;
-       }
-       if(L > Abscis) {
-         if ( Ui > TI(Index+1) ) {
-           Ui = (Abscis / L) * (TI(Index+1) - U0);
-           Ui = U0 + Ui;
-         }
-         theComputer.Init(C,U0,TI(Index+1), EPSILON);
-         theComputer.AdvPerform(sign*Abscis, U0, Ui, EPSILON);
-         return;
-       }
-       else {
-         U0 = TI(Index+Direction);
-         Abscis -= L;
-       }
-       Index++;
-      }
-         
-
-      while ((Index >= 1) && (Index <= NbIntervals)) {
-
-       L = CPnts_AbscissaPoint::Length(C, U0, TI(Index+Direction), EPSILON);
-       if (Abs(L - Abscis) <= Precision::PConfusion()) {
-         theComputer.SetParameter(TI(Index+Direction));
-         return;
-       }
-       if(L > Abscis) {
-         if ((Ui < TI(Index)) || (Ui > TI(Index+1))) {
-           Ui = (Abscis / L) * (TI(Index+1) - U0);
-           if (Direction)
-             Ui = U0 + Ui;
-           else
-             Ui = U0 - Ui;
-         }
-         theComputer.Init(C,TI(Index),TI(Index+1), EPSILON);
-         theComputer.AdvPerform(sign*Abscis, U0, Ui, EPSILON);
-         return;
-       }
-       else {
-         U0 = TI(Index+Direction);
-         Abscis -= L;
-       }
-       if (Direction) {
-         Index++;
-
-       }
-       else {
-         Index--;
-
-       }
-      }
-
-      // Push a little bit outside the limits (hairy !!!)
-
-      Standard_Boolean nonperiodic = !C.IsPeriodic();
-      Ui = U0 + sign*0.1;
-      Standard_Real U1 = U0 + sign*.2;
-      if(nonperiodic) {
-       if(sign > 0) {
-         Ui = Min(Ui,C.LastParameter());
-          U1 = Min(U1, C.LastParameter());
-       }
-       else {
-         Ui = Max(Ui,C.FirstParameter());
-          U1 = Max(U1, C.FirstParameter());
-       }
-      }
-         
-      theComputer.Init(C, U0, U1, EPSILON);
-      theComputer.AdvPerform(sign*Abscis, U0, Ui, EPSILON);
-      return;
-    }
-    break;
-  }
-
-}
-
-//=======================================================================
-//function : Length
-//purpose  : 
-//=======================================================================
-
-Standard_Real GCPnts_AbscissaPoint::Length(const TheCurve& C)
-{
-  return GCPnts_AbscissaPoint::Length(C,C.FirstParameter(), 
-                                     C.LastParameter());
-}
-
-//=======================================================================
-//function : Length
-//purpose  : 
-//=======================================================================
-
-Standard_Real GCPnts_AbscissaPoint::Length(const TheCurve& C,
-                                          const Standard_Real Tol)
-{
-  return GCPnts_AbscissaPoint::Length(C,C.FirstParameter(), 
-                                     C.LastParameter(),Tol);
-}
-
-
-//=======================================================================
-//function : Length
-//purpose  : 
-//=======================================================================
-
-Standard_Real GCPnts_AbscissaPoint::Length(const TheCurve& C,
-                                          const Standard_Real U1,
-                                          const Standard_Real U2)
-{
-  Standard_Real Ratio;
-  GCPnts_AbscissaType Type = computeType(C,Ratio);
-  switch (Type) {
-
-  case GCPnts_LengthParametrized: 
-    return Abs(U2-U1) * Ratio;
-                
-  case GCPnts_Parametrized: 
-    return CPnts_AbscissaPoint::Length(C, U1, U2);
-
-  case GCPnts_AbsComposite: 
-    {
-      Standard_Integer NbIntervals = C.NbIntervals(GeomAbs_CN);
-      TColStd_Array1OfReal TI(1,NbIntervals+1);
-      C.Intervals(TI,GeomAbs_CN);
-      Standard_Real UU1 = Min(U1, U2);
-      Standard_Real UU2 = Max(U1, U2);
-      Standard_Real L = 0.0;
-      for(Standard_Integer Index = 1; Index <= NbIntervals; Index++) {
-       if (TI(Index)   > UU2) break;
-       if (TI(Index+1) < UU1) continue;
-       L += CPnts_AbscissaPoint::Length(C, 
-                                        Max(TI(Index),UU1),
-                                        Min(TI(Index+1),UU2));
-      }
-      return L;
-    }
-  }
-  return RealLast();
-}
-
-//=======================================================================
-//function : Length
-//purpose  : 
-//=======================================================================
-
-Standard_Real GCPnts_AbscissaPoint::Length(const TheCurve& C,
-                                          const Standard_Real U1,
-                                          const Standard_Real U2,
-                                          const Standard_Real Tol)
-{
-  Standard_Real Ratio;
-  GCPnts_AbscissaType Type = computeType(C,Ratio);
-  switch (Type) {
-
-  case GCPnts_LengthParametrized: 
-    return Abs(U2-U1) * Ratio;
-                
-  case GCPnts_Parametrized: 
-    return CPnts_AbscissaPoint::Length(C, U1, U2, Tol);
-
-  case GCPnts_AbsComposite: 
-    {
-      Standard_Integer NbIntervals = C.NbIntervals(GeomAbs_CN);
-      TColStd_Array1OfReal TI(1,NbIntervals+1);
-      C.Intervals(TI,GeomAbs_CN);
-      Standard_Real UU1 = Min(U1, U2);
-      Standard_Real UU2 = Max(U1, U2);
-      Standard_Real L = 0.0;
-      for(Standard_Integer Index = 1; Index <= NbIntervals; Index++) {
-       if (TI(Index)   > UU2) break;
-       if (TI(Index+1) < UU1) continue;
-       L += CPnts_AbscissaPoint::Length(C, 
-                                        Max(TI(Index),UU1),
-                                        Min(TI(Index+1),UU2),
-                                        Tol);
-      }
-      return L;
-    }
-  }
-  return RealLast();
-}
-
-
-//=======================================================================
-//function : GCPnts_AbscissaPoint
-//purpose  : 
-//=======================================================================
-
-GCPnts_AbscissaPoint::GCPnts_AbscissaPoint
-                                  (const TheCurve& C,
-                                  const Standard_Real   Abscissa,
-                                  const Standard_Real   U0)
-{
-  Standard_Real L = GCPnts_AbscissaPoint::Length(C);
-  if (L < Precision::Confusion()) {
-    Standard_ConstructionError::Raise();
-  } 
-  Standard_Real Abscis = Abscissa;
-  Standard_Real UU0 = U0;
-  Standard_Real UUi = U0 + 
-    (Abscis / L) * (C.LastParameter() - C.FirstParameter());
-  Compute(myComputer, C, Abscis, UU0, UUi,
-         C.Resolution(Precision::Confusion()));  
-}
-
-//=======================================================================
-//function : GCPnts_AbscissaPoint
-//purpose  : rbv for curvilinear parametrization
-//=======================================================================
-
-GCPnts_AbscissaPoint::GCPnts_AbscissaPoint
-                                  (const Standard_Real Tol,
-                                  const TheCurve& C,
-                                  const Standard_Real   Abscissa,
-                                  const Standard_Real   U0)
-{
-  Standard_Real L = GCPnts_AbscissaPoint::Length(C, Tol);
-/*  if (L < Precision::Confusion()) {
-    cout<<"FirstParameter = "<<C.FirstParameter()<<endl;
-    cout<<"LastParameter = "<<C.LastParameter()<<endl;
-    Standard_ConstructionError::Raise("GCPnts_AbscissaPoint::GCPnts_AbscissaPoint");
-  } 
-*/
-  Standard_Real Abscis = Abscissa;
-  Standard_Real UU0 = U0;
-  Standard_Real UUi;
-  if (L >= Precision::Confusion()) 
-    UUi= U0 + 
-      (Abscis / L) * (C.LastParameter() - C.FirstParameter());
-  else UUi = U0;
-
-  AdvCompute(myComputer, C, Abscis, UU0, UUi, Tol);  
-}
-
-//=======================================================================
-//function : GCPnts_AbscissaPoint
-//purpose  : 
-//=======================================================================
-
-GCPnts_AbscissaPoint::GCPnts_AbscissaPoint
-                                  (const TheCurve& C,
-                                  const Standard_Real   Abscissa,
-                                  const Standard_Real   U0,
-                                  const Standard_Real   Ui)
-{
-  Standard_Real Abscis = Abscissa;
-  Standard_Real UU0 = U0;
-  Standard_Real UUi = Ui;
-  Compute(myComputer, C, Abscis, UU0, UUi, 
-         C.Resolution(Precision::Confusion()));
-}
-
-//=======================================================================
-//function : GCPnts_AbscissaPoint
-//purpose  : rbv for curvilinear parametrization
-//=======================================================================
-
-GCPnts_AbscissaPoint::GCPnts_AbscissaPoint
-                                  (const TheCurve& C,
-                                  const Standard_Real   Abscissa,
-                                  const Standard_Real   U0,
-                                  const Standard_Real   Ui,
-                                  const Standard_Real   Tol)
-{
-  Standard_Real Abscis = Abscissa;
-  Standard_Real UU0 = U0;
-  Standard_Real UUi = Ui;
-  AdvCompute(myComputer, C, Abscis, UU0, UUi, Tol);
-}
index 7a930ca..6c4498c 100644 (file)
 #ifndef _GCPnts_AbscissaPoint_HeaderFile
 #define _GCPnts_AbscissaPoint_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
 #include <CPnts_AbscissaPoint.hxx>
-#include <Standard_Real.hxx>
-#include <Standard_Boolean.hxx>
+
 class StdFail_NotDone;
 class Standard_ConstructionError;
 class Adaptor3d_Curve;
 class Adaptor2d_Curve2d;
 
-
 //! Provides an algorithm to compute a point on a curve
 //! situated at a given distance from another point on the
 //! curve, the distance being measured along the curve
@@ -127,38 +121,23 @@ public:
   //! IsDone is a protection against:
   //! -   non-convergence of the algorithm
   //! -   querying the results before computation.
-    Standard_Boolean IsDone() const;
+  Standard_Boolean IsDone () const
+  {
+    return myComputer.IsDone ();
+  }
   
   //! Returns the parameter on the curve of the point
   //! solution of this algorithm.
   //! Exceptions
   //! StdFail_NotDone if the computation was not
   //! successful, or was not done.
-    Standard_Real Parameter() const;
-
-
-
-
-protected:
-
-
-
-
+  Standard_Real Parameter () const
+  {
+    return myComputer.Parameter ();
+  }
 
 private:
-
-
-
   CPnts_AbscissaPoint myComputer;
-
-
 };
 
-
-#include <GCPnts_AbscissaPoint.lxx>
-
-
-
-
-
 #endif // _GCPnts_AbscissaPoint_HeaderFile
diff --git a/src/GCPnts/GCPnts_AbscissaPoint.lxx b/src/GCPnts/GCPnts_AbscissaPoint.lxx
deleted file mode 100644 (file)
index d9d9273..0000000
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright (c) 1995-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.
-
-//=======================================================================
-//function : IsDone
-//purpose  : 
-//=======================================================================
-
-inline Standard_Boolean GCPnts_AbscissaPoint::IsDone() const 
-{
-  return myComputer.IsDone();
-}
-
-//=======================================================================
-//function : Parameter
-//purpose  : 
-//=======================================================================
-
-inline Standard_Real GCPnts_AbscissaPoint::Parameter() const
-{
-  return myComputer.Parameter();
-}
-
-
diff --git a/src/GCPnts/GCPnts_AbscissaPoint.pxx b/src/GCPnts/GCPnts_AbscissaPoint.pxx
new file mode 100644 (file)
index 0000000..5cba7bb
--- /dev/null
@@ -0,0 +1,474 @@
+// Created on: 1995-05-05
+// Created by: Modelistation
+// Copyright (c) 1995-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.
+
+// Dimension independant used to implement GCPnts_AbscissaPoint
+
+// compute the type 
+// and the length ratio if GCPnts_LengthParametrized
+#include <GCPnts_AbscissaType.hxx>
+#include <gp_Vec.hxx>
+#include <gp_Vec2d.hxx>
+#include <gp_Circ.hxx>
+#include <gp_Circ2d.hxx>
+#include <Precision.hxx>
+#include <TColStd_Array1OfReal.hxx>
+#include <BSplCLib.hxx>
+
+static GCPnts_AbscissaType computeType( const TheCurve& C,
+                                      Standard_Real& Ratio)
+{
+  GCPnts_AbscissaType LocalType ;
+
+  if (C.NbIntervals(GeomAbs_CN) > 1)
+    return GCPnts_AbsComposite;
+
+  switch (C.GetType()) {
+    
+  case GeomAbs_Line:
+    Ratio = 1.0e0 ;
+    return GCPnts_LengthParametrized;
+
+  case GeomAbs_Circle:
+    Ratio = C.Circle().Radius();
+    return GCPnts_LengthParametrized;
+
+  case GeomAbs_BezierCurve:
+    {
+      Handle_TheBezierCurve Bz = C.Bezier();
+      if ((Bz->NbPoles() == 2) && !(Bz->IsRational())) {
+       Ratio = Bz->DN(0,1).Magnitude();
+       LocalType =  GCPnts_LengthParametrized;
+      }
+      else
+       LocalType = GCPnts_Parametrized;
+      return LocalType ;
+    }
+  case GeomAbs_BSplineCurve:
+    {
+      Handle_TheBSplineCurve Bs = C.BSpline();
+      if ((Bs->NbPoles() == 2) && !(Bs->IsRational())) {
+       Ratio = Bs->DN(Bs->FirstParameter(),1).Magnitude();
+       LocalType = GCPnts_LengthParametrized;
+      }
+      else
+       LocalType = GCPnts_Parametrized;
+      return LocalType ; 
+    }
+    default:
+      return GCPnts_Parametrized;
+    
+  }
+}
+
+// compute a point at distance Abscis from parameter U0
+// using Ui as initial guess
+
+static void Compute(CPnts_AbscissaPoint& theComputer,
+                    const TheCurve& C,
+                    Standard_Real& Abscis,
+                   Standard_Real& U0,
+                   Standard_Real& Ui,
+                   const Standard_Real EPSILON) 
+{
+  // test for easy solution
+  if (Abs(Abscis) <= Precision::Confusion()) {
+    theComputer.SetParameter(U0);
+    return;
+  }
+
+  Standard_Real Ratio = 1.;
+  GCPnts_AbscissaType Type = computeType(C,Ratio);
+
+  switch (Type) {
+  case GCPnts_LengthParametrized : 
+    theComputer.SetParameter(U0 + Abscis / Ratio);
+    return;
+
+  case GCPnts_Parametrized : 
+    theComputer.Init(C);
+    theComputer.Perform(Abscis, U0, Ui, EPSILON);
+    return;
+
+  case GCPnts_AbsComposite : 
+    {
+      Standard_Integer NbIntervals = C.NbIntervals(GeomAbs_CN);
+      TColStd_Array1OfReal TI(1,NbIntervals+1);
+      C.Intervals(TI,GeomAbs_CN);
+      Standard_Real L = 0.0, sign = 1.;
+      Standard_Integer Index = 1;
+      BSplCLib::Hunt(TI,U0,Index);
+      Standard_Integer Direction = 1;
+      if (Abscis < 0) {
+       Direction = 0;
+       Abscis = -Abscis;
+       sign = -1.;
+      }
+
+      while ((Index >= 1) && (Index <= NbIntervals)) {
+
+       L = CPnts_AbscissaPoint::Length(C, U0, TI(Index+Direction));
+       if (Abs(L - Abscis) <= Precision::Confusion()) {
+         theComputer.SetParameter(TI(Index+Direction));
+         return;
+       }
+       if(L > Abscis) {
+         if ((Ui < TI(Index)) || (Ui > TI(Index+1))) {
+           Ui = (Abscis / L) * (TI(Index+1) - U0);
+           if (Direction)
+             Ui = U0 + Ui;
+           else
+             Ui = U0 - Ui;
+         }
+         theComputer.Init(C,TI(Index),TI(Index+1));
+         theComputer.Perform(sign*Abscis, U0, Ui, EPSILON);
+         return;
+       }
+       else {
+         U0 = TI(Index+Direction);
+         Abscis -= L;
+       }
+       if (Direction)
+         Index++;
+       else
+         Index--;
+      }
+
+      // Push a little bit outside the limits (hairy !!!)
+      Ui = U0 + 0.1;
+      theComputer.Init(C,U0,U0+0.2);
+      theComputer.Perform(sign*Abscis, U0, Ui, EPSILON);
+      return;
+    }
+    break;
+  }
+
+}
+
+// introduced by rbv for curvilinear parametrization
+// performs more apropriate tolerance managment
+
+static void AdvCompute(CPnts_AbscissaPoint& theComputer,
+                    const TheCurve& C,
+                    Standard_Real& Abscis,
+                   Standard_Real& U0,
+                   Standard_Real& Ui,
+                   const Standard_Real EPSILON) 
+{
+  Standard_Real Ratio;
+  GCPnts_AbscissaType Type = computeType(C,Ratio);
+
+  switch (Type) {
+  case GCPnts_LengthParametrized : 
+    theComputer.SetParameter(U0 + Abscis / Ratio);
+    return;
+
+  case GCPnts_Parametrized : 
+//    theComputer.Init(C);
+    theComputer.Init(C, EPSILON); //rbv's modification
+//
+    theComputer.AdvPerform(Abscis, U0, Ui, EPSILON);
+    return;
+
+  case GCPnts_AbsComposite : 
+    {
+      Standard_Integer NbIntervals = C.NbIntervals(GeomAbs_CN);
+      TColStd_Array1OfReal TI(1,NbIntervals+1);
+      C.Intervals(TI,GeomAbs_CN);
+      Standard_Real L = 0.0, sign = 1.;
+      Standard_Integer Index = 1;
+      BSplCLib::Hunt(TI,U0,Index);
+       
+      Standard_Integer Direction = 1;
+      if (Abscis < 0) {
+       Direction = 0;
+       Abscis = -Abscis;
+       sign = -1.;
+      }
+
+      if(Index == 0 && Direction > 0) {
+       L = CPnts_AbscissaPoint::Length(C, U0, TI(Index+Direction), EPSILON);
+       if (Abs(L - Abscis) <= /*Precision::Confusion()*/EPSILON) {
+         theComputer.SetParameter(TI(Index+Direction));
+         return;
+       }
+       if(L > Abscis) {
+         if ( Ui > TI(Index+1) ) {
+           Ui = (Abscis / L) * (TI(Index+1) - U0);
+           Ui = U0 + Ui;
+         }
+         theComputer.Init(C,U0,TI(Index+1), EPSILON);
+         theComputer.AdvPerform(sign*Abscis, U0, Ui, EPSILON);
+         return;
+       }
+       else {
+         U0 = TI(Index+Direction);
+         Abscis -= L;
+       }
+       Index++;
+      }
+         
+
+      while ((Index >= 1) && (Index <= NbIntervals)) {
+
+       L = CPnts_AbscissaPoint::Length(C, U0, TI(Index+Direction), EPSILON);
+       if (Abs(L - Abscis) <= Precision::PConfusion()) {
+         theComputer.SetParameter(TI(Index+Direction));
+         return;
+       }
+       if(L > Abscis) {
+         if ((Ui < TI(Index)) || (Ui > TI(Index+1))) {
+           Ui = (Abscis / L) * (TI(Index+1) - U0);
+           if (Direction)
+             Ui = U0 + Ui;
+           else
+             Ui = U0 - Ui;
+         }
+         theComputer.Init(C,TI(Index),TI(Index+1), EPSILON);
+         theComputer.AdvPerform(sign*Abscis, U0, Ui, EPSILON);
+         return;
+       }
+       else {
+         U0 = TI(Index+Direction);
+         Abscis -= L;
+       }
+       if (Direction) {
+         Index++;
+
+       }
+       else {
+         Index--;
+
+       }
+      }
+
+      // Push a little bit outside the limits (hairy !!!)
+
+      Standard_Boolean nonperiodic = !C.IsPeriodic();
+      Ui = U0 + sign*0.1;
+      Standard_Real U1 = U0 + sign*.2;
+      if(nonperiodic) {
+       if(sign > 0) {
+         Ui = Min(Ui,C.LastParameter());
+          U1 = Min(U1, C.LastParameter());
+       }
+       else {
+         Ui = Max(Ui,C.FirstParameter());
+          U1 = Max(U1, C.FirstParameter());
+       }
+      }
+         
+      theComputer.Init(C, U0, U1, EPSILON);
+      theComputer.AdvPerform(sign*Abscis, U0, Ui, EPSILON);
+      return;
+    }
+    break;
+  }
+
+}
+
+//=======================================================================
+//function : Length
+//purpose  : 
+//=======================================================================
+
+Standard_Real GCPnts_AbscissaPoint::Length(const TheCurve& C)
+{
+  return GCPnts_AbscissaPoint::Length(C,C.FirstParameter(), 
+                                     C.LastParameter());
+}
+
+//=======================================================================
+//function : Length
+//purpose  : 
+//=======================================================================
+
+Standard_Real GCPnts_AbscissaPoint::Length(const TheCurve& C,
+                                          const Standard_Real Tol)
+{
+  return GCPnts_AbscissaPoint::Length(C,C.FirstParameter(), 
+                                     C.LastParameter(),Tol);
+}
+
+
+//=======================================================================
+//function : Length
+//purpose  : 
+//=======================================================================
+
+Standard_Real GCPnts_AbscissaPoint::Length(const TheCurve& C,
+                                          const Standard_Real U1,
+                                          const Standard_Real U2)
+{
+  Standard_Real Ratio;
+  GCPnts_AbscissaType Type = computeType(C,Ratio);
+  switch (Type) {
+
+  case GCPnts_LengthParametrized: 
+    return Abs(U2-U1) * Ratio;
+                
+  case GCPnts_Parametrized: 
+    return CPnts_AbscissaPoint::Length(C, U1, U2);
+
+  case GCPnts_AbsComposite: 
+    {
+      Standard_Integer NbIntervals = C.NbIntervals(GeomAbs_CN);
+      TColStd_Array1OfReal TI(1,NbIntervals+1);
+      C.Intervals(TI,GeomAbs_CN);
+      Standard_Real UU1 = Min(U1, U2);
+      Standard_Real UU2 = Max(U1, U2);
+      Standard_Real L = 0.0;
+      for(Standard_Integer Index = 1; Index <= NbIntervals; Index++) {
+       if (TI(Index)   > UU2) break;
+       if (TI(Index+1) < UU1) continue;
+       L += CPnts_AbscissaPoint::Length(C, 
+                                        Max(TI(Index),UU1),
+                                        Min(TI(Index+1),UU2));
+      }
+      return L;
+    }
+  }
+  return RealLast();
+}
+
+//=======================================================================
+//function : Length
+//purpose  : 
+//=======================================================================
+
+Standard_Real GCPnts_AbscissaPoint::Length(const TheCurve& C,
+                                          const Standard_Real U1,
+                                          const Standard_Real U2,
+                                          const Standard_Real Tol)
+{
+  Standard_Real Ratio;
+  GCPnts_AbscissaType Type = computeType(C,Ratio);
+  switch (Type) {
+
+  case GCPnts_LengthParametrized: 
+    return Abs(U2-U1) * Ratio;
+                
+  case GCPnts_Parametrized: 
+    return CPnts_AbscissaPoint::Length(C, U1, U2, Tol);
+
+  case GCPnts_AbsComposite: 
+    {
+      Standard_Integer NbIntervals = C.NbIntervals(GeomAbs_CN);
+      TColStd_Array1OfReal TI(1,NbIntervals+1);
+      C.Intervals(TI,GeomAbs_CN);
+      Standard_Real UU1 = Min(U1, U2);
+      Standard_Real UU2 = Max(U1, U2);
+      Standard_Real L = 0.0;
+      for(Standard_Integer Index = 1; Index <= NbIntervals; Index++) {
+       if (TI(Index)   > UU2) break;
+       if (TI(Index+1) < UU1) continue;
+       L += CPnts_AbscissaPoint::Length(C, 
+                                        Max(TI(Index),UU1),
+                                        Min(TI(Index+1),UU2),
+                                        Tol);
+      }
+      return L;
+    }
+  }
+  return RealLast();
+}
+
+
+//=======================================================================
+//function : GCPnts_AbscissaPoint
+//purpose  : 
+//=======================================================================
+
+GCPnts_AbscissaPoint::GCPnts_AbscissaPoint
+                                  (const TheCurve& C,
+                                  const Standard_Real   Abscissa,
+                                  const Standard_Real   U0)
+{
+  Standard_Real L = GCPnts_AbscissaPoint::Length(C);
+  if (L < Precision::Confusion()) {
+    Standard_ConstructionError::Raise();
+  } 
+  Standard_Real Abscis = Abscissa;
+  Standard_Real UU0 = U0;
+  Standard_Real UUi = U0 + 
+    (Abscis / L) * (C.LastParameter() - C.FirstParameter());
+  Compute(myComputer, C, Abscis, UU0, UUi,
+         C.Resolution(Precision::Confusion()));  
+}
+
+//=======================================================================
+//function : GCPnts_AbscissaPoint
+//purpose  : rbv for curvilinear parametrization
+//=======================================================================
+
+GCPnts_AbscissaPoint::GCPnts_AbscissaPoint
+                                  (const Standard_Real Tol,
+                                  const TheCurve& C,
+                                  const Standard_Real   Abscissa,
+                                  const Standard_Real   U0)
+{
+  Standard_Real L = GCPnts_AbscissaPoint::Length(C, Tol);
+/*  if (L < Precision::Confusion()) {
+    cout<<"FirstParameter = "<<C.FirstParameter()<<endl;
+    cout<<"LastParameter = "<<C.LastParameter()<<endl;
+    Standard_ConstructionError::Raise("GCPnts_AbscissaPoint::GCPnts_AbscissaPoint");
+  } 
+*/
+  Standard_Real Abscis = Abscissa;
+  Standard_Real UU0 = U0;
+  Standard_Real UUi;
+  if (L >= Precision::Confusion()) 
+    UUi= U0 + 
+      (Abscis / L) * (C.LastParameter() - C.FirstParameter());
+  else UUi = U0;
+
+  AdvCompute(myComputer, C, Abscis, UU0, UUi, Tol);  
+}
+
+//=======================================================================
+//function : GCPnts_AbscissaPoint
+//purpose  : 
+//=======================================================================
+
+GCPnts_AbscissaPoint::GCPnts_AbscissaPoint
+                                  (const TheCurve& C,
+                                  const Standard_Real   Abscissa,
+                                  const Standard_Real   U0,
+                                  const Standard_Real   Ui)
+{
+  Standard_Real Abscis = Abscissa;
+  Standard_Real UU0 = U0;
+  Standard_Real UUi = Ui;
+  Compute(myComputer, C, Abscis, UU0, UUi, 
+         C.Resolution(Precision::Confusion()));
+}
+
+//=======================================================================
+//function : GCPnts_AbscissaPoint
+//purpose  : rbv for curvilinear parametrization
+//=======================================================================
+
+GCPnts_AbscissaPoint::GCPnts_AbscissaPoint
+                                  (const TheCurve& C,
+                                  const Standard_Real   Abscissa,
+                                  const Standard_Real   U0,
+                                  const Standard_Real   Ui,
+                                  const Standard_Real   Tol)
+{
+  Standard_Real Abscis = Abscissa;
+  Standard_Real UU0 = U0;
+  Standard_Real UUi = Ui;
+  AdvCompute(myComputer, C, Abscis, UU0, UUi, Tol);
+}
index 4e3b067..3cf02a1 100644 (file)
@@ -53,7 +53,7 @@ GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa ()
 #define TheArray1OfPnt          TColgp_Array1OfPnt
 #define ThePnt                  gp_Pnt
 
-#include <GCPnts_QuasiUniformAbscissa.gxx>
+#include "GCPnts_QuasiUniformAbscissa.pxx"
 
 #undef TheCurve
 #undef Handle_TheBezierCurve
@@ -70,7 +70,7 @@ GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa ()
 #define TheArray1OfPnt          TColgp_Array1OfPnt2d
 #define ThePnt                  gp_Pnt2d
 
-#include <GCPnts_QuasiUniformAbscissa.gxx>
+#include "GCPnts_QuasiUniformAbscissa.pxx"
 
 
 
diff --git a/src/GCPnts/GCPnts_QuasiUniformAbscissa.gxx b/src/GCPnts/GCPnts_QuasiUniformAbscissa.gxx
deleted file mode 100644 (file)
index 9ee0912..0000000
+++ /dev/null
@@ -1,139 +0,0 @@
-// Created on: 1996-08-22
-// Created by: Stagiaire Mary FABIEN
-// 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.
-
-//=======================================================================
-//function : GCPnts_QuasiUniformAbscissa
-//purpose  : 
-//=======================================================================
-
-GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa(const TheCurve& C,
-                                              const Standard_Integer NbPoints)
-{
-  Initialize(C, NbPoints);
-}
-
-//=======================================================================
-//function : GCPnts_QuasiUniformAbscissa
-//purpose  : 
-//=======================================================================
-
-GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa(const TheCurve& C,
-                                              const Standard_Integer NbPoints,
-                                              const Standard_Real U1, 
-                                              const Standard_Real U2)
-{
-  Initialize(C, NbPoints, U1, U2);
-}
-
-//=======================================================================
-//function : Initialize
-//purpose  : 
-//=======================================================================
-
-void GCPnts_QuasiUniformAbscissa::Initialize(const TheCurve& C,
-                                       const Standard_Integer NbPoints)
-{
-  Initialize(C, NbPoints, C.FirstParameter(),
-            C.LastParameter());
-} 
-
-
-//=======================================================================
-//function : Initialize
-//purpose  : This function divides given curve on the several parts with
-//            equal length. It returns array of parameters in the
-//            control points.
-//=======================================================================
-void GCPnts_QuasiUniformAbscissa::Initialize(const TheCurve& C,
-                                            const Standard_Integer NbPoints,
-                                            const Standard_Real U1, 
-                                            const Standard_Real U2)
-{
-  Standard_Integer i;
-  if ((C.GetType() != GeomAbs_BezierCurve) && (C.GetType() != GeomAbs_BSplineCurve))
-    {
-      GCPnts_UniformAbscissa UA(C,NbPoints,U1,U2);
-      myDone = UA.IsDone();
-      myNbPoints = UA.NbPoints();
-      myParams = new TColStd_HArray1OfReal(1,myNbPoints);
-      for( i = 1 ; i <= myNbPoints ; i++ ) 
-       myParams->SetValue(i,UA.Parameter(i));
-#ifdef OCCT_DEBUG
-
-//      char name [100];
-//      for( i = 1 ; i <= NbPoints ; i++ ) {
-//     sprintf(name,"%s_%d","pnt2d",i+(compteur++));
-//     DrawTrSurf::Set(name,C->Value(UA.Parameter(i)));
-//      }
-#endif
-    }
-  else {
-    Standard_ConstructionError_Raise_if(NbPoints <= 1, "");
-    
-// evaluate the approximative length of the 3dCurve
-    myNbPoints = NbPoints;
-    Standard_Real Length = 0.;
-    Standard_Real Dist, dU = (U2 - U1) / ( 2*NbPoints - 1);
-    
-    TColgp_Array1OfPnt2d LP(1,2*NbPoints); // tableau Longueur <-> Param
-    ThePnt P1, P2;
-    P1 = C.Value(U1);
-    
-// On additionne toutes les distances
-    for ( i = 0; i < 2*NbPoints ; i++) {
-      P2      = C.Value(U1 + i*dU);
-      Dist    = P1.Distance(P2);
-      Length += Dist;
-      LP(i+1) = gp_Pnt2d( Length, U1 + (i*dU));
-      P1      = P2;
-    }
-
-// On cherche a mettre NbPoints dans la curve.
-// on met les points environ a Length/NbPoints.
-
-    if(IsEqual(Length, 0.0))
-    {//use usual analytical grid
-      Standard_Real aStep = (U2 - U1) / (NbPoints - 1);
-      myParams = new TColStd_HArray1OfReal(1,NbPoints); 
-      myParams->SetValue(1,U1);
-      for ( i = 2; i < NbPoints; i++)
-      {
-        myParams->SetValue(i, U1 + aStep*(i-1));
-      }
-    }
-    else
-    {
-      Standard_Real DCorde = Length / ( NbPoints - 1); 
-      Standard_Real Corde  = DCorde;
-      Standard_Integer Index = 1;
-      Standard_Real U, Alpha;
-      myParams = new TColStd_HArray1OfReal(1,NbPoints); 
-      myParams->SetValue(1,U1); 
-      for ( i = 2; i < NbPoints; i++)
-      {
-        while ( LP(Index).X() < Corde) Index ++;
-        Alpha = (Corde - LP(Index-1).X()) / (LP(Index).X() - LP(Index-1).X());
-        U = LP(Index-1).Y() + Alpha * ( LP(Index).Y() - LP(Index-1).Y());
-        myParams->SetValue(i,U);
-        Corde = i*DCorde;
-      }
-    }
-
-    myParams->SetValue(NbPoints,U2);
-    myDone = Standard_True;
-  }
-}
-
index 4725842..a9dd598 100644 (file)
 #ifndef _GCPnts_QuasiUniformAbscissa_HeaderFile
 #define _GCPnts_QuasiUniformAbscissa_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-#include <Standard_Integer.hxx>
+#include <StdFail_NotDone.hxx>
 #include <TColStd_HArray1OfReal.hxx>
-#include <Standard_Real.hxx>
+
 class Standard_DomainError;
 class Standard_ConstructionError;
 class Standard_OutOfRange;
@@ -32,7 +27,6 @@ class StdFail_NotDone;
 class Adaptor3d_Curve;
 class Adaptor2d_Curve2d;
 
-
 //! This class provides an algorithm to compute a uniform abscissa
 //! distribution of points on a curve, i.e. a sequence of
 //! equidistant points. The distance between two
@@ -113,8 +107,10 @@ public:
   //! IsDone is a protection against:
   //! -   non-convergence of the algorithm
   //! -   querying the results before computation.
-    Standard_Boolean IsDone() const;
-  
+  Standard_Boolean IsDone () const
+  {
+    return myDone;
+  }
 
   //! Returns the number of points of the distribution
   //! computed by this algorithm.
@@ -128,7 +124,11 @@ public:
   //! Exceptions
   //! StdFail_NotDone if this algorithm has not been
   //! initialized, or if the computation was not successful.
-    Standard_Integer NbPoints() const;
+  Standard_Integer NbPoints () const
+  {
+    StdFail_NotDone_Raise_if (!myDone, "GCPnts_QuasiUniformAbscissa::NbPoints()");
+    return myNbPoints;
+  }
   
   //! Returns the parameter of the point of index Index in
   //! the distribution computed by this algorithm.
@@ -140,33 +140,16 @@ public:
   //! Exceptions
   //! StdFail_NotDone if this algorithm has not been
   //! initialized, or if the computation was not successful.
-    Standard_Real Parameter (const Standard_Integer Index) const;
-
-
-
-
-protected:
-
-
-
-
+  Standard_Real Parameter (const Standard_Integer Index) const
+  {
+    StdFail_NotDone_Raise_if (!myDone, "GCPnts_QuasiUniformAbscissa::Parameter()");
+    return myParams->Value (Index);
+  }
 
 private:
-
-
-
   Standard_Boolean myDone;
   Standard_Integer myNbPoints;
   Handle(TColStd_HArray1OfReal) myParams;
-
-
 };
 
-
-#include <GCPnts_QuasiUniformAbscissa.lxx>
-
-
-
-
-
 #endif // _GCPnts_QuasiUniformAbscissa_HeaderFile
diff --git a/src/GCPnts/GCPnts_QuasiUniformAbscissa.lxx b/src/GCPnts/GCPnts_QuasiUniformAbscissa.lxx
deleted file mode 100644 (file)
index 0201cae..0000000
+++ /dev/null
@@ -1,44 +0,0 @@
-// 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 <StdFail_NotDone.hxx>
-#include <TColStd_HArray1OfReal.hxx>
-
-inline Standard_Boolean GCPnts_QuasiUniformAbscissa::IsDone () const
-{
-  return myDone;
-}
-
-
-inline Standard_Integer GCPnts_QuasiUniformAbscissa::NbPoints () const
-{ 
-  StdFail_NotDone_Raise_if(!myDone, 
-                        "GCPnts_QuasiUniformAbscissa::NbPoints()");
-  return myNbPoints;
-}
-
-
-inline Standard_Real GCPnts_QuasiUniformAbscissa::Parameter
-                      (const Standard_Integer Index) const
-{ 
-  StdFail_NotDone_Raise_if(!myDone, 
-                        "GCPnts_QuasiUniformAbscissa::Parameter()");
-  return myParams->Value(Index) ;
-}
-
-
-
-
-
-
diff --git a/src/GCPnts/GCPnts_QuasiUniformAbscissa.pxx b/src/GCPnts/GCPnts_QuasiUniformAbscissa.pxx
new file mode 100644 (file)
index 0000000..9ee0912
--- /dev/null
@@ -0,0 +1,139 @@
+// Created on: 1996-08-22
+// Created by: Stagiaire Mary FABIEN
+// 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.
+
+//=======================================================================
+//function : GCPnts_QuasiUniformAbscissa
+//purpose  : 
+//=======================================================================
+
+GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa(const TheCurve& C,
+                                              const Standard_Integer NbPoints)
+{
+  Initialize(C, NbPoints);
+}
+
+//=======================================================================
+//function : GCPnts_QuasiUniformAbscissa
+//purpose  : 
+//=======================================================================
+
+GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa(const TheCurve& C,
+                                              const Standard_Integer NbPoints,
+                                              const Standard_Real U1, 
+                                              const Standard_Real U2)
+{
+  Initialize(C, NbPoints, U1, U2);
+}
+
+//=======================================================================
+//function : Initialize
+//purpose  : 
+//=======================================================================
+
+void GCPnts_QuasiUniformAbscissa::Initialize(const TheCurve& C,
+                                       const Standard_Integer NbPoints)
+{
+  Initialize(C, NbPoints, C.FirstParameter(),
+            C.LastParameter());
+} 
+
+
+//=======================================================================
+//function : Initialize
+//purpose  : This function divides given curve on the several parts with
+//            equal length. It returns array of parameters in the
+//            control points.
+//=======================================================================
+void GCPnts_QuasiUniformAbscissa::Initialize(const TheCurve& C,
+                                            const Standard_Integer NbPoints,
+                                            const Standard_Real U1, 
+                                            const Standard_Real U2)
+{
+  Standard_Integer i;
+  if ((C.GetType() != GeomAbs_BezierCurve) && (C.GetType() != GeomAbs_BSplineCurve))
+    {
+      GCPnts_UniformAbscissa UA(C,NbPoints,U1,U2);
+      myDone = UA.IsDone();
+      myNbPoints = UA.NbPoints();
+      myParams = new TColStd_HArray1OfReal(1,myNbPoints);
+      for( i = 1 ; i <= myNbPoints ; i++ ) 
+       myParams->SetValue(i,UA.Parameter(i));
+#ifdef OCCT_DEBUG
+
+//      char name [100];
+//      for( i = 1 ; i <= NbPoints ; i++ ) {
+//     sprintf(name,"%s_%d","pnt2d",i+(compteur++));
+//     DrawTrSurf::Set(name,C->Value(UA.Parameter(i)));
+//      }
+#endif
+    }
+  else {
+    Standard_ConstructionError_Raise_if(NbPoints <= 1, "");
+    
+// evaluate the approximative length of the 3dCurve
+    myNbPoints = NbPoints;
+    Standard_Real Length = 0.;
+    Standard_Real Dist, dU = (U2 - U1) / ( 2*NbPoints - 1);
+    
+    TColgp_Array1OfPnt2d LP(1,2*NbPoints); // tableau Longueur <-> Param
+    ThePnt P1, P2;
+    P1 = C.Value(U1);
+    
+// On additionne toutes les distances
+    for ( i = 0; i < 2*NbPoints ; i++) {
+      P2      = C.Value(U1 + i*dU);
+      Dist    = P1.Distance(P2);
+      Length += Dist;
+      LP(i+1) = gp_Pnt2d( Length, U1 + (i*dU));
+      P1      = P2;
+    }
+
+// On cherche a mettre NbPoints dans la curve.
+// on met les points environ a Length/NbPoints.
+
+    if(IsEqual(Length, 0.0))
+    {//use usual analytical grid
+      Standard_Real aStep = (U2 - U1) / (NbPoints - 1);
+      myParams = new TColStd_HArray1OfReal(1,NbPoints); 
+      myParams->SetValue(1,U1);
+      for ( i = 2; i < NbPoints; i++)
+      {
+        myParams->SetValue(i, U1 + aStep*(i-1));
+      }
+    }
+    else
+    {
+      Standard_Real DCorde = Length / ( NbPoints - 1); 
+      Standard_Real Corde  = DCorde;
+      Standard_Integer Index = 1;
+      Standard_Real U, Alpha;
+      myParams = new TColStd_HArray1OfReal(1,NbPoints); 
+      myParams->SetValue(1,U1); 
+      for ( i = 2; i < NbPoints; i++)
+      {
+        while ( LP(Index).X() < Corde) Index ++;
+        Alpha = (Corde - LP(Index-1).X()) / (LP(Index).X() - LP(Index-1).X());
+        U = LP(Index-1).Y() + Alpha * ( LP(Index).Y() - LP(Index-1).Y());
+        myParams->SetValue(i,U);
+        Corde = i*DCorde;
+      }
+    }
+
+    myParams->SetValue(NbPoints,U2);
+    myDone = Standard_True;
+  }
+}
+
index f0cce03..b4dea42 100644 (file)
@@ -91,7 +91,7 @@ GCPnts_QuasiUniformDeflection::GCPnts_QuasiUniformDeflection ()
 #define Handle_TheBezierCurve   Handle(Geom_BezierCurve)
 #define Handle_TheBSplineCurve  Handle(Geom_BSplineCurve)
 
-#include <GCPnts_QuasiUniformDeflection.gxx>
+#include "GCPnts_QuasiUniformDeflection.pxx"
 
 #undef TheCurve
 #undef Handle_TheBezierCurve
@@ -104,7 +104,7 @@ GCPnts_QuasiUniformDeflection::GCPnts_QuasiUniformDeflection ()
 #define Handle_TheBezierCurve   Handle(Geom2d_BezierCurve)
 #define Handle_TheBSplineCurve  Handle(Geom2d_BSplineCurve)
 
-#include <GCPnts_QuasiUniformDeflection.gxx>
+#include "GCPnts_QuasiUniformDeflection.pxx"
 
 
 
diff --git a/src/GCPnts/GCPnts_QuasiUniformDeflection.gxx b/src/GCPnts/GCPnts_QuasiUniformDeflection.gxx
deleted file mode 100644 (file)
index 59ff8dd..0000000
+++ /dev/null
@@ -1,467 +0,0 @@
-// Copyright (c) 1995-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 <StdFail_NotDone.hxx>
-#include <Standard_DomainError.hxx>
-#include <Standard_OutOfRange.hxx>
-#include <Standard_ConstructionError.hxx>
-#include <Standard_NotImplemented.hxx>
-#include <GCPnts_DeflectionType.hxx>
-#include <TColStd_Array1OfReal.hxx>
-#include <TColStd_SequenceOfReal.hxx>
-#include <BSplCLib.hxx>
-#include <gp_Circ.hxx>
-#include <gp_Circ2d.hxx>
-#include <Precision.hxx>
-
-static void QuasiFleche(const TheCurve&,
-                       const Standard_Real,
-                       const Standard_Real,
-                       const gp_Pnt&,
-                       const gp_Vec&,
-                       const Standard_Real,
-                       const gp_Pnt&,
-                       const gp_Vec&,
-                       const Standard_Integer,
-                       const Standard_Real,
-                       TColStd_SequenceOfReal&,
-                       TColgp_SequenceOfPnt&);
-
-static void QuasiFleche(const TheCurve&,
-                       const Standard_Real,
-                       const Standard_Real,
-                       const gp_Pnt&,
-                       const Standard_Real,
-                       const gp_Pnt&,
-                       const Standard_Integer,
-                       TColStd_SequenceOfReal&,
-                       TColgp_SequenceOfPnt&);
-
-
-//=======================================================================
-//function : PerformLinear
-//purpose  :
-//=======================================================================
-static Standard_Boolean PerformLinear (const TheCurve& C,
-                                       TColStd_SequenceOfReal& Parameters,
-                                       TColgp_SequenceOfPnt& Points,
-                                       const Standard_Real U1,
-                                       const Standard_Real U2)
-{
-  gp_Pnt aPoint;
-  Parameters.Append (U1);
-  aPoint = Value (C, U1);
-  Points.Append (aPoint);
-
-  Parameters.Append (U2);
-  aPoint = Value (C, U2);
-  Points.Append (aPoint);
-  return Standard_True;
-}
-
-
-//=======================================================================
-//function : PerformCircular
-//purpose  :
-//=======================================================================
-static Standard_Boolean PerformCircular (const TheCurve& C,
-                                         TColStd_SequenceOfReal& Parameters,
-                                         TColgp_SequenceOfPnt& Points,
-                                         const Standard_Real Deflection,
-                                         const Standard_Real U1,
-                                         const Standard_Real U2)
-
-{
-  gp_Pnt aPoint;
-  Standard_Real Angle = Max (1.0e0 - (Deflection / C.Circle().Radius()), 0.0e0);
-  Angle = 2.0e0 * ACos (Angle);
-  Standard_Integer NbPoints = (Standard_Integer )((U2 - U1) / Angle);
-  NbPoints += 2;
-  Angle = (U2 - U1) / (Standard_Real) (NbPoints - 1);
-  Standard_Real U = U1;
-  for (Standard_Integer i = 1; i <= NbPoints; ++i)
-  {
-    Parameters.Append (U);
-    aPoint = Value (C,U);
-    Points.Append (aPoint);
-    U += Angle;
-  }
-  return Standard_True;
-}
-
-
-//=======================================================================
-//function : GetDefType
-//purpose  :
-//=======================================================================
-static GCPnts_DeflectionType GetDefType (const TheCurve& C)
-{
-  if (C.NbIntervals(GeomAbs_C1) > 1)
-    return GCPnts_DefComposite;
-  // pour forcer les decoupages aux cassures. G1 devrait marcher,
-  // mais donne des exceptions...
-
-  switch (C.GetType())
-  {
-    case GeomAbs_Line:   return GCPnts_Linear;
-    case GeomAbs_Circle: return GCPnts_Circular;
-    case GeomAbs_BSplineCurve:
-    {
-      Handle_TheBSplineCurve BS = C.BSpline();
-      return (BS->NbPoles() == 2) ? GCPnts_Linear : GCPnts_Curved;
-    }
-    case GeomAbs_BezierCurve:
-    {
-      Handle_TheBezierCurve BZ = C.Bezier();
-      return (BZ->NbPoles() == 2) ? GCPnts_Linear : GCPnts_Curved;
-    }
-    default: return GCPnts_Curved;
-  }
-}
-
-
-//=======================================================================
-//function : PerformCurve
-//purpose  :
-//=======================================================================
-static Standard_Boolean PerformCurve (TColStd_SequenceOfReal& Parameters,
-                                      TColgp_SequenceOfPnt& Points,
-                                      const TheCurve& C,
-                                      const Standard_Real Deflection,
-                                      const Standard_Real U1,
-                                      const Standard_Real U2,
-                                      const Standard_Real EPSILON,
-                                      const GeomAbs_Shape Continuity)
-{
-  Standard_Integer Nbmin = 2;
-
-  gp_Pnt Pdeb;
-  if (Continuity <= GeomAbs_G1)
-  {
-
-    Pdeb = Value (C, U1);
-    Parameters.Append (U1);
-    Points.Append (Pdeb);
-
-    gp_Pnt Pfin (Value (C, U2));
-    QuasiFleche (C, Deflection * Deflection,
-               U1, Pdeb,
-               U2, Pfin,
-               Nbmin,
-               Parameters, Points);
-  }
-  else
-  {
-    gp_Pnt Pfin;
-    gp_Vec Ddeb, Dfin;
-    D1 (C, U1, Pdeb, Ddeb);
-    Parameters.Append (U1);
-    Points.Append (Pdeb);
-
-    D1 (C, U2, Pfin, Dfin);
-    QuasiFleche (C, Deflection * Deflection,
-                 U1, Pdeb,
-                 Ddeb,
-                 U2, Pfin,
-                 Dfin,
-                 Nbmin,
-                 EPSILON * EPSILON,
-                 Parameters, Points);
-  }
-//  cout << "Nb de pts: " << Points.Length()<< endl;
-  return Standard_True;
-}
-
-
-//=======================================================================
-//function : PerformComposite
-//purpose  :
-//=======================================================================
-static Standard_Boolean PerformComposite (TColStd_SequenceOfReal& Parameters,
-                                          TColgp_SequenceOfPnt& Points,
-                                          const TheCurve& C,
-                                          const Standard_Real Deflection,
-                                          const Standard_Real U1,
-                                          const Standard_Real U2,
-                                          const Standard_Real EPSILON,
-                                          const GeomAbs_Shape Continuity)
-{
-//
-//  coherence avec Intervals
-//
-  Standard_Integer NbIntervals = C.NbIntervals (GeomAbs_C2);
-  Standard_Integer PIndex;
-  TColStd_Array1OfReal TI (1, NbIntervals + 1);
-  C.Intervals (TI, GeomAbs_C2);
-  BSplCLib::Hunt (TI, U1, PIndex);
-
-  // iterate by continuous segments
-  Standard_Real Ua = U1;
-  for (Standard_Integer Index = PIndex;;)
-  {
-    Standard_Real Ub = Min (U2, TI (Index + 1));
-    if (!PerformCurve (Parameters, Points, C, Deflection,
-                                  Ua, Ub, EPSILON, Continuity))
-      return Standard_False;
-
-    ++Index;
-    if (Index > NbIntervals || U2 < TI (Index))
-      return Standard_True;
-
-    // remove last point to avoid duplication
-    Parameters.Remove (Parameters.Length());
-    Points.Remove (Points.Length());
-
-    Ua = Ub;
-  }
-}
-
-
-//=======================================================================
-//function : GCPnts_QuasiUniformDeflection
-//purpose  :
-//=======================================================================
-GCPnts_QuasiUniformDeflection::GCPnts_QuasiUniformDeflection
-                               (const TheCurve& C,
-                                const Standard_Real Deflection,
-                                const Standard_Real U1,
-                                const Standard_Real U2,
-                                const GeomAbs_Shape Continuity)
-{
-  Initialize (C, Deflection, U1, U2, Continuity);
-}
-
-
-//=======================================================================
-//function : GCPnts_QuasiUniformDeflection
-//purpose  :
-//=======================================================================
-GCPnts_QuasiUniformDeflection::GCPnts_QuasiUniformDeflection
-                               (const TheCurve& C,
-                                const Standard_Real Deflection,
-                                const GeomAbs_Shape Continuity)
-{
-  Initialize (C, Deflection, Continuity);
-}
-
-
-//=======================================================================
-//function : Initialize
-//purpose  :
-//=======================================================================
-void GCPnts_QuasiUniformDeflection::Initialize (const TheCurve& C,
-                                                const Standard_Real Deflection,
-                                                const GeomAbs_Shape Continuity)
-{
-  Initialize (C, Deflection, C.FirstParameter(),
-              C.LastParameter(), Continuity);
-}
-
-
-//=======================================================================
-//function : Initialize
-//purpose  :
-//=======================================================================
-
-void GCPnts_QuasiUniformDeflection::Initialize
-                     (const TheCurve& C,
-                                     const Standard_Real Deflection,
-                                     const Standard_Real theU1,
-                                     const Standard_Real theU2,
-                                     const GeomAbs_Shape Continuity)
-{
-  myCont = (Continuity > GeomAbs_G1) ? GeomAbs_C1 : GeomAbs_C0;
-  Standard_Real EPSILON = C.Resolution (Precision::Confusion());
-  EPSILON = Min (EPSILON, 1.e50);
-  myDeflection = Deflection;
-  myDone = Standard_False;
-  myParams.Clear();
-  myPoints.Clear();
-  GCPnts_DeflectionType Type = GetDefType (C);
-
-  Standard_Real U1 = Min (theU1, theU2);
-  Standard_Real U2 = Max (theU1, theU2);
-
-  if (Type == GCPnts_Curved || Type == GCPnts_DefComposite)
-  {
-    if (C.GetType() == GeomAbs_BSplineCurve || C.GetType() == GeomAbs_BezierCurve)
-    {
-      Standard_Real maxpar = Max (Abs (C.FirstParameter()), Abs (C.LastParameter()));
-      if (EPSILON < Epsilon (maxpar)) return;
-    }
-  }
-
-  switch (Type)
-  {
-    case GCPnts_Linear:
-      myDone = PerformLinear (C, myParams, myPoints, U1, U2);
-      break;
-    case GCPnts_Circular:
-      myDone = PerformCircular (C, myParams, myPoints, Deflection, U1, U2);
-      break;
-    case GCPnts_Curved:
-      myDone = PerformCurve (myParams, myPoints, C, Deflection,
-                             U1, U2, EPSILON, myCont);
-      break;
-    case GCPnts_DefComposite:
-      myDone = PerformComposite (myParams, myPoints, C, Deflection,
-                                 U1, U2, EPSILON, myCont);
-      break;
-  }
-}
-
-
-//=======================================================================
-//function : QuasiFleche
-//purpose  :
-//=======================================================================
-void QuasiFleche (const TheCurve& C,
-                  const Standard_Real Deflection2,
-                  const Standard_Real Udeb,
-                  const gp_Pnt& Pdeb,
-                  const gp_Vec& Vdeb,
-                  const Standard_Real Ufin,
-                  const gp_Pnt& Pfin,
-                  const gp_Vec& Vfin,
-                  const Standard_Integer Nbmin,
-                  const Standard_Real Eps,
-                  TColStd_SequenceOfReal& Parameters,
-                  TColgp_SequenceOfPnt& Points)
-{
-  Standard_Integer Ptslength = Points.Length();
-  Standard_Real Udelta = Ufin - Udeb;
-  gp_Pnt Pdelta;
-  gp_Vec Vdelta;
-  if (Nbmin > 2)
-  {
-    Udelta /= (Nbmin - 1);
-    D1 (C, Udeb + Udelta, Pdelta, Vdelta);
-  }
-  else
-  {
-    Pdelta = Pfin;
-    Vdelta = Vfin;
-  }
-
-  Standard_Real Norme = gp_Vec (Pdeb, Pdelta).SquareMagnitude();
-  Standard_Real theFleche = 0;
-  Standard_Boolean flecheok = Standard_False;
-  if (Norme > Eps)
-  {
-    // Evaluation de la fleche par interpolation . Voir IntWalk_IWalking_5.gxx
-    Standard_Real N1 = Vdeb.SquareMagnitude();
-    Standard_Real N2 = Vdelta.SquareMagnitude();
-    if (N1 > Eps && N2 > Eps)
-    {
-      Standard_Real Normediff = (Vdeb.Normalized().XYZ() - Vdelta.Normalized().XYZ()).SquareModulus();
-      if (Normediff > Eps)
-      {
-        theFleche = Normediff * Norme / 64.;
-        flecheok = Standard_True;
-      }
-    }
-  }
-  if (!flecheok)
-  {
-    gp_Pnt Pmid ((Pdeb.XYZ() + Pdelta.XYZ()) * 0.5);
-    gp_Pnt Pverif (Value(C, Udeb + Udelta * 0.5));
-    theFleche = Pmid.SquareDistance (Pverif);
-  }
-
-  if (theFleche < Deflection2)
-  {
-    Parameters.Append (Udeb + Udelta);
-    Points.Append (Pdelta);
-  }
-  else
-  {
-    QuasiFleche (C, Deflection2, Udeb, Pdeb,
-                 Vdeb,
-                 Udeb + Udelta, Pdelta,
-                 Vdelta,
-                 3,
-                 Eps,
-                 Parameters, Points);
-  }
-
-  if (Nbmin > 2)
-  {
-    QuasiFleche (C, Deflection2, Udeb + Udelta, Pdelta,
-                 Vdelta,
-                 Ufin, Pfin,
-                 Vfin,
-                 Nbmin - (Points.Length() - Ptslength),
-                 Eps,
-                 Parameters, Points);
-  }
-}
-
-
-//=======================================================================
-//function : QuasiFleche
-//purpose  :
-//=======================================================================
-void QuasiFleche (const TheCurve& C,
-                  const Standard_Real Deflection2,
-                  const Standard_Real Udeb,
-                  const gp_Pnt& Pdeb,
-                  const Standard_Real Ufin,
-                  const gp_Pnt& Pfin,
-                  const Standard_Integer Nbmin,
-                  TColStd_SequenceOfReal& Parameters,
-                  TColgp_SequenceOfPnt& Points)
-{
-  Standard_Integer Ptslength = Points.Length();
-  Standard_Real Udelta = Ufin - Udeb;
-  gp_Pnt Pdelta;
-  if (Nbmin > 2)
-  {
-    Udelta /= (Nbmin-1);
-    Pdelta = Value (C, Udeb + Udelta);
-  }
-  else
-  {
-    Pdelta = Pfin;
-  }
-
-  gp_Pnt Pmid ((Pdeb.XYZ() + Pdelta.XYZ()) * 0.5);
-  gp_Pnt Pverif (Value (C, Udeb + Udelta * 0.5));
-  Standard_Real theFleche = Pmid.SquareDistance (Pverif);
-
-  if (theFleche < Deflection2)
-  {
-    Parameters.Append(Udeb + Udelta);
-    Points.Append (Pdelta);
-  }
-  else
-  {
-    QuasiFleche (C, Deflection2, Udeb, Pdeb,
-                 Udeb + Udelta * 0.5, Pverif,
-                 2,
-                 Parameters, Points);
-
-    QuasiFleche (C, Deflection2, Udeb + Udelta * 0.5, Pverif,
-                 Udeb + Udelta, Pdelta,
-                 2,
-                 Parameters, Points);
-  }
-
-  if (Nbmin > 2)
-  {
-    QuasiFleche (C, Deflection2, Udeb + Udelta, Pdelta,
-                 Ufin, Pfin,
-                 Nbmin - (Points.Length() - Ptslength),
-                 Parameters, Points);
-  }
-}
index c4165e9..c9392c2 100644 (file)
 #ifndef _GCPnts_QuasiUniformDeflection_HeaderFile
 #define _GCPnts_QuasiUniformDeflection_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-#include <Standard_Real.hxx>
+#include <StdFail_NotDone.hxx>
 #include <TColStd_SequenceOfReal.hxx>
 #include <TColgp_SequenceOfPnt.hxx>
 #include <GeomAbs_Shape.hxx>
-#include <Standard_Integer.hxx>
+
 class Standard_DomainError;
 class Standard_ConstructionError;
 class Standard_OutOfRange;
@@ -35,7 +30,6 @@ class Adaptor3d_Curve;
 class Adaptor2d_Curve2d;
 class gp_Pnt;
 
-
 //! This  class computes  a  distribution of  points  on a
 //! curve. The points may respect the deflection. The algorithm
 //! is not based on the  classical prediction (with second
@@ -186,15 +180,21 @@ public:
   //! IsDone is a protection against:
   //! -   non-convergence of the algorithm
   //! -   querying the results before computation.
-    Standard_Boolean IsDone() const;
-  
+  Standard_Boolean IsDone () const
+  {
+    return myDone;
+  }
 
   //! Returns the number of points of the distribution
   //! computed by this algorithm.
   //! Exceptions
   //! StdFail_NotDone if this algorithm has not been
   //! initialized, or if the computation was not successful.
-    Standard_Integer NbPoints() const;
+  Standard_Integer NbPoints () const
+  {
+    StdFail_NotDone_Raise_if (!myDone, "GCPnts_QuasiUniformDeflection::NbPoints()");
+    return myParams.Length ();
+  }
   
   //! Returns the parameter of the point of index Index in
   //! the distribution computed by this algorithm.
@@ -206,7 +206,11 @@ public:
   //! Exceptions
   //! StdFail_NotDone if this algorithm has not been
   //! initialized, or if the computation was not successful.
-    Standard_Real Parameter (const Standard_Integer Index) const;
+  Standard_Real Parameter (const Standard_Integer Index) const
+  {
+    StdFail_NotDone_Raise_if (!myDone, "GCPnts_QuasiUniformDeflection::Parameter()");
+    return myParams (Index);
+  }
   
   //! Returns the point of index Index in the distribution
   //! computed by this algorithm.
@@ -228,35 +232,18 @@ public:
   //! Exceptions
   //! StdFail_NotDone if this algorithm has not been
   //! initialized, or if the computation was not successful.
-    Standard_Real Deflection() const;
-
-
-
-
-protected:
-
-
-
-
+  Standard_Real Deflection () const
+  {
+    StdFail_NotDone_Raise_if (!myDone, "GCPnts_QuasiUniformDeflection::Deflection()");
+    return myDeflection;
+  }
 
 private:
-
-
-
   Standard_Boolean myDone;
   Standard_Real myDeflection;
   TColStd_SequenceOfReal myParams;
   TColgp_SequenceOfPnt myPoints;
   GeomAbs_Shape myCont;
-
-
 };
 
-
-#include <GCPnts_QuasiUniformDeflection.lxx>
-
-
-
-
-
 #endif // _GCPnts_QuasiUniformDeflection_HeaderFile
diff --git a/src/GCPnts/GCPnts_QuasiUniformDeflection.lxx b/src/GCPnts/GCPnts_QuasiUniformDeflection.lxx
deleted file mode 100644 (file)
index 40edcd0..0000000
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright (c) 1995-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 <StdFail_NotDone.hxx>
-
-//=======================================================================
-//function : IsDone
-//purpose  : 
-//=======================================================================
-
-inline Standard_Boolean GCPnts_QuasiUniformDeflection::IsDone () const
-{
-  return myDone;
-}
-
-//=======================================================================
-//function : Deflection
-//purpose  : 
-//=======================================================================
-
-inline Standard_Real GCPnts_QuasiUniformDeflection::Deflection () const
-{ 
-  StdFail_NotDone_Raise_if(!myDone, 
-                        "GCPnts_QuasiUniformDeflection::Deflection()");
-  return myDeflection;
-}
-
-//=======================================================================
-//function : NbPoints
-//purpose  : 
-//=======================================================================
-
-inline Standard_Integer GCPnts_QuasiUniformDeflection::NbPoints () const
-{ 
-  StdFail_NotDone_Raise_if(!myDone, 
-                        "GCPnts_QuasiUniformDeflection::NbPoints()");
-  return myParams.Length();
-}
-
-//=======================================================================
-//function : Parameter
-//purpose  : 
-//=======================================================================
-
-inline Standard_Real GCPnts_QuasiUniformDeflection::Parameter
-                      (const Standard_Integer Index) const
-{ 
-  StdFail_NotDone_Raise_if(!myDone, 
-                             "GCPnts_QuasiUniformDeflection::Parameter()");
-  return myParams(Index);
-}
-
diff --git a/src/GCPnts/GCPnts_QuasiUniformDeflection.pxx b/src/GCPnts/GCPnts_QuasiUniformDeflection.pxx
new file mode 100644 (file)
index 0000000..59ff8dd
--- /dev/null
@@ -0,0 +1,467 @@
+// Copyright (c) 1995-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 <StdFail_NotDone.hxx>
+#include <Standard_DomainError.hxx>
+#include <Standard_OutOfRange.hxx>
+#include <Standard_ConstructionError.hxx>
+#include <Standard_NotImplemented.hxx>
+#include <GCPnts_DeflectionType.hxx>
+#include <TColStd_Array1OfReal.hxx>
+#include <TColStd_SequenceOfReal.hxx>
+#include <BSplCLib.hxx>
+#include <gp_Circ.hxx>
+#include <gp_Circ2d.hxx>
+#include <Precision.hxx>
+
+static void QuasiFleche(const TheCurve&,
+                       const Standard_Real,
+                       const Standard_Real,
+                       const gp_Pnt&,
+                       const gp_Vec&,
+                       const Standard_Real,
+                       const gp_Pnt&,
+                       const gp_Vec&,
+                       const Standard_Integer,
+                       const Standard_Real,
+                       TColStd_SequenceOfReal&,
+                       TColgp_SequenceOfPnt&);
+
+static void QuasiFleche(const TheCurve&,
+                       const Standard_Real,
+                       const Standard_Real,
+                       const gp_Pnt&,
+                       const Standard_Real,
+                       const gp_Pnt&,
+                       const Standard_Integer,
+                       TColStd_SequenceOfReal&,
+                       TColgp_SequenceOfPnt&);
+
+
+//=======================================================================
+//function : PerformLinear
+//purpose  :
+//=======================================================================
+static Standard_Boolean PerformLinear (const TheCurve& C,
+                                       TColStd_SequenceOfReal& Parameters,
+                                       TColgp_SequenceOfPnt& Points,
+                                       const Standard_Real U1,
+                                       const Standard_Real U2)
+{
+  gp_Pnt aPoint;
+  Parameters.Append (U1);
+  aPoint = Value (C, U1);
+  Points.Append (aPoint);
+
+  Parameters.Append (U2);
+  aPoint = Value (C, U2);
+  Points.Append (aPoint);
+  return Standard_True;
+}
+
+
+//=======================================================================
+//function : PerformCircular
+//purpose  :
+//=======================================================================
+static Standard_Boolean PerformCircular (const TheCurve& C,
+                                         TColStd_SequenceOfReal& Parameters,
+                                         TColgp_SequenceOfPnt& Points,
+                                         const Standard_Real Deflection,
+                                         const Standard_Real U1,
+                                         const Standard_Real U2)
+
+{
+  gp_Pnt aPoint;
+  Standard_Real Angle = Max (1.0e0 - (Deflection / C.Circle().Radius()), 0.0e0);
+  Angle = 2.0e0 * ACos (Angle);
+  Standard_Integer NbPoints = (Standard_Integer )((U2 - U1) / Angle);
+  NbPoints += 2;
+  Angle = (U2 - U1) / (Standard_Real) (NbPoints - 1);
+  Standard_Real U = U1;
+  for (Standard_Integer i = 1; i <= NbPoints; ++i)
+  {
+    Parameters.Append (U);
+    aPoint = Value (C,U);
+    Points.Append (aPoint);
+    U += Angle;
+  }
+  return Standard_True;
+}
+
+
+//=======================================================================
+//function : GetDefType
+//purpose  :
+//=======================================================================
+static GCPnts_DeflectionType GetDefType (const TheCurve& C)
+{
+  if (C.NbIntervals(GeomAbs_C1) > 1)
+    return GCPnts_DefComposite;
+  // pour forcer les decoupages aux cassures. G1 devrait marcher,
+  // mais donne des exceptions...
+
+  switch (C.GetType())
+  {
+    case GeomAbs_Line:   return GCPnts_Linear;
+    case GeomAbs_Circle: return GCPnts_Circular;
+    case GeomAbs_BSplineCurve:
+    {
+      Handle_TheBSplineCurve BS = C.BSpline();
+      return (BS->NbPoles() == 2) ? GCPnts_Linear : GCPnts_Curved;
+    }
+    case GeomAbs_BezierCurve:
+    {
+      Handle_TheBezierCurve BZ = C.Bezier();
+      return (BZ->NbPoles() == 2) ? GCPnts_Linear : GCPnts_Curved;
+    }
+    default: return GCPnts_Curved;
+  }
+}
+
+
+//=======================================================================
+//function : PerformCurve
+//purpose  :
+//=======================================================================
+static Standard_Boolean PerformCurve (TColStd_SequenceOfReal& Parameters,
+                                      TColgp_SequenceOfPnt& Points,
+                                      const TheCurve& C,
+                                      const Standard_Real Deflection,
+                                      const Standard_Real U1,
+                                      const Standard_Real U2,
+                                      const Standard_Real EPSILON,
+                                      const GeomAbs_Shape Continuity)
+{
+  Standard_Integer Nbmin = 2;
+
+  gp_Pnt Pdeb;
+  if (Continuity <= GeomAbs_G1)
+  {
+
+    Pdeb = Value (C, U1);
+    Parameters.Append (U1);
+    Points.Append (Pdeb);
+
+    gp_Pnt Pfin (Value (C, U2));
+    QuasiFleche (C, Deflection * Deflection,
+               U1, Pdeb,
+               U2, Pfin,
+               Nbmin,
+               Parameters, Points);
+  }
+  else
+  {
+    gp_Pnt Pfin;
+    gp_Vec Ddeb, Dfin;
+    D1 (C, U1, Pdeb, Ddeb);
+    Parameters.Append (U1);
+    Points.Append (Pdeb);
+
+    D1 (C, U2, Pfin, Dfin);
+    QuasiFleche (C, Deflection * Deflection,
+                 U1, Pdeb,
+                 Ddeb,
+                 U2, Pfin,
+                 Dfin,
+                 Nbmin,
+                 EPSILON * EPSILON,
+                 Parameters, Points);
+  }
+//  cout << "Nb de pts: " << Points.Length()<< endl;
+  return Standard_True;
+}
+
+
+//=======================================================================
+//function : PerformComposite
+//purpose  :
+//=======================================================================
+static Standard_Boolean PerformComposite (TColStd_SequenceOfReal& Parameters,
+                                          TColgp_SequenceOfPnt& Points,
+                                          const TheCurve& C,
+                                          const Standard_Real Deflection,
+                                          const Standard_Real U1,
+                                          const Standard_Real U2,
+                                          const Standard_Real EPSILON,
+                                          const GeomAbs_Shape Continuity)
+{
+//
+//  coherence avec Intervals
+//
+  Standard_Integer NbIntervals = C.NbIntervals (GeomAbs_C2);
+  Standard_Integer PIndex;
+  TColStd_Array1OfReal TI (1, NbIntervals + 1);
+  C.Intervals (TI, GeomAbs_C2);
+  BSplCLib::Hunt (TI, U1, PIndex);
+
+  // iterate by continuous segments
+  Standard_Real Ua = U1;
+  for (Standard_Integer Index = PIndex;;)
+  {
+    Standard_Real Ub = Min (U2, TI (Index + 1));
+    if (!PerformCurve (Parameters, Points, C, Deflection,
+                                  Ua, Ub, EPSILON, Continuity))
+      return Standard_False;
+
+    ++Index;
+    if (Index > NbIntervals || U2 < TI (Index))
+      return Standard_True;
+
+    // remove last point to avoid duplication
+    Parameters.Remove (Parameters.Length());
+    Points.Remove (Points.Length());
+
+    Ua = Ub;
+  }
+}
+
+
+//=======================================================================
+//function : GCPnts_QuasiUniformDeflection
+//purpose  :
+//=======================================================================
+GCPnts_QuasiUniformDeflection::GCPnts_QuasiUniformDeflection
+                               (const TheCurve& C,
+                                const Standard_Real Deflection,
+                                const Standard_Real U1,
+                                const Standard_Real U2,
+                                const GeomAbs_Shape Continuity)
+{
+  Initialize (C, Deflection, U1, U2, Continuity);
+}
+
+
+//=======================================================================
+//function : GCPnts_QuasiUniformDeflection
+//purpose  :
+//=======================================================================
+GCPnts_QuasiUniformDeflection::GCPnts_QuasiUniformDeflection
+                               (const TheCurve& C,
+                                const Standard_Real Deflection,
+                                const GeomAbs_Shape Continuity)
+{
+  Initialize (C, Deflection, Continuity);
+}
+
+
+//=======================================================================
+//function : Initialize
+//purpose  :
+//=======================================================================
+void GCPnts_QuasiUniformDeflection::Initialize (const TheCurve& C,
+                                                const Standard_Real Deflection,
+                                                const GeomAbs_Shape Continuity)
+{
+  Initialize (C, Deflection, C.FirstParameter(),
+              C.LastParameter(), Continuity);
+}
+
+
+//=======================================================================
+//function : Initialize
+//purpose  :
+//=======================================================================
+
+void GCPnts_QuasiUniformDeflection::Initialize
+                     (const TheCurve& C,
+                                     const Standard_Real Deflection,
+                                     const Standard_Real theU1,
+                                     const Standard_Real theU2,
+                                     const GeomAbs_Shape Continuity)
+{
+  myCont = (Continuity > GeomAbs_G1) ? GeomAbs_C1 : GeomAbs_C0;
+  Standard_Real EPSILON = C.Resolution (Precision::Confusion());
+  EPSILON = Min (EPSILON, 1.e50);
+  myDeflection = Deflection;
+  myDone = Standard_False;
+  myParams.Clear();
+  myPoints.Clear();
+  GCPnts_DeflectionType Type = GetDefType (C);
+
+  Standard_Real U1 = Min (theU1, theU2);
+  Standard_Real U2 = Max (theU1, theU2);
+
+  if (Type == GCPnts_Curved || Type == GCPnts_DefComposite)
+  {
+    if (C.GetType() == GeomAbs_BSplineCurve || C.GetType() == GeomAbs_BezierCurve)
+    {
+      Standard_Real maxpar = Max (Abs (C.FirstParameter()), Abs (C.LastParameter()));
+      if (EPSILON < Epsilon (maxpar)) return;
+    }
+  }
+
+  switch (Type)
+  {
+    case GCPnts_Linear:
+      myDone = PerformLinear (C, myParams, myPoints, U1, U2);
+      break;
+    case GCPnts_Circular:
+      myDone = PerformCircular (C, myParams, myPoints, Deflection, U1, U2);
+      break;
+    case GCPnts_Curved:
+      myDone = PerformCurve (myParams, myPoints, C, Deflection,
+                             U1, U2, EPSILON, myCont);
+      break;
+    case GCPnts_DefComposite:
+      myDone = PerformComposite (myParams, myPoints, C, Deflection,
+                                 U1, U2, EPSILON, myCont);
+      break;
+  }
+}
+
+
+//=======================================================================
+//function : QuasiFleche
+//purpose  :
+//=======================================================================
+void QuasiFleche (const TheCurve& C,
+                  const Standard_Real Deflection2,
+                  const Standard_Real Udeb,
+                  const gp_Pnt& Pdeb,
+                  const gp_Vec& Vdeb,
+                  const Standard_Real Ufin,
+                  const gp_Pnt& Pfin,
+                  const gp_Vec& Vfin,
+                  const Standard_Integer Nbmin,
+                  const Standard_Real Eps,
+                  TColStd_SequenceOfReal& Parameters,
+                  TColgp_SequenceOfPnt& Points)
+{
+  Standard_Integer Ptslength = Points.Length();
+  Standard_Real Udelta = Ufin - Udeb;
+  gp_Pnt Pdelta;
+  gp_Vec Vdelta;
+  if (Nbmin > 2)
+  {
+    Udelta /= (Nbmin - 1);
+    D1 (C, Udeb + Udelta, Pdelta, Vdelta);
+  }
+  else
+  {
+    Pdelta = Pfin;
+    Vdelta = Vfin;
+  }
+
+  Standard_Real Norme = gp_Vec (Pdeb, Pdelta).SquareMagnitude();
+  Standard_Real theFleche = 0;
+  Standard_Boolean flecheok = Standard_False;
+  if (Norme > Eps)
+  {
+    // Evaluation de la fleche par interpolation . Voir IntWalk_IWalking_5.gxx
+    Standard_Real N1 = Vdeb.SquareMagnitude();
+    Standard_Real N2 = Vdelta.SquareMagnitude();
+    if (N1 > Eps && N2 > Eps)
+    {
+      Standard_Real Normediff = (Vdeb.Normalized().XYZ() - Vdelta.Normalized().XYZ()).SquareModulus();
+      if (Normediff > Eps)
+      {
+        theFleche = Normediff * Norme / 64.;
+        flecheok = Standard_True;
+      }
+    }
+  }
+  if (!flecheok)
+  {
+    gp_Pnt Pmid ((Pdeb.XYZ() + Pdelta.XYZ()) * 0.5);
+    gp_Pnt Pverif (Value(C, Udeb + Udelta * 0.5));
+    theFleche = Pmid.SquareDistance (Pverif);
+  }
+
+  if (theFleche < Deflection2)
+  {
+    Parameters.Append (Udeb + Udelta);
+    Points.Append (Pdelta);
+  }
+  else
+  {
+    QuasiFleche (C, Deflection2, Udeb, Pdeb,
+                 Vdeb,
+                 Udeb + Udelta, Pdelta,
+                 Vdelta,
+                 3,
+                 Eps,
+                 Parameters, Points);
+  }
+
+  if (Nbmin > 2)
+  {
+    QuasiFleche (C, Deflection2, Udeb + Udelta, Pdelta,
+                 Vdelta,
+                 Ufin, Pfin,
+                 Vfin,
+                 Nbmin - (Points.Length() - Ptslength),
+                 Eps,
+                 Parameters, Points);
+  }
+}
+
+
+//=======================================================================
+//function : QuasiFleche
+//purpose  :
+//=======================================================================
+void QuasiFleche (const TheCurve& C,
+                  const Standard_Real Deflection2,
+                  const Standard_Real Udeb,
+                  const gp_Pnt& Pdeb,
+                  const Standard_Real Ufin,
+                  const gp_Pnt& Pfin,
+                  const Standard_Integer Nbmin,
+                  TColStd_SequenceOfReal& Parameters,
+                  TColgp_SequenceOfPnt& Points)
+{
+  Standard_Integer Ptslength = Points.Length();
+  Standard_Real Udelta = Ufin - Udeb;
+  gp_Pnt Pdelta;
+  if (Nbmin > 2)
+  {
+    Udelta /= (Nbmin-1);
+    Pdelta = Value (C, Udeb + Udelta);
+  }
+  else
+  {
+    Pdelta = Pfin;
+  }
+
+  gp_Pnt Pmid ((Pdeb.XYZ() + Pdelta.XYZ()) * 0.5);
+  gp_Pnt Pverif (Value (C, Udeb + Udelta * 0.5));
+  Standard_Real theFleche = Pmid.SquareDistance (Pverif);
+
+  if (theFleche < Deflection2)
+  {
+    Parameters.Append(Udeb + Udelta);
+    Points.Append (Pdelta);
+  }
+  else
+  {
+    QuasiFleche (C, Deflection2, Udeb, Pdeb,
+                 Udeb + Udelta * 0.5, Pverif,
+                 2,
+                 Parameters, Points);
+
+    QuasiFleche (C, Deflection2, Udeb + Udelta * 0.5, Pverif,
+                 Udeb + Udelta, Pdelta,
+                 2,
+                 Parameters, Points);
+  }
+
+  if (Nbmin > 2)
+  {
+    QuasiFleche (C, Deflection2, Udeb + Udelta, Pdelta,
+                 Ufin, Pfin,
+                 Nbmin - (Points.Length() - Ptslength),
+                 Parameters, Points);
+  }
+}
index 6bb89e7..7019e58 100644 (file)
@@ -178,12 +178,13 @@ Standard_Real GCPnts_TangentialDeflection::ArcAngularStep(
 #include <Geom_BSplineCurve.hxx>
 #include <gp_Circ.hxx>
 #include <GCPnts_DistFunction.hxx>
+
 #define TheCurve Adaptor3d_Curve
 #define Handle_TheBezierCurve   Handle(Geom_BezierCurve)
 #define Handle_TheBSplineCurve  Handle(Geom_BSplineCurve)
 #define TheMaxCurvLinDist GCPnts_DistFunction
 #define TheMaxCurvLinDistMV GCPnts_DistFunctionMV
-#include <GCPnts_TangentialDeflection.gxx>
+#include "GCPnts_TangentialDeflection.pxx"
 #undef Handle_TheBezierCurve
 #undef Handle_TheBSplineCurve
 #undef TheCurve
@@ -200,7 +201,7 @@ Standard_Real GCPnts_TangentialDeflection::ArcAngularStep(
 #define Handle_TheBSplineCurve  Handle(Geom2d_BSplineCurve)
 #define TheMaxCurvLinDist GCPnts_DistFunction2d
 #define TheMaxCurvLinDistMV GCPnts_DistFunction2dMV
-#include <GCPnts_TangentialDeflection.gxx>
+#include "GCPnts_TangentialDeflection.pxx"
 #undef Handle_TheBezierCurve
 #undef Handle_TheBSplineCurve
 #undef TheCurve
diff --git a/src/GCPnts/GCPnts_TangentialDeflection.gxx b/src/GCPnts/GCPnts_TangentialDeflection.gxx
deleted file mode 100644 (file)
index 53b652f..0000000
+++ /dev/null
@@ -1,678 +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)Ceiling(aDiff / Du);
-  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();
-  Standard_Integer MinNb= (9*minNbPnts)/10;
-  //if(MinNb<4) MinNb=4;
-
-  //-- if(Nbp <  MinNb) { cout<<"\n*"; } else {  cout<<"\n."; } 
-  while(Nbp < MinNb) { 
-    //-- cout<<" \nGCPnts TangentialDeflection : Ajout de Points ("<<Nbp<<" "<<minNbPnts<<" )"<<endl;
-    for(i=2; i<=Nbp; i++) { 
-      MiddleU = (parameters.Value(i-1)+parameters.Value(i))*0.5;
-      D0 (C, MiddleU, MiddlePoint); 
-      parameters.InsertBefore(i,MiddleU);
-      points.InsertBefore(i,MiddlePoint);
-      Nbp++;
-      i++;
-    }
-  }
-  //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);
-    // 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 splitted 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);
-  //
-}
index e95142d..0e66213 100644 (file)
 #ifndef _GCPnts_TangentialDeflection_HeaderFile
 #define _GCPnts_TangentialDeflection_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Real.hxx>
-#include <Standard_Integer.hxx>
 #include <TColgp_SequenceOfPnt.hxx>
 #include <TColStd_SequenceOfReal.hxx>
-#include <Standard_Boolean.hxx>
 #include <gp_Pnt.hxx>
 #include <gp_Lin.hxx>
 #include <math_Function.hxx>
 #include <math_MultipleVarFunction.hxx>
 #include <Adaptor3d_Curve.hxx>
 #include <Adaptor2d_Curve2d.hxx>
+
 class Standard_ConstructionError;
 class Standard_OutOfRange;
 
@@ -102,26 +96,25 @@ public:
   //! 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_Integer NbPoints() const;
+  Standard_Integer NbPoints () const
+  {
+    return parameters.Length ();
+  }
   
-    Standard_Real Parameter (const Standard_Integer I) const;
+  Standard_Real Parameter (const Standard_Integer I) const
+  {
+    return parameters.Value (I);
+  }
   
-    gp_Pnt Value (const Standard_Integer I) const;
+  gp_Pnt Value (const Standard_Integer I) const
+  {
+    return points.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);
 
-
-
-
-protected:
-
-
-
-
-
 private:
-
   
   Standard_EXPORT void PerformLinear (const Adaptor3d_Curve& C);
   
@@ -145,6 +138,7 @@ private:
   Standard_EXPORT void EstimDefl (const Adaptor2d_Curve2d& C, const Standard_Real U1, const Standard_Real U2, 
                                   Standard_Real& MaxDefl, Standard_Real& UMax);
 
+private:
   Standard_Real angularDeflection;
   Standard_Real curvatureDeflection;
   Standard_Real uTol;
@@ -154,15 +148,6 @@ private:
   Standard_Real firstu;
   TColgp_SequenceOfPnt points;
   TColStd_SequenceOfReal parameters;
-
-
 };
 
-
-#include <GCPnts_TangentialDeflection.lxx>
-
-
-
-
-
 #endif // _GCPnts_TangentialDeflection_HeaderFile
diff --git a/src/GCPnts/GCPnts_TangentialDeflection.lxx b/src/GCPnts/GCPnts_TangentialDeflection.lxx
deleted file mode 100644 (file)
index 6b80516..0000000
+++ /dev/null
@@ -1,36 +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 <gp_Pnt.hxx>
-
-inline Standard_Integer GCPnts_TangentialDeflection::NbPoints () const 
-{
-  return parameters.Length ();
-}
-
-inline Standard_Real GCPnts_TangentialDeflection::Parameter (const Standard_Integer I) const 
-{
-  return parameters.Value (I);
-}
-
-inline gp_Pnt GCPnts_TangentialDeflection::Value (const Standard_Integer I) const 
-{
-  return points.Value (I);
-}
-
-
-
-
diff --git a/src/GCPnts/GCPnts_TangentialDeflection.pxx b/src/GCPnts/GCPnts_TangentialDeflection.pxx
new file mode 100644 (file)
index 0000000..53b652f
--- /dev/null
@@ -0,0 +1,678 @@
+// 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)Ceiling(aDiff / Du);
+  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();
+  Standard_Integer MinNb= (9*minNbPnts)/10;
+  //if(MinNb<4) MinNb=4;
+
+  //-- if(Nbp <  MinNb) { cout<<"\n*"; } else {  cout<<"\n."; } 
+  while(Nbp < MinNb) { 
+    //-- cout<<" \nGCPnts TangentialDeflection : Ajout de Points ("<<Nbp<<" "<<minNbPnts<<" )"<<endl;
+    for(i=2; i<=Nbp; i++) { 
+      MiddleU = (parameters.Value(i-1)+parameters.Value(i))*0.5;
+      D0 (C, MiddleU, MiddlePoint); 
+      parameters.InsertBefore(i,MiddleU);
+      points.InsertBefore(i,MiddlePoint);
+      Nbp++;
+      i++;
+    }
+  }
+  //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);
+    // 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 splitted 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);
+  //
+}
index 05b04fe..75c5075 100644 (file)
@@ -39,7 +39,7 @@ GCPnts_UniformAbscissa::GCPnts_UniformAbscissa ()
 #define Handle_TheBezierCurve   Handle(Geom_BezierCurve)
 #define Handle_TheBSplineCurve  Handle(Geom_BSplineCurve)
 
-#include <GCPnts_UniformAbscissa.gxx>
+#include "GCPnts_UniformAbscissa.pxx"
 
 #undef TheCurve
 #undef Handle_TheBezierCurve
@@ -52,7 +52,7 @@ GCPnts_UniformAbscissa::GCPnts_UniformAbscissa ()
 #define Handle_TheBezierCurve   Handle(Geom2d_BezierCurve)
 #define Handle_TheBSplineCurve  Handle(Geom2d_BSplineCurve)
 
-#include <GCPnts_UniformAbscissa.gxx>
+#include "GCPnts_UniformAbscissa.pxx"
 
 
 
diff --git a/src/GCPnts/GCPnts_UniformAbscissa.gxx b/src/GCPnts/GCPnts_UniformAbscissa.gxx
deleted file mode 100644 (file)
index 095739b..0000000
+++ /dev/null
@@ -1,476 +0,0 @@
-// Copyright (c) 1995-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 <StdFail_NotDone.hxx>
-#include <Standard_DomainError.hxx>
-#include <Standard_OutOfRange.hxx>
-#include <Standard_ConstructionError.hxx>
-#include <GCPnts_AbscissaType.hxx>
-#include <TColStd_HArray1OfReal.hxx>
-#include <TColStd_Array1OfReal.hxx>
-#include <GeomAbs_CurveType.hxx>
-#include <CPnts_AbscissaPoint.hxx>
-#include <GCPnts_AbscissaPoint.hxx>
-#include <Precision.hxx>
-#include <gp_Circ.hxx>
-#include <gp_Circ2d.hxx>
-#include <gp_Vec.hxx>
-#include <gp_Vec2d.hxx>
-
-
-static Standard_Real GetParameterLengthRatio(const TheCurve& C)
-{
-  switch (C.GetType()) {
-    
-  case GeomAbs_Circle :
-    return C.Circle().Radius();
-    
-  case GeomAbs_Line :
-    return 1.;
-    
-  case GeomAbs_BezierCurve : 
-  case GeomAbs_BSplineCurve :
-    {
-      if (!C.IsRational())
-       return C.DN(0., 1).Magnitude();
-      else
-       return RealLast();
-    }
-    
-    default :
-      return RealLast();
-    
-  }
-}
-
-
-static GCPnts_AbscissaType GetAbsType(const TheCurve& C)
-{
-  if (C.NbIntervals(GeomAbs_C1) > 1)
-    return GCPnts_AbsComposite;
-
-  switch (C.GetType()) {
-    
-  case GeomAbs_Line:
-  case GeomAbs_Circle:
-    return GCPnts_LengthParametrized;
-  case GeomAbs_BezierCurve:
-    {
-      Handle_TheBezierCurve  BZ = C.Bezier(); 
-      if (BZ->NbPoles() == 2 && !BZ->IsRational()) 
-       return GCPnts_LengthParametrized;
-      else
-       return GCPnts_Parametrized; 
-    }
-  case GeomAbs_BSplineCurve:
-    {
-      Handle_TheBSplineCurve BS = C.BSpline() ;
-      if (BS->NbPoles() == 2 && !BS->IsRational()) 
-       return GCPnts_LengthParametrized;
-      else
-       return GCPnts_Parametrized; 
-    }
-  default:
-   return GCPnts_Parametrized ;   
-  }
-}
-
-static Standard_Boolean Perform(Handle(TColStd_HArray1OfReal)& HParameters,
-                               const TheCurve& C,
-                               const Standard_Real Abscissa,
-                               const Standard_Real U1,
-                               const Standard_Real U2,
-                               const Standard_Real TotalLength,
-                               Standard_Integer &NbPoints,
-                               const Standard_Real EPSILON) 
-{
-  Standard_Boolean NotDone = Standard_True;
-  Standard_Boolean LocalDone = Standard_True;
-//  Standard_Boolean Forward = Standard_True  ;
-  Standard_Real UU1 = Min(U1, U2), UU2 = Max(U1, U2) ;
-  Standard_Integer Index ;
-//  Standard_Real UCurrent, Delta, Ui;
-  Standard_Real Delta, Ui;
-  NbPoints = 0 ;
-
-// 
-// this initialization avoids the computation of the Length
-// of the curve 
-
-  Delta = (Abscissa/TotalLength) * (UU2 - UU1) ; 
-  Index = 1 ;
-  HParameters->SetValue(Index,UU1)  ;
-  while (NotDone) {
-    Ui = HParameters->Value(Index) + Delta;
-    if (Ui > UU2) {
-      // MSV 21.04.2004: OCC5739 (GCPnts_UniformAbscissa gives incorrect
-      // distribution of points)
-//       if (UU2 - HParameters->Value(Index) > 0.01*Delta) {
-//     Index += 1;
-//       }
-//       HParameters->SetValue(Index, UU2);
-//       NotDone = Standard_False;
-//       break;
-      Ui = UU2;
-    }
-    GCPnts_AbscissaPoint   AbscissaFinder(C,
-                                         Abscissa,
-                                         HParameters->Value(Index),
-                                         Ui,
-                                         EPSILON) ;
-    if (AbscissaFinder.IsDone()) {
-      Index += 1 ;
-      Ui = AbscissaFinder.Parameter();
-      if (Abs(Ui-UU2) <= EPSILON) {
-       HParameters->SetValue(Index, UU2);
-        NotDone = Standard_False;
-      }
-      else if (Ui < UU2) {
-       HParameters->SetValue(Index, Ui);
-      }
-      else {
-       HParameters->SetValue(Index, UU2);
-       NotDone = Standard_False;
-      }
-      NotDone = NotDone && (Index + 1 <= HParameters->Length()) ;
-    }
-    else {
-      
-      LocalDone = Standard_False ;
-      NotDone = Standard_True ;
-      Delta -= Delta/10;
-      if (Delta <= Precision::PConfusion()) break;
-    }
-  }
-  NbPoints = Index ;
-  return (LocalDone) ;
-}
-
-
-static Standard_Boolean 
-PerformLengthParametrized( Handle(TColStd_HArray1OfReal)& HParameters,
-                         const TheCurve& C,
-                         const Standard_Real Abscissa,
-                         const Standard_Real U1,
-                         const Standard_Real U2,
-                         const Standard_Real TotalLength,
-                         Standard_Integer &NbPoints,
-                         const Standard_Real EPSILON) 
-{
-  Standard_Boolean NotDone = Standard_True;
-//  Standard_Boolean LocalDone = Standard_True;
-  Standard_Real UU1 = Min(U1, U2);
-//  Standard_Real UCurrent;
-  Standard_Real Delta, Ui;
-  Standard_Real UU2 = Max(U1, U2);
-  Standard_Integer   Index ;
-
-// Ratio is defined as dl = Ratio * du
-// for a circle of gp Ratio is equal to the radius of the circle.
-// for a line of gp ratio is equal to 1.0
-  Standard_Real Ratio = GetParameterLengthRatio(C);
-
-
-  if (Abscissa < 0.0e0)    {
-    UU2 = Min(U1, U2);
-    UU1 = Max(U1, U2);
-  }
-  Delta = (Abscissa/TotalLength) * (UU2 - UU1) ; 
-  Index = 1 ;
-  NbPoints = 0 ;
-  HParameters->SetValue(Index,UU1) ;  
-  while  (NotDone) {
-    Index += 1 ;
-    Ui = HParameters->Value(Index-1) + Delta;
-    if (Abs(Ui-UU2) <= EPSILON) {
-      HParameters->SetValue(Index, UU2);
-      NotDone = Standard_False;
-    }
-    else if (Ui < UU2) {
-      HParameters->SetValue(Index, Ui);
-    }
-    else {
-      NotDone = Standard_False;
-      if (Abs(HParameters->Value(Index-1) - UU2)*Ratio/Abscissa < 0.1) {
-       HParameters->SetValue(Index-1, UU2);
-       Index -= 1;
-      }
-      else 
-       HParameters->SetValue(Index, UU2);
-    }
-    NotDone = (Index+1  <= HParameters->Length()) && NotDone ;
-  }
-
-  NbPoints = Index ;
-  return Standard_True ;
-}
-
-
-//=======================================================================
-//function : Initialize
-//purpose  : 
-//=======================================================================
-
-void GCPnts_UniformAbscissa::Initialize  (const TheCurve& C,
-                                         const Standard_Real Abscissa, 
-                                         const Standard_Real Tol)
-{
-  Initialize(C, Abscissa, C.FirstParameter(), 
-            C.LastParameter(), Tol);
-} 
-
-//=======================================================================
-//function : GCPnts_UniformAbscissa
-//purpose  : 
-//=======================================================================
-
-GCPnts_UniformAbscissa::GCPnts_UniformAbscissa  (const TheCurve& C,
-                                                const Standard_Real Abscissa,
-                                                const Standard_Real Tol)
-{
-  Initialize(C, Abscissa, Tol);
-} 
-
-//=======================================================================
-//function : GCPnts_UniformAbscissa
-//purpose  : 
-//=======================================================================
-
-GCPnts_UniformAbscissa::GCPnts_UniformAbscissa  (const TheCurve& C,
-                                                const Standard_Real Abscissa, 
-                                                const Standard_Real U1, 
-                                                const Standard_Real U2,
-                                                const Standard_Real Tol)
-{
-  Initialize(C, Abscissa, U1, U2, Tol);
-}
-
-//=======================================================================
-//function : GCPnts_UniformAbscissa
-//purpose  : 
-//=======================================================================
-
-GCPnts_UniformAbscissa::GCPnts_UniformAbscissa(const TheCurve& C,
-                                              const Standard_Integer NbPoints, 
-                                              const Standard_Real Tol)
-{
-  Initialize(C, NbPoints, Tol);
-}
-
-//=======================================================================
-//function : GCPnts_UniformAbscissa
-//purpose  : 
-//=======================================================================
-
-GCPnts_UniformAbscissa::GCPnts_UniformAbscissa(const TheCurve& C,
-                                              const Standard_Integer NbPoints,
-                                              const Standard_Real U1, 
-                                              const Standard_Real U2,
-                                              const Standard_Real Tol)
-{
-  Initialize(C, NbPoints, U1, U2, Tol);
-}
-
-//=======================================================================
-//function : Initialize
-//purpose  : 
-//=======================================================================
-
-void GCPnts_UniformAbscissa::Initialize(const TheCurve& C,
-                                       const Standard_Real Abscissa, 
-                                       const Standard_Real U1,
-                                       const Standard_Real U2,
-                                       const Standard_Real Tol)
-{ 
-  Standard_Real L ;
-  myAbscissa = Abscissa;
-  myNbPoints = 0 ;
-  myDone = Standard_False;
-  Standard_Real EPSILON;
-  
-  if(Tol < Precision::Confusion())
-    EPSILON = C.Resolution(Precision::Confusion());
-  else
-    EPSILON = C.Resolution(Tol);
-  
-  L = GCPnts_AbscissaPoint::Length(C, U1, U2, EPSILON);
-  if (L <= Precision::Confusion()) {
-    return;
-  }
-  Standard_Integer size ;
-
-// 
-//  compute the total Length here so that we can 
-//  guess the number of points instead of letting the
-//  constructor of CPnts_AbscissaPoint do that and loosing
-//  the information
-//
-//
-
-// modified by Igor Motchalov 23/04/2001
-//  size = (Standard_Integer )( (L/Abs(Abscissa)) + 5 );
-  Standard_Real sizeR=L/Abs(Abscissa) + 5; 
-  if (sizeR < IntegerLast()) {
-    size=(Standard_Integer) sizeR; 
-  } else {
-    return; 
-  }
-
-  if (!myParams.IsNull())    {
-    if (myParams->Length() < size)     {
-      myParams.Nullify() ;
-      myParams =  new
-       TColStd_HArray1OfReal(1,size) ;
-    } 
-  }
-  else    {
-    myParams  = new
-      TColStd_HArray1OfReal(1,size) ;
-  }
-
-//  Standard_Real EPSILON = C.Resolution(Precision::Confusion());
-  GCPnts_AbscissaType Type = GetAbsType(C);
-  switch (Type) {
-  case GCPnts_LengthParametrized : 
-    myDone = PerformLengthParametrized(myParams, 
-                                      C, 
-                                      Abscissa, 
-                                      U1, 
-                                      U2, 
-                                      L, 
-                                      myNbPoints, 
-                                      EPSILON);
-    break;
-  case GCPnts_Parametrized: 
-  case GCPnts_AbsComposite: 
-    myDone = Perform(myParams, 
-                    C, 
-                    Abscissa, 
-                    U1, 
-                    U2, 
-                    L, 
-                    myNbPoints, 
-                    EPSILON);
-    break;
-  }
-}
-
-
-//=======================================================================
-//function : Initialize
-//purpose  : 
-//=======================================================================
-
-void GCPnts_UniformAbscissa::Initialize(const TheCurve& C,
-                                       const Standard_Integer NbPoints,
-                                       const Standard_Real Tol)
-{
-  Initialize(C, NbPoints, C.FirstParameter(),
-            C.LastParameter(), Tol);
-} 
-
-
-//=======================================================================
-//function : Initialize
-//purpose  : 
-//=======================================================================
-
-void GCPnts_UniformAbscissa::Initialize(const TheCurve& C,
-                                       const Standard_Integer NbPoints,
-                                       const Standard_Real U1, 
-                                       const Standard_Real U2,
-                                       const Standard_Real Tol)
-{
-  Standard_ConstructionError_Raise_if(NbPoints <= 1, "");
-  Standard_Real Abscissa ;
-  myNbPoints = 0 ;
-  myDone = Standard_False;
-  Standard_Real EPSILON;
-  
-  if(Tol < Precision::Confusion())
-    EPSILON = C.Resolution(Precision::Confusion());
-  else
-    EPSILON = C.Resolution(Tol);
-
-//
-// although very similar to Initialize with Abscissa this avoid
-// the computation of the total length of the curve twice
-//
-  Standard_Real L = GCPnts_AbscissaPoint::Length(C, U1, U2, EPSILON) ;
-
-  if (L <= Precision::Confusion()) {
-    return;
-  }
-
-  Abscissa = 
-  myAbscissa = L / (NbPoints - 1);
-  
-  Standard_Integer size ;
-
-// 
-//  compute the total Length here so that we can 
-//  guess the number of points instead of letting the
-//  constructor of CPnts_AbscissaPoint do that and loosing
-//  the information
-//
-//
-
-  size = NbPoints + 5 ;
-
-
-  if (!myParams.IsNull())    {
-    if (myParams->Length() < size)     {
-      myParams.Nullify() ;
-      myParams =  new
-       TColStd_HArray1OfReal(1,size) ;
-    } 
-  }
-  else    {
-    myParams  = new
-      TColStd_HArray1OfReal(1,size) ;
-  }
-  
-
-  myNbPoints = 0 ;
-  GCPnts_AbscissaType Type = GetAbsType(C);
-  switch (Type) {
-  case GCPnts_LengthParametrized: 
-    myDone = PerformLengthParametrized(myParams, 
-                                      C, 
-                                      Abscissa, 
-                                      U1, 
-                                      U2, 
-                                      L, 
-                                      myNbPoints, 
-                                      EPSILON);
-    break;
-  case GCPnts_Parametrized: 
-  case GCPnts_AbsComposite: 
-    myDone = Perform(myParams, 
-                    C, 
-                    Abscissa, 
-                    U1, 
-                    U2, 
-                    L, 
-                    myNbPoints, 
-                    EPSILON);
-    break;
-  }
-}
-
-
-
-
-
-
index a95ed2c..c3fc7eb 100644 (file)
 #ifndef _GCPnts_UniformAbscissa_HeaderFile
 #define _GCPnts_UniformAbscissa_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-#include <Standard_Integer.hxx>
-#include <Standard_Real.hxx>
+#include <StdFail_NotDone.hxx>
 #include <TColStd_HArray1OfReal.hxx>
+
 class Standard_DomainError;
 class Standard_ConstructionError;
 class Standard_OutOfRange;
@@ -32,7 +27,6 @@ class StdFail_NotDone;
 class Adaptor3d_Curve;
 class Adaptor2d_Curve2d;
 
-
 //! This class allows to compute a uniform distribution of points
 //! on a curve (ie the points will all be equally distant).
 class GCPnts_UniformAbscissa 
@@ -121,43 +115,37 @@ public:
   //! <U2>, <Toler>.
   Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Integer NbPoints, const Standard_Real U1, const Standard_Real U2, const Standard_Real Toler = -1);
   
-    Standard_Boolean IsDone() const;
+  Standard_Boolean IsDone () const
+  {
+    return myDone;
+  }
   
-    Standard_Integer NbPoints() const;
+  Standard_Integer NbPoints () const
+  {
+    StdFail_NotDone_Raise_if (!myDone, "GCPnts_UniformAbscissa::NbPoints()");
+    return myNbPoints;
+  }
   
   //! returns the computed Parameter of index <Index>.
-    Standard_Real Parameter (const Standard_Integer Index) const;
+  Standard_Real Parameter (const Standard_Integer Index) const
+  {
+    StdFail_NotDone_Raise_if (!myDone, "GCPnts_UniformAbscissa::Parameter()");
+    return myParams->Value (Index);
+  }
   
   //! returne the current abscissa
   //! ie the distance between two consecutive points
-    Standard_Real Abscissa() const;
-
-
-
-
-protected:
-
-
-
-
+  Standard_Real Abscissa () const
+  {
+    StdFail_NotDone_Raise_if (!myDone, "GCPnts_UniformAbscissa::Abscissa()");
+    return myAbscissa;
+  }
 
 private:
-
-
-
   Standard_Boolean myDone;
   Standard_Integer myNbPoints;
   Standard_Real myAbscissa;
   Handle(TColStd_HArray1OfReal) myParams;
-
-
 };
 
-
-#include <GCPnts_UniformAbscissa.lxx>
-
-
-
-
-
 #endif // _GCPnts_UniformAbscissa_HeaderFile
diff --git a/src/GCPnts/GCPnts_UniformAbscissa.lxx b/src/GCPnts/GCPnts_UniformAbscissa.lxx
deleted file mode 100644 (file)
index 1137886..0000000
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright (c) 1995-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 <StdFail_NotDone.hxx>
-#include <TColStd_HArray1OfReal.hxx>
-
-inline Standard_Boolean GCPnts_UniformAbscissa::IsDone () const
-{
-  return myDone;
-}
-
-inline Standard_Real GCPnts_UniformAbscissa::Abscissa () const
-{ 
-  StdFail_NotDone_Raise_if(!myDone, 
-                             "GCPnts_UniformAbscissa::Abscissa()");
-  return myAbscissa;
-}
-
-inline Standard_Integer GCPnts_UniformAbscissa::NbPoints () const
-{ 
-  StdFail_NotDone_Raise_if(!myDone, 
-                        "GCPnts_UniformAbscissa::NbPoints()");
-  return myNbPoints;
-}
-
-
-inline Standard_Real GCPnts_UniformAbscissa::Parameter
-                      (const Standard_Integer Index) const
-{ 
-  StdFail_NotDone_Raise_if(!myDone, 
-                        "GCPnts_UniformAbscissa::Parameter()");
-  return myParams->Value(Index) ;
-}
-
-
-
-
-
-
diff --git a/src/GCPnts/GCPnts_UniformAbscissa.pxx b/src/GCPnts/GCPnts_UniformAbscissa.pxx
new file mode 100644 (file)
index 0000000..095739b
--- /dev/null
@@ -0,0 +1,476 @@
+// Copyright (c) 1995-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 <StdFail_NotDone.hxx>
+#include <Standard_DomainError.hxx>
+#include <Standard_OutOfRange.hxx>
+#include <Standard_ConstructionError.hxx>
+#include <GCPnts_AbscissaType.hxx>
+#include <TColStd_HArray1OfReal.hxx>
+#include <TColStd_Array1OfReal.hxx>
+#include <GeomAbs_CurveType.hxx>
+#include <CPnts_AbscissaPoint.hxx>
+#include <GCPnts_AbscissaPoint.hxx>
+#include <Precision.hxx>
+#include <gp_Circ.hxx>
+#include <gp_Circ2d.hxx>
+#include <gp_Vec.hxx>
+#include <gp_Vec2d.hxx>
+
+
+static Standard_Real GetParameterLengthRatio(const TheCurve& C)
+{
+  switch (C.GetType()) {
+    
+  case GeomAbs_Circle :
+    return C.Circle().Radius();
+    
+  case GeomAbs_Line :
+    return 1.;
+    
+  case GeomAbs_BezierCurve : 
+  case GeomAbs_BSplineCurve :
+    {
+      if (!C.IsRational())
+       return C.DN(0., 1).Magnitude();
+      else
+       return RealLast();
+    }
+    
+    default :
+      return RealLast();
+    
+  }
+}
+
+
+static GCPnts_AbscissaType GetAbsType(const TheCurve& C)
+{
+  if (C.NbIntervals(GeomAbs_C1) > 1)
+    return GCPnts_AbsComposite;
+
+  switch (C.GetType()) {
+    
+  case GeomAbs_Line:
+  case GeomAbs_Circle:
+    return GCPnts_LengthParametrized;
+  case GeomAbs_BezierCurve:
+    {
+      Handle_TheBezierCurve  BZ = C.Bezier(); 
+      if (BZ->NbPoles() == 2 && !BZ->IsRational()) 
+       return GCPnts_LengthParametrized;
+      else
+       return GCPnts_Parametrized; 
+    }
+  case GeomAbs_BSplineCurve:
+    {
+      Handle_TheBSplineCurve BS = C.BSpline() ;
+      if (BS->NbPoles() == 2 && !BS->IsRational()) 
+       return GCPnts_LengthParametrized;
+      else
+       return GCPnts_Parametrized; 
+    }
+  default:
+   return GCPnts_Parametrized ;   
+  }
+}
+
+static Standard_Boolean Perform(Handle(TColStd_HArray1OfReal)& HParameters,
+                               const TheCurve& C,
+                               const Standard_Real Abscissa,
+                               const Standard_Real U1,
+                               const Standard_Real U2,
+                               const Standard_Real TotalLength,
+                               Standard_Integer &NbPoints,
+                               const Standard_Real EPSILON) 
+{
+  Standard_Boolean NotDone = Standard_True;
+  Standard_Boolean LocalDone = Standard_True;
+//  Standard_Boolean Forward = Standard_True  ;
+  Standard_Real UU1 = Min(U1, U2), UU2 = Max(U1, U2) ;
+  Standard_Integer Index ;
+//  Standard_Real UCurrent, Delta, Ui;
+  Standard_Real Delta, Ui;
+  NbPoints = 0 ;
+
+// 
+// this initialization avoids the computation of the Length
+// of the curve 
+
+  Delta = (Abscissa/TotalLength) * (UU2 - UU1) ; 
+  Index = 1 ;
+  HParameters->SetValue(Index,UU1)  ;
+  while (NotDone) {
+    Ui = HParameters->Value(Index) + Delta;
+    if (Ui > UU2) {
+      // MSV 21.04.2004: OCC5739 (GCPnts_UniformAbscissa gives incorrect
+      // distribution of points)
+//       if (UU2 - HParameters->Value(Index) > 0.01*Delta) {
+//     Index += 1;
+//       }
+//       HParameters->SetValue(Index, UU2);
+//       NotDone = Standard_False;
+//       break;
+      Ui = UU2;
+    }
+    GCPnts_AbscissaPoint   AbscissaFinder(C,
+                                         Abscissa,
+                                         HParameters->Value(Index),
+                                         Ui,
+                                         EPSILON) ;
+    if (AbscissaFinder.IsDone()) {
+      Index += 1 ;
+      Ui = AbscissaFinder.Parameter();
+      if (Abs(Ui-UU2) <= EPSILON) {
+       HParameters->SetValue(Index, UU2);
+        NotDone = Standard_False;
+      }
+      else if (Ui < UU2) {
+       HParameters->SetValue(Index, Ui);
+      }
+      else {
+       HParameters->SetValue(Index, UU2);
+       NotDone = Standard_False;
+      }
+      NotDone = NotDone && (Index + 1 <= HParameters->Length()) ;
+    }
+    else {
+      
+      LocalDone = Standard_False ;
+      NotDone = Standard_True ;
+      Delta -= Delta/10;
+      if (Delta <= Precision::PConfusion()) break;
+    }
+  }
+  NbPoints = Index ;
+  return (LocalDone) ;
+}
+
+
+static Standard_Boolean 
+PerformLengthParametrized( Handle(TColStd_HArray1OfReal)& HParameters,
+                         const TheCurve& C,
+                         const Standard_Real Abscissa,
+                         const Standard_Real U1,
+                         const Standard_Real U2,
+                         const Standard_Real TotalLength,
+                         Standard_Integer &NbPoints,
+                         const Standard_Real EPSILON) 
+{
+  Standard_Boolean NotDone = Standard_True;
+//  Standard_Boolean LocalDone = Standard_True;
+  Standard_Real UU1 = Min(U1, U2);
+//  Standard_Real UCurrent;
+  Standard_Real Delta, Ui;
+  Standard_Real UU2 = Max(U1, U2);
+  Standard_Integer   Index ;
+
+// Ratio is defined as dl = Ratio * du
+// for a circle of gp Ratio is equal to the radius of the circle.
+// for a line of gp ratio is equal to 1.0
+  Standard_Real Ratio = GetParameterLengthRatio(C);
+
+
+  if (Abscissa < 0.0e0)    {
+    UU2 = Min(U1, U2);
+    UU1 = Max(U1, U2);
+  }
+  Delta = (Abscissa/TotalLength) * (UU2 - UU1) ; 
+  Index = 1 ;
+  NbPoints = 0 ;
+  HParameters->SetValue(Index,UU1) ;  
+  while  (NotDone) {
+    Index += 1 ;
+    Ui = HParameters->Value(Index-1) + Delta;
+    if (Abs(Ui-UU2) <= EPSILON) {
+      HParameters->SetValue(Index, UU2);
+      NotDone = Standard_False;
+    }
+    else if (Ui < UU2) {
+      HParameters->SetValue(Index, Ui);
+    }
+    else {
+      NotDone = Standard_False;
+      if (Abs(HParameters->Value(Index-1) - UU2)*Ratio/Abscissa < 0.1) {
+       HParameters->SetValue(Index-1, UU2);
+       Index -= 1;
+      }
+      else 
+       HParameters->SetValue(Index, UU2);
+    }
+    NotDone = (Index+1  <= HParameters->Length()) && NotDone ;
+  }
+
+  NbPoints = Index ;
+  return Standard_True ;
+}
+
+
+//=======================================================================
+//function : Initialize
+//purpose  : 
+//=======================================================================
+
+void GCPnts_UniformAbscissa::Initialize  (const TheCurve& C,
+                                         const Standard_Real Abscissa, 
+                                         const Standard_Real Tol)
+{
+  Initialize(C, Abscissa, C.FirstParameter(), 
+            C.LastParameter(), Tol);
+} 
+
+//=======================================================================
+//function : GCPnts_UniformAbscissa
+//purpose  : 
+//=======================================================================
+
+GCPnts_UniformAbscissa::GCPnts_UniformAbscissa  (const TheCurve& C,
+                                                const Standard_Real Abscissa,
+                                                const Standard_Real Tol)
+{
+  Initialize(C, Abscissa, Tol);
+} 
+
+//=======================================================================
+//function : GCPnts_UniformAbscissa
+//purpose  : 
+//=======================================================================
+
+GCPnts_UniformAbscissa::GCPnts_UniformAbscissa  (const TheCurve& C,
+                                                const Standard_Real Abscissa, 
+                                                const Standard_Real U1, 
+                                                const Standard_Real U2,
+                                                const Standard_Real Tol)
+{
+  Initialize(C, Abscissa, U1, U2, Tol);
+}
+
+//=======================================================================
+//function : GCPnts_UniformAbscissa
+//purpose  : 
+//=======================================================================
+
+GCPnts_UniformAbscissa::GCPnts_UniformAbscissa(const TheCurve& C,
+                                              const Standard_Integer NbPoints, 
+                                              const Standard_Real Tol)
+{
+  Initialize(C, NbPoints, Tol);
+}
+
+//=======================================================================
+//function : GCPnts_UniformAbscissa
+//purpose  : 
+//=======================================================================
+
+GCPnts_UniformAbscissa::GCPnts_UniformAbscissa(const TheCurve& C,
+                                              const Standard_Integer NbPoints,
+                                              const Standard_Real U1, 
+                                              const Standard_Real U2,
+                                              const Standard_Real Tol)
+{
+  Initialize(C, NbPoints, U1, U2, Tol);
+}
+
+//=======================================================================
+//function : Initialize
+//purpose  : 
+//=======================================================================
+
+void GCPnts_UniformAbscissa::Initialize(const TheCurve& C,
+                                       const Standard_Real Abscissa, 
+                                       const Standard_Real U1,
+                                       const Standard_Real U2,
+                                       const Standard_Real Tol)
+{ 
+  Standard_Real L ;
+  myAbscissa = Abscissa;
+  myNbPoints = 0 ;
+  myDone = Standard_False;
+  Standard_Real EPSILON;
+  
+  if(Tol < Precision::Confusion())
+    EPSILON = C.Resolution(Precision::Confusion());
+  else
+    EPSILON = C.Resolution(Tol);
+  
+  L = GCPnts_AbscissaPoint::Length(C, U1, U2, EPSILON);
+  if (L <= Precision::Confusion()) {
+    return;
+  }
+  Standard_Integer size ;
+
+// 
+//  compute the total Length here so that we can 
+//  guess the number of points instead of letting the
+//  constructor of CPnts_AbscissaPoint do that and loosing
+//  the information
+//
+//
+
+// modified by Igor Motchalov 23/04/2001
+//  size = (Standard_Integer )( (L/Abs(Abscissa)) + 5 );
+  Standard_Real sizeR=L/Abs(Abscissa) + 5; 
+  if (sizeR < IntegerLast()) {
+    size=(Standard_Integer) sizeR; 
+  } else {
+    return; 
+  }
+
+  if (!myParams.IsNull())    {
+    if (myParams->Length() < size)     {
+      myParams.Nullify() ;
+      myParams =  new
+       TColStd_HArray1OfReal(1,size) ;
+    } 
+  }
+  else    {
+    myParams  = new
+      TColStd_HArray1OfReal(1,size) ;
+  }
+
+//  Standard_Real EPSILON = C.Resolution(Precision::Confusion());
+  GCPnts_AbscissaType Type = GetAbsType(C);
+  switch (Type) {
+  case GCPnts_LengthParametrized : 
+    myDone = PerformLengthParametrized(myParams, 
+                                      C, 
+                                      Abscissa, 
+                                      U1, 
+                                      U2, 
+                                      L, 
+                                      myNbPoints, 
+                                      EPSILON);
+    break;
+  case GCPnts_Parametrized: 
+  case GCPnts_AbsComposite: 
+    myDone = Perform(myParams, 
+                    C, 
+                    Abscissa, 
+                    U1, 
+                    U2, 
+                    L, 
+                    myNbPoints, 
+                    EPSILON);
+    break;
+  }
+}
+
+
+//=======================================================================
+//function : Initialize
+//purpose  : 
+//=======================================================================
+
+void GCPnts_UniformAbscissa::Initialize(const TheCurve& C,
+                                       const Standard_Integer NbPoints,
+                                       const Standard_Real Tol)
+{
+  Initialize(C, NbPoints, C.FirstParameter(),
+            C.LastParameter(), Tol);
+} 
+
+
+//=======================================================================
+//function : Initialize
+//purpose  : 
+//=======================================================================
+
+void GCPnts_UniformAbscissa::Initialize(const TheCurve& C,
+                                       const Standard_Integer NbPoints,
+                                       const Standard_Real U1, 
+                                       const Standard_Real U2,
+                                       const Standard_Real Tol)
+{
+  Standard_ConstructionError_Raise_if(NbPoints <= 1, "");
+  Standard_Real Abscissa ;
+  myNbPoints = 0 ;
+  myDone = Standard_False;
+  Standard_Real EPSILON;
+  
+  if(Tol < Precision::Confusion())
+    EPSILON = C.Resolution(Precision::Confusion());
+  else
+    EPSILON = C.Resolution(Tol);
+
+//
+// although very similar to Initialize with Abscissa this avoid
+// the computation of the total length of the curve twice
+//
+  Standard_Real L = GCPnts_AbscissaPoint::Length(C, U1, U2, EPSILON) ;
+
+  if (L <= Precision::Confusion()) {
+    return;
+  }
+
+  Abscissa = 
+  myAbscissa = L / (NbPoints - 1);
+  
+  Standard_Integer size ;
+
+// 
+//  compute the total Length here so that we can 
+//  guess the number of points instead of letting the
+//  constructor of CPnts_AbscissaPoint do that and loosing
+//  the information
+//
+//
+
+  size = NbPoints + 5 ;
+
+
+  if (!myParams.IsNull())    {
+    if (myParams->Length() < size)     {
+      myParams.Nullify() ;
+      myParams =  new
+       TColStd_HArray1OfReal(1,size) ;
+    } 
+  }
+  else    {
+    myParams  = new
+      TColStd_HArray1OfReal(1,size) ;
+  }
+  
+
+  myNbPoints = 0 ;
+  GCPnts_AbscissaType Type = GetAbsType(C);
+  switch (Type) {
+  case GCPnts_LengthParametrized: 
+    myDone = PerformLengthParametrized(myParams, 
+                                      C, 
+                                      Abscissa, 
+                                      U1, 
+                                      U2, 
+                                      L, 
+                                      myNbPoints, 
+                                      EPSILON);
+    break;
+  case GCPnts_Parametrized: 
+  case GCPnts_AbsComposite: 
+    myDone = Perform(myParams, 
+                    C, 
+                    Abscissa, 
+                    U1, 
+                    U2, 
+                    L, 
+                    myNbPoints, 
+                    EPSILON);
+    break;
+  }
+}
+
+
+
+
+
+
index 050823b..c0905ad 100644 (file)
@@ -65,10 +65,11 @@ GCPnts_UniformDeflection::GCPnts_UniformDeflection ()
 
 #include <Geom_BezierCurve.hxx>
 #include <Geom_BSplineCurve.hxx>
+
 #define TheCurve                 Adaptor3d_Curve
 #define Handle_TheBezierCurve   Handle(Geom_BezierCurve)
 #define Handle_TheBSplineCurve  Handle(Geom_BSplineCurve)
-#include <GCPnts_UniformDeflection.gxx>
+#include "GCPnts_UniformDeflection.pxx"
 #undef TheCurve
 #undef Handle_TheBezierCurve
 #undef Handle_TheBSplineCurve
@@ -78,7 +79,7 @@ GCPnts_UniformDeflection::GCPnts_UniformDeflection ()
 #define TheCurve                 Adaptor2d_Curve2d
 #define Handle_TheBezierCurve   Handle(Geom2d_BezierCurve)
 #define Handle_TheBSplineCurve  Handle(Geom2d_BSplineCurve)
-#include <GCPnts_UniformDeflection.gxx>
+#include "GCPnts_UniformDeflection.pxx"
 #undef TheCurve
 #undef Handle_TheBezierCurve
 #undef Handle_TheBSplineCurve
diff --git a/src/GCPnts/GCPnts_UniformDeflection.gxx b/src/GCPnts/GCPnts_UniformDeflection.gxx
deleted file mode 100644 (file)
index ab582b5..0000000
+++ /dev/null
@@ -1,272 +0,0 @@
-// Copyright (c) 1995-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 <StdFail_NotDone.hxx>
-#include <Standard_DomainError.hxx>
-#include <Standard_OutOfRange.hxx>
-#include <Standard_ConstructionError.hxx>
-#include <Standard_NotImplemented.hxx>
-#include <GCPnts_DeflectionType.hxx>
-#include <CPnts_UniformDeflection.hxx>
-#include <TColStd_Array1OfReal.hxx>
-#include <TColStd_SequenceOfReal.hxx>
-#include <BSplCLib.hxx>
-#include <gp_Circ.hxx>
-#include <gp_Circ2d.hxx>
-#include <Precision.hxx>
-
-
-//=======================================================================
-//function : Controle
-//purpose  :
-//=======================================================================
-static void Controle (const TheCurve& C,
-                      TColStd_SequenceOfReal& Parameters,
-                      TColgp_SequenceOfPnt& Points,
-                      const Standard_Real U2)
-{
-  Standard_Integer nbp = Points.Length();
-
-  if (nbp > 2)
-  {
-    Standard_Real Ua = Parameters (nbp - 2);
-    Standard_Real Ub = Parameters (nbp - 1);
-    if (U2 - Ub < 0.33 * (U2 - Ua))
-    {
-      Standard_Real Uc = (U2 + Ua) * 0.5;
-      Parameters (nbp - 1) = Uc;
-      Points (nbp - 1) = Value (C, Uc);
-    }
-  }
-}
-
-
-//=======================================================================
-//function : PerformLinear
-//purpose  :
-//=======================================================================
-static Standard_Boolean PerformLinear (const TheCurve& C,
-                                       TColStd_SequenceOfReal& Parameters,
-                                       TColgp_SequenceOfPnt& Points,
-                                       const Standard_Real U1,
-                                       const Standard_Real U2)
-{
-  gp_Pnt aPoint;
-  Parameters.Append (U1);
-  aPoint = Value (C, U1);
-  Points.Append (aPoint);
-
-  Parameters.Append (U2);
-  aPoint = Value (C, U2);
-  Points.Append (aPoint);
-  return Standard_True;
-}
-
-
-//=======================================================================
-//function : PerformCircular
-//purpose  :
-//=======================================================================
-static Standard_Boolean PerformCircular (const TheCurve& C,
-                                         TColStd_SequenceOfReal& Parameters,
-                                         TColgp_SequenceOfPnt& Points,
-                                         const Standard_Real Deflection,
-                                         const Standard_Real U1,
-                                         const Standard_Real U2)
-{
-  gp_Pnt aPoint;
-  Standard_Real Angle = Max (1.0e0 - (Deflection / C.Circle().Radius()), 0.0e0);
-  Angle = 2.0e0 * ACos (Angle);
-  Standard_Integer NbPoints = (Standard_Integer )((U2 - U1) / Angle);
-  NbPoints += 2;
-  Angle = (U2 - U1) / (Standard_Real) (NbPoints - 1);
-  Standard_Real U = U1;
-  for (Standard_Integer i = 1; i <= NbPoints; ++i)
-  {
-    Parameters.Append (U);
-    aPoint = Value (C, U);
-    Points.Append (aPoint);
-    U += Angle;
-  }
-  return Standard_True;
-}
-
-
-static GCPnts_DeflectionType GetDefType (const TheCurve& C)
-{
-  if (C.NbIntervals (GeomAbs_C2) > 1)
-    return GCPnts_DefComposite;
-
-  switch (C.GetType())
-  {
-    case GeomAbs_Line:   return GCPnts_Linear;
-    case GeomAbs_Circle: return GCPnts_Circular;
-    case GeomAbs_BSplineCurve:
-    {
-      Handle_TheBSplineCurve aBSpline = C.BSpline();
-      return (aBSpline->NbPoles() == 2) ? GCPnts_Linear : GCPnts_Curved;
-    }
-    case GeomAbs_BezierCurve:
-    {
-      Handle_TheBezierCurve aBezier = C.Bezier();
-      return (aBezier->NbPoles() == 2) ? GCPnts_Linear : GCPnts_Curved;
-    }
-    default: return GCPnts_Curved;
-  }
-}
-
-
-//=======================================================================
-//function : PerformCurve
-//purpose  :
-//=======================================================================
-static Standard_Boolean PerformCurve (TColStd_SequenceOfReal& Parameters,
-                                      TColgp_SequenceOfPnt&   Points,
-                                      const TheCurve& C,
-                                      const Standard_Real Deflection,
-                                      const Standard_Real U1,
-                                      const Standard_Real U2,
-                                      const Standard_Real EPSILON,
-                                      const Standard_Boolean WithControl)
-{
-  CPnts_UniformDeflection Iterator (C, Deflection, U1, U2, EPSILON, WithControl);
-  for(; Iterator.More(); Iterator.Next())
-  {
-    Parameters.Append (Iterator.Value());
-    Points.Append (Iterator.Point());
-  }
-  return Iterator.IsAllDone();
-}
-
-
-//=======================================================================
-//function : PerformComposite
-//purpose  :
-//=======================================================================
-static Standard_Boolean PerformComposite (TColStd_SequenceOfReal& Parameters,
-                                          TColgp_SequenceOfPnt& Points,
-                                          const TheCurve& C,
-                                          const Standard_Real Deflection,
-                                          const Standard_Real U1,
-                                          const Standard_Real U2,
-                                          const Standard_Real EPSILON,
-                                          const Standard_Boolean WithControl)
-{
-  Standard_Integer NbIntervals = C.NbIntervals (GeomAbs_C2);
-  Standard_Integer PIndex;
-
-  TColStd_Array1OfReal TI (1, NbIntervals + 1);
-  C.Intervals (TI, GeomAbs_C2);
-  BSplCLib::Hunt (TI, U1, PIndex);
-
-  // iterate by continuous segments
-  Standard_Real Ua = U1;
-  for (Standard_Integer Index = PIndex;;)
-  {
-    Standard_Real Ub = Min (U2, TI (Index + 1));
-    if (!PerformCurve (Parameters, Points, C, Deflection,
-                   Ua, Ub, EPSILON, WithControl))
-    {
-      return Standard_False;
-    }
-    ++Index;
-    if (Index > NbIntervals || U2 < TI (Index))
-      return Standard_True;
-
-    // remove last point to avoid duplication
-    Parameters.Remove (Parameters.Length());
-    Points.Remove (Points.Length());
-
-    Ua = Ub;
-  }
-}
-
-
-//=======================================================================
-//function : GCPnts_UniformDeflection
-//purpose  :
-//=======================================================================
-GCPnts_UniformDeflection::GCPnts_UniformDeflection (const TheCurve& C,
-                                                    const Standard_Real Deflection,
-                                                    const Standard_Real U1,
-                                                    const Standard_Real U2,
-                                                    const Standard_Boolean WithControl)
-{
-  Initialize (C, Deflection, U1, U2, WithControl);
-}
-
-
-//=======================================================================
-//function : GCPnts_UniformDeflection
-//purpose  :
-//=======================================================================
-GCPnts_UniformDeflection::GCPnts_UniformDeflection (const TheCurve& C,
-                                                    const Standard_Real Deflection,
-                                                    const Standard_Boolean WithControl)
-{
-  Initialize(C, Deflection, WithControl);
-}
-
-
-//=======================================================================
-//function : Initialize
-//purpose  :
-//=======================================================================
-void   GCPnts_UniformDeflection::Initialize (const TheCurve& C,
-                                             const Standard_Real Deflection,
-                                             const Standard_Boolean WithControl)
-{
-  Initialize (C, Deflection, C.FirstParameter(), C.LastParameter(), WithControl);
-}
-
-
-//=======================================================================
-//function : Initialize
-//purpose  :
-//=======================================================================
-void GCPnts_UniformDeflection::Initialize (const TheCurve& C,
-                                           const Standard_Real Deflection,
-                                           const Standard_Real theU1,
-                                           const Standard_Real theU2,
-                                           const Standard_Boolean WithControl)
-{
-  Standard_Real EPSILON = C.Resolution (Precision::Confusion());
-  myDeflection = Deflection;
-  myDone = Standard_False;
-  myParams.Clear();
-  myPoints.Clear();
-  Standard_Real U1 = Min (theU1, theU2);
-  Standard_Real U2 = Max (theU1, theU2);
-  GCPnts_DeflectionType Type = GetDefType (C);
-  switch (Type)
-  {
-    case GCPnts_Linear:
-      myDone = PerformLinear (C, myParams, myPoints, U1, U2);
-      break;
-    case GCPnts_Circular:
-      myDone = PerformCircular (C, myParams, myPoints, Deflection, U1, U2);
-      break;
-    case GCPnts_Curved:
-      myDone = PerformCurve (myParams, myPoints, C, Deflection,
-                             U1, U2, EPSILON, WithControl);
-      break;
-    case GCPnts_DefComposite:
-      myDone = PerformComposite (myParams, myPoints, C, Deflection,
-                                 U1, U2, EPSILON, WithControl);
-      break;
-  }
-
-  // controle des derniers points:
-  Controle (C, myParams, myPoints, U2);
-}
index 7cb692d..4cc8c40 100644 (file)
 #ifndef _GCPnts_UniformDeflection_HeaderFile
 #define _GCPnts_UniformDeflection_HeaderFile
 
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-#include <Standard_Real.hxx>
+#include <StdFail_NotDone.hxx>
 #include <TColStd_SequenceOfReal.hxx>
 #include <TColgp_SequenceOfPnt.hxx>
-#include <Standard_Integer.hxx>
+
 class Standard_DomainError;
 class Standard_ConstructionError;
 class Standard_OutOfRange;
@@ -34,7 +29,6 @@ class Adaptor3d_Curve;
 class Adaptor2d_Curve2d;
 class gp_Pnt;
 
-
 //! Provides an algorithm to compute a distribution of
 //! points on a 'C2' continuous curve. The algorithm
 //! respects a criterion of maximum deflection between
@@ -137,14 +131,21 @@ public:
   //! IsDone is a protection against:
   //! -   non-convergence of the algorithm
   //! -   querying the results before computation.
-    Standard_Boolean IsDone() const;
+  Standard_Boolean IsDone () const
+  {
+    return myDone;
+  }
   
   //! Returns the number of points of the distribution
   //! computed by this algorithm.
   //! Exceptions
   //! StdFail_NotDone if this algorithm has not been
   //! initialized, or if the computation was not successful.
-    Standard_Integer NbPoints() const;
+  Standard_Integer NbPoints () const
+  {
+    StdFail_NotDone_Raise_if (!myDone, "GCPnts_UniformDeflection::NbPoints()");
+    return myParams.Length ();
+  }
   
   //! Returns the parameter of the point of index Index in
   //! the distribution computed by this algorithm.
@@ -156,7 +157,11 @@ public:
   //! Exceptions
   //! StdFail_NotDone if this algorithm has not been
   //! initialized, or if the computation was not successful.
-    Standard_Real Parameter (const Standard_Integer Index) const;
+  Standard_Real Parameter (const Standard_Integer Index) const
+  {
+    StdFail_NotDone_Raise_if (!myDone, "GCPnts_UniformDeflection::Parameter()");
+    return myParams (Index);
+  }
   
   //! Returns the point of index Index in the distribution
   //! computed by this algorithm.
@@ -178,34 +183,17 @@ public:
   //! Exceptions
   //! StdFail_NotDone if this algorithm has not been
   //! initialized, or if the computation was not successful.
-    Standard_Real Deflection() const;
-
-
-
-
-protected:
-
-
-
-
+  Standard_Real Deflection () const
+  {
+    StdFail_NotDone_Raise_if (!myDone, "GCPnts_UniformDeflection::Deflection()");
+    return myDeflection;
+  }
 
 private:
-
-
-
   Standard_Boolean myDone;
   Standard_Real myDeflection;
   TColStd_SequenceOfReal myParams;
   TColgp_SequenceOfPnt myPoints;
-
-
 };
 
-
-#include <GCPnts_UniformDeflection.lxx>
-
-
-
-
-
 #endif // _GCPnts_UniformDeflection_HeaderFile
diff --git a/src/GCPnts/GCPnts_UniformDeflection.lxx b/src/GCPnts/GCPnts_UniformDeflection.lxx
deleted file mode 100644 (file)
index aa8fd2b..0000000
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright (c) 1995-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 <StdFail_NotDone.hxx>
-
-//=======================================================================
-//function : IsDone
-//purpose  : 
-//=======================================================================
-
-inline Standard_Boolean GCPnts_UniformDeflection::IsDone () const
-{
-  return myDone;
-}
-
-//=======================================================================
-//function : Deflection
-//purpose  : 
-//=======================================================================
-
-inline Standard_Real GCPnts_UniformDeflection::Deflection () const
-{ 
-  StdFail_NotDone_Raise_if(!myDone, 
-                        "GCPnts_UniformDeflection::Deflection()");
-  return myDeflection;
-}
-
-//=======================================================================
-//function : NbPoints
-//purpose  : 
-//=======================================================================
-
-inline Standard_Integer GCPnts_UniformDeflection::NbPoints () const
-{ 
-  StdFail_NotDone_Raise_if(!myDone, 
-                        "GCPnts_UniformDeflection::NbPoints()");
-  return myParams.Length();
-}
-
-//=======================================================================
-//function : Parameter
-//purpose  : 
-//=======================================================================
-
-inline Standard_Real GCPnts_UniformDeflection::Parameter
-                      (const Standard_Integer Index) const
-{ 
-  StdFail_NotDone_Raise_if(!myDone, 
-                             "GCPnts_UniformDeflection::Parameter()");
-  return myParams(Index);
-}
-
diff --git a/src/GCPnts/GCPnts_UniformDeflection.pxx b/src/GCPnts/GCPnts_UniformDeflection.pxx
new file mode 100644 (file)
index 0000000..ab582b5
--- /dev/null
@@ -0,0 +1,272 @@
+// Copyright (c) 1995-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 <StdFail_NotDone.hxx>
+#include <Standard_DomainError.hxx>
+#include <Standard_OutOfRange.hxx>
+#include <Standard_ConstructionError.hxx>
+#include <Standard_NotImplemented.hxx>
+#include <GCPnts_DeflectionType.hxx>
+#include <CPnts_UniformDeflection.hxx>
+#include <TColStd_Array1OfReal.hxx>
+#include <TColStd_SequenceOfReal.hxx>
+#include <BSplCLib.hxx>
+#include <gp_Circ.hxx>
+#include <gp_Circ2d.hxx>
+#include <Precision.hxx>
+
+
+//=======================================================================
+//function : Controle
+//purpose  :
+//=======================================================================
+static void Controle (const TheCurve& C,
+                      TColStd_SequenceOfReal& Parameters,
+                      TColgp_SequenceOfPnt& Points,
+                      const Standard_Real U2)
+{
+  Standard_Integer nbp = Points.Length();
+
+  if (nbp > 2)
+  {
+    Standard_Real Ua = Parameters (nbp - 2);
+    Standard_Real Ub = Parameters (nbp - 1);
+    if (U2 - Ub < 0.33 * (U2 - Ua))
+    {
+      Standard_Real Uc = (U2 + Ua) * 0.5;
+      Parameters (nbp - 1) = Uc;
+      Points (nbp - 1) = Value (C, Uc);
+    }
+  }
+}
+
+
+//=======================================================================
+//function : PerformLinear
+//purpose  :
+//=======================================================================
+static Standard_Boolean PerformLinear (const TheCurve& C,
+                                       TColStd_SequenceOfReal& Parameters,
+                                       TColgp_SequenceOfPnt& Points,
+                                       const Standard_Real U1,
+                                       const Standard_Real U2)
+{
+  gp_Pnt aPoint;
+  Parameters.Append (U1);
+  aPoint = Value (C, U1);
+  Points.Append (aPoint);
+
+  Parameters.Append (U2);
+  aPoint = Value (C, U2);
+  Points.Append (aPoint);
+  return Standard_True;
+}
+
+
+//=======================================================================
+//function : PerformCircular
+//purpose  :
+//=======================================================================
+static Standard_Boolean PerformCircular (const TheCurve& C,
+                                         TColStd_SequenceOfReal& Parameters,
+                                         TColgp_SequenceOfPnt& Points,
+                                         const Standard_Real Deflection,
+                                         const Standard_Real U1,
+                                         const Standard_Real U2)
+{
+  gp_Pnt aPoint;
+  Standard_Real Angle = Max (1.0e0 - (Deflection / C.Circle().Radius()), 0.0e0);
+  Angle = 2.0e0 * ACos (Angle);
+  Standard_Integer NbPoints = (Standard_Integer )((U2 - U1) / Angle);
+  NbPoints += 2;
+  Angle = (U2 - U1) / (Standard_Real) (NbPoints - 1);
+  Standard_Real U = U1;
+  for (Standard_Integer i = 1; i <= NbPoints; ++i)
+  {
+    Parameters.Append (U);
+    aPoint = Value (C, U);
+    Points.Append (aPoint);
+    U += Angle;
+  }
+  return Standard_True;
+}
+
+
+static GCPnts_DeflectionType GetDefType (const TheCurve& C)
+{
+  if (C.NbIntervals (GeomAbs_C2) > 1)
+    return GCPnts_DefComposite;
+
+  switch (C.GetType())
+  {
+    case GeomAbs_Line:   return GCPnts_Linear;
+    case GeomAbs_Circle: return GCPnts_Circular;
+    case GeomAbs_BSplineCurve:
+    {
+      Handle_TheBSplineCurve aBSpline = C.BSpline();
+      return (aBSpline->NbPoles() == 2) ? GCPnts_Linear : GCPnts_Curved;
+    }
+    case GeomAbs_BezierCurve:
+    {
+      Handle_TheBezierCurve aBezier = C.Bezier();
+      return (aBezier->NbPoles() == 2) ? GCPnts_Linear : GCPnts_Curved;
+    }
+    default: return GCPnts_Curved;
+  }
+}
+
+
+//=======================================================================
+//function : PerformCurve
+//purpose  :
+//=======================================================================
+static Standard_Boolean PerformCurve (TColStd_SequenceOfReal& Parameters,
+                                      TColgp_SequenceOfPnt&   Points,
+                                      const TheCurve& C,
+                                      const Standard_Real Deflection,
+                                      const Standard_Real U1,
+                                      const Standard_Real U2,
+                                      const Standard_Real EPSILON,
+                                      const Standard_Boolean WithControl)
+{
+  CPnts_UniformDeflection Iterator (C, Deflection, U1, U2, EPSILON, WithControl);
+  for(; Iterator.More(); Iterator.Next())
+  {
+    Parameters.Append (Iterator.Value());
+    Points.Append (Iterator.Point());
+  }
+  return Iterator.IsAllDone();
+}
+
+
+//=======================================================================
+//function : PerformComposite
+//purpose  :
+//=======================================================================
+static Standard_Boolean PerformComposite (TColStd_SequenceOfReal& Parameters,
+                                          TColgp_SequenceOfPnt& Points,
+                                          const TheCurve& C,
+                                          const Standard_Real Deflection,
+                                          const Standard_Real U1,
+                                          const Standard_Real U2,
+                                          const Standard_Real EPSILON,
+                                          const Standard_Boolean WithControl)
+{
+  Standard_Integer NbIntervals = C.NbIntervals (GeomAbs_C2);
+  Standard_Integer PIndex;
+
+  TColStd_Array1OfReal TI (1, NbIntervals + 1);
+  C.Intervals (TI, GeomAbs_C2);
+  BSplCLib::Hunt (TI, U1, PIndex);
+
+  // iterate by continuous segments
+  Standard_Real Ua = U1;
+  for (Standard_Integer Index = PIndex;;)
+  {
+    Standard_Real Ub = Min (U2, TI (Index + 1));
+    if (!PerformCurve (Parameters, Points, C, Deflection,
+                   Ua, Ub, EPSILON, WithControl))
+    {
+      return Standard_False;
+    }
+    ++Index;
+    if (Index > NbIntervals || U2 < TI (Index))
+      return Standard_True;
+
+    // remove last point to avoid duplication
+    Parameters.Remove (Parameters.Length());
+    Points.Remove (Points.Length());
+
+    Ua = Ub;
+  }
+}
+
+
+//=======================================================================
+//function : GCPnts_UniformDeflection
+//purpose  :
+//=======================================================================
+GCPnts_UniformDeflection::GCPnts_UniformDeflection (const TheCurve& C,
+                                                    const Standard_Real Deflection,
+                                                    const Standard_Real U1,
+                                                    const Standard_Real U2,
+                                                    const Standard_Boolean WithControl)
+{
+  Initialize (C, Deflection, U1, U2, WithControl);
+}
+
+
+//=======================================================================
+//function : GCPnts_UniformDeflection
+//purpose  :
+//=======================================================================
+GCPnts_UniformDeflection::GCPnts_UniformDeflection (const TheCurve& C,
+                                                    const Standard_Real Deflection,
+                                                    const Standard_Boolean WithControl)
+{
+  Initialize(C, Deflection, WithControl);
+}
+
+
+//=======================================================================
+//function : Initialize
+//purpose  :
+//=======================================================================
+void   GCPnts_UniformDeflection::Initialize (const TheCurve& C,
+                                             const Standard_Real Deflection,
+                                             const Standard_Boolean WithControl)
+{
+  Initialize (C, Deflection, C.FirstParameter(), C.LastParameter(), WithControl);
+}
+
+
+//=======================================================================
+//function : Initialize
+//purpose  :
+//=======================================================================
+void GCPnts_UniformDeflection::Initialize (const TheCurve& C,
+                                           const Standard_Real Deflection,
+                                           const Standard_Real theU1,
+                                           const Standard_Real theU2,
+                                           const Standard_Boolean WithControl)
+{
+  Standard_Real EPSILON = C.Resolution (Precision::Confusion());
+  myDeflection = Deflection;
+  myDone = Standard_False;
+  myParams.Clear();
+  myPoints.Clear();
+  Standard_Real U1 = Min (theU1, theU2);
+  Standard_Real U2 = Max (theU1, theU2);
+  GCPnts_DeflectionType Type = GetDefType (C);
+  switch (Type)
+  {
+    case GCPnts_Linear:
+      myDone = PerformLinear (C, myParams, myPoints, U1, U2);
+      break;
+    case GCPnts_Circular:
+      myDone = PerformCircular (C, myParams, myPoints, Deflection, U1, U2);
+      break;
+    case GCPnts_Curved:
+      myDone = PerformCurve (myParams, myPoints, C, Deflection,
+                             U1, U2, EPSILON, WithControl);
+      break;
+    case GCPnts_DefComposite:
+      myDone = PerformComposite (myParams, myPoints, C, Deflection,
+                                 U1, U2, EPSILON, WithControl);
+      break;
+  }
+
+  // controle des derniers points:
+  Controle (C, myParams, myPoints, U2);
+}