mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-04-03 17:56:21 +03:00
0032294: Coding Rules - merge GCPnts_QuasiUniformAbscissa.pxx into GCPnts_QuasiUniformAbscissa.cxx
This commit is contained in:
kgv
parent
3d42fbc189
commit
de8a63e98e
@ -4,7 +4,6 @@ GCPnts_AbscissaPoint.hxx
|
||||
GCPnts_AbscissaType.hxx
|
||||
GCPnts_DeflectionType.hxx
|
||||
GCPnts_QuasiUniformAbscissa.cxx
|
||||
GCPnts_QuasiUniformAbscissa.pxx
|
||||
GCPnts_QuasiUniformAbscissa.hxx
|
||||
GCPnts_QuasiUniformDeflection.cxx
|
||||
GCPnts_QuasiUniformDeflection.pxx
|
||||
|
||||
@ -12,65 +12,200 @@
|
||||
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||
// commercial license or contractual agreement.
|
||||
|
||||
//#include <GCPnts_QuasiUniformAbscissa.ixx>
|
||||
|
||||
#include <StdFail_NotDone.hxx>
|
||||
#include <Standard_DomainError.hxx>
|
||||
#include <Standard_OutOfRange.hxx>
|
||||
#include <Standard_ConstructionError.hxx>
|
||||
#include <GCPnts_QuasiUniformAbscissa.hxx>
|
||||
|
||||
#include <GCPnts_TCurveTypes.hxx>
|
||||
#include <GCPnts_UniformAbscissa.hxx>
|
||||
#include <Adaptor3d_Curve.hxx>
|
||||
#include <Adaptor2d_Curve2d.hxx>
|
||||
#include <TColgp_Array1OfPnt2d.hxx>
|
||||
#include <gp_Pnt2d.hxx>
|
||||
#include <TColgp_Array1OfPnt.hxx>
|
||||
#include <gp_Pnt.hxx>
|
||||
|
||||
#ifdef OCCT_DEBUG
|
||||
//#include <DrawTrSurf.hxx>
|
||||
|
||||
//static Standard_Integer compteur = 0;
|
||||
#endif
|
||||
#include <gp_Pnt2d.hxx>
|
||||
#include <Standard_ConstructionError.hxx>
|
||||
#include <TColgp_Array1OfPnt2d.hxx>
|
||||
#include <TColgp_Array1OfPnt.hxx>
|
||||
|
||||
//=======================================================================
|
||||
//function : GCPnts_QuasiUniformAbscissa
|
||||
//purpose :
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
|
||||
GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa ()
|
||||
:myDone(Standard_False),
|
||||
myNbPoints(0)
|
||||
GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa()
|
||||
: myDone (Standard_False),
|
||||
myNbPoints (0)
|
||||
{
|
||||
//
|
||||
}
|
||||
|
||||
#include <Geom_BezierCurve.hxx>
|
||||
#include <Geom_BSplineCurve.hxx>
|
||||
//=======================================================================
|
||||
//function : GCPnts_QuasiUniformAbscissa
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa (const Adaptor3d_Curve& theC,
|
||||
const Standard_Integer theNbPoints)
|
||||
: myDone (Standard_False),
|
||||
myNbPoints (0)
|
||||
{
|
||||
Initialize (theC, theNbPoints);
|
||||
}
|
||||
|
||||
#define TheCurve Adaptor3d_Curve
|
||||
#define Handle_TheBezierCurve Handle(Geom_BezierCurve)
|
||||
#define Handle_TheBSplineCurve Handle(Geom_BSplineCurve)
|
||||
#define TheArray1OfPnt TColgp_Array1OfPnt
|
||||
#define ThePnt gp_Pnt
|
||||
//=======================================================================
|
||||
//function : GCPnts_QuasiUniformAbscissa
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa (const Adaptor3d_Curve& theC,
|
||||
const Standard_Integer theNbPoints,
|
||||
const Standard_Real theU1,
|
||||
const Standard_Real theU2)
|
||||
: myDone (Standard_False),
|
||||
myNbPoints (0)
|
||||
{
|
||||
Initialize (theC, theNbPoints, theU1, theU2);
|
||||
}
|
||||
|
||||
#include "GCPnts_QuasiUniformAbscissa.pxx"
|
||||
//=======================================================================
|
||||
//function : GCPnts_QuasiUniformAbscissa
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa (const Adaptor2d_Curve2d& theC,
|
||||
const Standard_Integer theNbPoints)
|
||||
: myDone (Standard_False),
|
||||
myNbPoints (0)
|
||||
{
|
||||
Initialize (theC, theNbPoints);
|
||||
}
|
||||
|
||||
#undef TheCurve
|
||||
#undef Handle_TheBezierCurve
|
||||
#undef Handle_TheBSplineCurve
|
||||
#undef TheArray1OfPnt
|
||||
#undef ThePnt
|
||||
//=======================================================================
|
||||
//function : GCPnts_QuasiUniformAbscissa
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa (const Adaptor2d_Curve2d& theC,
|
||||
const Standard_Integer theNbPoints,
|
||||
const Standard_Real theU1,
|
||||
const Standard_Real theU2)
|
||||
: myDone (Standard_False),
|
||||
myNbPoints (0)
|
||||
{
|
||||
Initialize (theC, theNbPoints, theU1, theU2);
|
||||
}
|
||||
|
||||
#include <Geom2d_BezierCurve.hxx>
|
||||
#include <Geom2d_BSplineCurve.hxx>
|
||||
//=======================================================================
|
||||
//function : Initialize
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
void GCPnts_QuasiUniformAbscissa::Initialize (const Adaptor3d_Curve& theC,
|
||||
const Standard_Integer theNbPoints)
|
||||
{
|
||||
Initialize (theC, theNbPoints, theC.FirstParameter(), theC.LastParameter());
|
||||
}
|
||||
|
||||
#define TheCurve Adaptor2d_Curve2d
|
||||
#define Handle_TheBezierCurve Handle(Geom2d_BezierCurve)
|
||||
#define Handle_TheBSplineCurve Handle(Geom2d_BSplineCurve)
|
||||
#define TheArray1OfPnt TColgp_Array1OfPnt2d
|
||||
#define ThePnt gp_Pnt2d
|
||||
//=======================================================================
|
||||
//function : Initialize
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
void GCPnts_QuasiUniformAbscissa::Initialize (const Adaptor2d_Curve2d& theC,
|
||||
const Standard_Integer theNbPoints)
|
||||
{
|
||||
Initialize (theC, theNbPoints, theC.FirstParameter(), theC.LastParameter());
|
||||
}
|
||||
|
||||
#include "GCPnts_QuasiUniformAbscissa.pxx"
|
||||
//=======================================================================
|
||||
//function : Initialize
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
void GCPnts_QuasiUniformAbscissa::Initialize (const Adaptor3d_Curve& theC,
|
||||
const Standard_Integer theNbPoints,
|
||||
const Standard_Real theU1,
|
||||
const Standard_Real theU2)
|
||||
{
|
||||
initialize (theC, theNbPoints, theU1, theU2);
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : Initialize
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
void GCPnts_QuasiUniformAbscissa::Initialize (const Adaptor2d_Curve2d& theC,
|
||||
const Standard_Integer theNbPoints,
|
||||
const Standard_Real theU1,
|
||||
const Standard_Real theU2)
|
||||
{
|
||||
initialize (theC, theNbPoints, theU1, theU2);
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : initialize
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
template<class TheCurve>
|
||||
void GCPnts_QuasiUniformAbscissa::initialize (const TheCurve& theC,
|
||||
const Standard_Integer theNbPoints,
|
||||
const Standard_Real theU1,
|
||||
const Standard_Real theU2)
|
||||
{
|
||||
if (theC.GetType() != GeomAbs_BezierCurve
|
||||
&& theC.GetType() != GeomAbs_BSplineCurve)
|
||||
{
|
||||
GCPnts_UniformAbscissa aUA (theC, theNbPoints, theU1, theU2);
|
||||
myDone = aUA.IsDone();
|
||||
myNbPoints = aUA.NbPoints();
|
||||
myParams = new TColStd_HArray1OfReal (1, myNbPoints);
|
||||
for (Standard_Integer aPntIter = 1 ; aPntIter <= myNbPoints; ++aPntIter)
|
||||
{
|
||||
myParams->SetValue (aPntIter, aUA.Parameter (aPntIter));
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
Standard_ConstructionError_Raise_if (theNbPoints <= 1, "GCPnts_QuasiUniformAbscissa::Initialize(), number of points should be >= 2");
|
||||
|
||||
// evaluate the approximative length of the 3dCurve
|
||||
myNbPoints = theNbPoints;
|
||||
Standard_Real aLength = 0.0;
|
||||
const Standard_Real dU = (theU2 - theU1) / (2 * theNbPoints - 1);
|
||||
|
||||
TColgp_Array1OfPnt2d aLP (1, 2 * theNbPoints); // table Length <-> Param
|
||||
typename GCPnts_TCurveTypes<TheCurve>::Point aP1, aP2;
|
||||
aP1 = theC.Value (theU1);
|
||||
|
||||
// On additionne toutes les distances
|
||||
for (Standard_Integer i = 0; i < 2 * theNbPoints; ++i)
|
||||
{
|
||||
aP2 = theC.Value (theU1 + i * dU);
|
||||
const Standard_Real aDist = aP1.Distance (aP2);
|
||||
aLength += aDist;
|
||||
aLP(i+1) = gp_Pnt2d (aLength, theU1 + (i * dU));
|
||||
aP1 = aP2;
|
||||
}
|
||||
|
||||
// On cherche a mettre NbPoints dans la curve.
|
||||
// on met les points environ a Length/NbPoints.
|
||||
if (IsEqual (aLength, 0.0))
|
||||
{ //use usual analytical grid
|
||||
Standard_Real aStep = (theU2 - theU1) / (theNbPoints - 1);
|
||||
myParams = new TColStd_HArray1OfReal (1, theNbPoints);
|
||||
myParams->SetValue (1, theU1);
|
||||
for (Standard_Integer i = 2; i < theNbPoints; ++i)
|
||||
{
|
||||
myParams->SetValue (i, theU1 + aStep * (i - 1));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
const Standard_Real aDCorde = aLength / (theNbPoints - 1);
|
||||
Standard_Real aCorde = aDCorde;
|
||||
Standard_Integer anIndex = 1;
|
||||
myParams = new TColStd_HArray1OfReal (1, theNbPoints);
|
||||
myParams->SetValue (1, theU1);
|
||||
for (Standard_Integer i = 2; i < theNbPoints; ++i)
|
||||
{
|
||||
while (aLP (anIndex).X() < aCorde)
|
||||
{
|
||||
++anIndex;
|
||||
}
|
||||
Standard_Real anAlpha = (aCorde - aLP(anIndex - 1).X()) / (aLP (anIndex).X() - aLP (anIndex-1).X());
|
||||
Standard_Real aU = aLP (anIndex - 1).Y() + anAlpha * (aLP (anIndex).Y() - aLP (anIndex-1).Y());
|
||||
myParams->SetValue (i, aU);
|
||||
aCorde = i * aDCorde;
|
||||
}
|
||||
}
|
||||
|
||||
myParams->SetValue (theNbPoints, theU2);
|
||||
myDone = Standard_True;
|
||||
}
|
||||
|
||||
@ -20,89 +20,108 @@
|
||||
#include <StdFail_NotDone.hxx>
|
||||
#include <TColStd_HArray1OfReal.hxx>
|
||||
|
||||
class Standard_DomainError;
|
||||
class Standard_ConstructionError;
|
||||
class Standard_OutOfRange;
|
||||
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
|
||||
//! consecutive points is measured along the curve.
|
||||
//! The distribution is defined:
|
||||
//! - either by the curvilinear distance between two consecutive points
|
||||
//! - or by a number of points.
|
||||
//! distribution of points on a curve, i.e. a sequence of equidistant points.
|
||||
//! The distance between two consecutive points is measured along the curve.
|
||||
//!
|
||||
//! The distribution is defined by a number of points.
|
||||
class GCPnts_QuasiUniformAbscissa
|
||||
{
|
||||
public:
|
||||
|
||||
DEFINE_STANDARD_ALLOC
|
||||
|
||||
|
||||
//! Constructs an empty algorithm. To define the problem
|
||||
//! to be solved, use the function Initialize.
|
||||
//! Constructs an empty algorithm.
|
||||
//! To define the problem to be solved, use the function Initialize.
|
||||
Standard_EXPORT GCPnts_QuasiUniformAbscissa();
|
||||
|
||||
|
||||
//! Computes a uniform abscissa distribution of points
|
||||
//! - on the curve C where Abscissa is the curvilinear distance between
|
||||
//! - on the curve where Abscissa is the curvilinear distance between
|
||||
//! two consecutive points of the distribution.
|
||||
Standard_EXPORT GCPnts_QuasiUniformAbscissa(const Adaptor3d_Curve& C, const Standard_Integer NbPoints);
|
||||
|
||||
Standard_EXPORT GCPnts_QuasiUniformAbscissa (const Adaptor3d_Curve& theC,
|
||||
const Standard_Integer theNbPoints);
|
||||
|
||||
//! Computes a uniform abscissa distribution of points
|
||||
//! on the part of curve C limited by the two parameter values U1 and U2,
|
||||
//! on the part of curve limited by the two parameter values theU1 and theU2,
|
||||
//! where Abscissa is the curvilinear distance between
|
||||
//! two consecutive points of the distribution.
|
||||
//! The first point of the distribution is either the origin of
|
||||
//! curve C or the point of parameter U1. The following
|
||||
//! points are computed such that the curvilinear
|
||||
//! curve or the point of parameter theU1.
|
||||
//! The following points are computed such that the curvilinear
|
||||
//! distance between two consecutive points is equal to Abscissa.
|
||||
//! The last point of the distribution is either the end
|
||||
//! point of curve C or the point of parameter U2.
|
||||
//! point of curve or the point of parameter theU2.
|
||||
//! However the curvilinear distance between this last
|
||||
//! point and the point just preceding it in the distribution
|
||||
//! is, of course, generally not equal to Abscissa.
|
||||
//! Use the function IsDone to verify that the
|
||||
//! computation was successful, the function NbPoints
|
||||
//! to obtain the number of points of the computed
|
||||
//! distribution, and the function Parameter to read the
|
||||
//! parameter of each point.
|
||||
//! point and the point just preceding it in the distribution is,
|
||||
//! of course, generally not equal to Abscissa.
|
||||
//! Use the function IsDone() to verify that the computation was successful,
|
||||
//! the function NbPoints() to obtain the number of points of the computed distribution,
|
||||
//! and the function Parameter() to read the parameter of each point.
|
||||
//!
|
||||
//! Warning
|
||||
//! The roles of U1 and U2 are inverted if U1 > U2 .
|
||||
//! The roles of theU1 and theU2 are inverted if theU1 > theU2.
|
||||
//! Warning
|
||||
//! C is an adapted curve, that is, an object which is an
|
||||
//! interface between:
|
||||
//! theC is an adapted curve, that is, an object which is an interface between:
|
||||
//! - the services provided by either a 2D curve from
|
||||
//! the package Geom2d (in the case of an
|
||||
//! Adaptor2d_Curve2d curve) or a 3D curve from
|
||||
//! the package Geom (in the case of an Adaptor3d_Curve curve),
|
||||
//! the package Geom2d (in the case of an Adaptor2d_Curve2d curve)
|
||||
//! or a 3D curve from the package Geom (in the case of an Adaptor3d_Curve curve),
|
||||
//! - and those required on the curve by the computation algorithm.
|
||||
Standard_EXPORT GCPnts_QuasiUniformAbscissa(const Adaptor3d_Curve& C, const Standard_Integer NbPoints, const Standard_Real U1, const Standard_Real U2);
|
||||
|
||||
//! Initialize the algorithms with <C>, <NbPoints> and
|
||||
Standard_EXPORT void Initialize (const Adaptor3d_Curve& C, const Standard_Integer NbPoints);
|
||||
|
||||
//! Initialize the algorithms with <C>, <Abscissa>, <U1>,
|
||||
//! <U2>.
|
||||
Standard_EXPORT void Initialize (const Adaptor3d_Curve& C, const Standard_Integer NbPoints, const Standard_Real U1, const Standard_Real U2);
|
||||
|
||||
//! Computes a uniform abscissa distribution of points on
|
||||
//! the Curve2d <C>.
|
||||
//! <NbPoints> defines the nomber of desired points.
|
||||
Standard_EXPORT GCPnts_QuasiUniformAbscissa(const Adaptor2d_Curve2d& C, const Standard_Integer NbPoints);
|
||||
|
||||
//! Computes a Uniform abscissa distribution of points
|
||||
//! on a part of the Curve2d <C>.
|
||||
Standard_EXPORT GCPnts_QuasiUniformAbscissa(const Adaptor2d_Curve2d& C, const Standard_Integer NbPoints, const Standard_Real U1, const Standard_Real U2);
|
||||
|
||||
//! Initialize the algorithms with <C>, <NbPoints> and
|
||||
Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Integer NbPoints);
|
||||
|
||||
//! Initialize the algorithms with <C>, <Abscissa>, <U1>,
|
||||
//! <U2>.
|
||||
Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Integer NbPoints, const Standard_Real U1, const Standard_Real U2);
|
||||
//! @param theC [in] input 3D curve
|
||||
//! @param theNbPoints [in] defines the number of desired points
|
||||
//! @param theU1 [in] first parameter on curve
|
||||
//! @param theU2 [in] last parameter on curve
|
||||
Standard_EXPORT GCPnts_QuasiUniformAbscissa (const Adaptor3d_Curve& theC,
|
||||
const Standard_Integer theNbPoints,
|
||||
const Standard_Real theU1, const Standard_Real theU2);
|
||||
|
||||
//! Initialize the algorithms with 3D curve and target number of points.
|
||||
//! @param theC [in] input 3D curve
|
||||
//! @param theNbPoints [in] defines the number of desired points
|
||||
Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
|
||||
const Standard_Integer theNbPoints);
|
||||
|
||||
//! Initialize the algorithms with 3D curve, target number of points and curve parameter range.
|
||||
//! @param theC [in] input 3D curve
|
||||
//! @param theNbPoints [in] defines the number of desired points
|
||||
//! @param theU1 [in] first parameter on curve
|
||||
//! @param theU2 [in] last parameter on curve
|
||||
Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
|
||||
const Standard_Integer theNbPoints,
|
||||
const Standard_Real theU1, const Standard_Real theU2);
|
||||
|
||||
//! Computes a uniform abscissa distribution of points on the 2D curve.
|
||||
//! @param theC [in] input 2D curve
|
||||
//! @param theNbPoints [in] defines the number of desired points
|
||||
Standard_EXPORT GCPnts_QuasiUniformAbscissa (const Adaptor2d_Curve2d& theC,
|
||||
const Standard_Integer theNbPoints);
|
||||
|
||||
//! Computes a Uniform abscissa distribution of points on a part of the 2D curve.
|
||||
//! @param theC [in] input 2D curve
|
||||
//! @param theNbPoints [in] defines the number of desired points
|
||||
//! @param theU1 [in] first parameter on curve
|
||||
//! @param theU2 [in] last parameter on curve
|
||||
Standard_EXPORT GCPnts_QuasiUniformAbscissa (const Adaptor2d_Curve2d& theC,
|
||||
const Standard_Integer theNbPoints,
|
||||
const Standard_Real theU1, const Standard_Real theU2);
|
||||
|
||||
//! Initialize the algorithms with 2D curve and target number of points.
|
||||
//! @param theC [in] input 2D curve
|
||||
//! @param theNbPoints [in] defines the number of desired points
|
||||
Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& theC,
|
||||
const Standard_Integer theNbPoints);
|
||||
|
||||
//! Initialize the algorithms with 2D curve, target number of points and curve parameter range.
|
||||
//! @param theC [in] input 2D curve
|
||||
//! @param theNbPoints [in] defines the number of desired points
|
||||
//! @param theU1 [in] first parameter on curve
|
||||
//! @param theU2 [in] last parameter on curve
|
||||
Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& theC,
|
||||
const Standard_Integer theNbPoints,
|
||||
const Standard_Real theU1, const Standard_Real theU2);
|
||||
|
||||
//! Returns true if the computation was successful.
|
||||
//! IsDone is a protection against:
|
||||
//! - non-convergence of the algorithm
|
||||
@ -146,6 +165,15 @@ public:
|
||||
return myParams->Value (Index);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
//! This function divides given curve on the several parts with equal length.
|
||||
//! It returns array of parameters in the control points.
|
||||
template<class TheCurve>
|
||||
void initialize (const TheCurve& theC,
|
||||
const Standard_Integer theNbPoints,
|
||||
const Standard_Real theU1, const Standard_Real theU2);
|
||||
|
||||
private:
|
||||
Standard_Boolean myDone;
|
||||
Standard_Integer myNbPoints;
|
||||
|
||||
@ -1,141 +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,
|
||||
"GCPnts_QuasiUniformAbscissa::Initialize() - number of points should be >= 2");
|
||||
|
||||
// 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;
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user