OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

0032294: Coding Rules - merge GCPnts_QuasiUniformAbscissa.pxx into GCPnts_QuasiUniformAbscissa.cxx

Browse Source
This commit is contained in:
kgv 2021-04-10 11:55:28 +03:00
parent 3d42fbc189
commit de8a63e98e
4 changed files with 264 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/GCPnts/FILES
View File

@ -4,7 +4,6 @@ GCPnts_AbscissaPoint.hxx
GCPnts_AbscissaType.hxx GCPnts_AbscissaType.hxx
GCPnts_DeflectionType.hxx GCPnts_DeflectionType.hxx
GCPnts_QuasiUniformAbscissa.cxx GCPnts_QuasiUniformAbscissa.cxx
GCPnts_QuasiUniformAbscissa.pxx
GCPnts_QuasiUniformAbscissa.hxx GCPnts_QuasiUniformAbscissa.hxx
GCPnts_QuasiUniformDeflection.cxx GCPnts_QuasiUniformDeflection.cxx
GCPnts_QuasiUniformDeflection.pxx GCPnts_QuasiUniformDeflection.pxx

221
src/GCPnts/GCPnts_QuasiUniformAbscissa.cxx
View File

@ -12,65 +12,200 @@
// Alternatively, this file may be used under the terms of Open CASCADE // Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement. // 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_QuasiUniformAbscissa.hxx>
#include <GCPnts_TCurveTypes.hxx>
#include <GCPnts_UniformAbscissa.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> #include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#ifdef OCCT_DEBUG #include <Standard_ConstructionError.hxx>
//#include <DrawTrSurf.hxx> #include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_Array1OfPnt.hxx>
//static Standard_Integer compteur = 0;
#endif
//======================================================================= //=======================================================================
//function : GCPnts_QuasiUniformAbscissa //function : GCPnts_QuasiUniformAbscissa
//purpose : //purpose :
//======================================================================= //=======================================================================
GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa()
GCPnts_QuasiUniformAbscissa::GCPnts_QuasiUniformAbscissa () : myDone (Standard_False),
:myDone(Standard_False), myNbPoints (0)
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) //function : GCPnts_QuasiUniformAbscissa
#define Handle_TheBSplineCurve Handle(Geom_BSplineCurve) //purpose :
#define TheArray1OfPnt TColgp_Array1OfPnt //=======================================================================
#define ThePnt gp_Pnt 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 //function : GCPnts_QuasiUniformAbscissa
#undef Handle_TheBSplineCurve //purpose :
#undef TheArray1OfPnt //=======================================================================
#undef ThePnt 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) //function : Initialize
#define Handle_TheBSplineCurve Handle(Geom2d_BSplineCurve) //purpose :
#define TheArray1OfPnt TColgp_Array1OfPnt2d //=======================================================================
#define ThePnt gp_Pnt2d 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;
}

144
src/GCPnts/GCPnts_QuasiUniformAbscissa.hxx
View File

@ -20,89 +20,108 @@
#include <StdFail_NotDone.hxx> #include <StdFail_NotDone.hxx>
#include <TColStd_HArray1OfReal.hxx> #include <TColStd_HArray1OfReal.hxx>
class Standard_DomainError;
class Standard_ConstructionError;
class Standard_OutOfRange;
class StdFail_NotDone;
class Adaptor3d_Curve; class Adaptor3d_Curve;
class Adaptor2d_Curve2d; class Adaptor2d_Curve2d;
//! This class provides an algorithm to compute a uniform abscissa //! This class provides an algorithm to compute a uniform abscissa
//! distribution of points on a curve, i.e. a sequence of //! distribution of points on a curve, i.e. a sequence of equidistant points.
//! equidistant points. The distance between two //! The distance between two consecutive points is measured along the curve.
//! consecutive points is measured along the curve. //!
//! The distribution is defined: //! The distribution is defined by a number of points.
//! - either by the curvilinear distance between two consecutive points
//! - or by a number of points.
class GCPnts_QuasiUniformAbscissa class GCPnts_QuasiUniformAbscissa
{ {
public: public:
DEFINE_STANDARD_ALLOC DEFINE_STANDARD_ALLOC
//! Constructs an empty algorithm.
//! Constructs an empty algorithm. To define the problem //! To define the problem to be solved, use the function Initialize.
//! to be solved, use the function Initialize.
Standard_EXPORT GCPnts_QuasiUniformAbscissa(); Standard_EXPORT GCPnts_QuasiUniformAbscissa();
//! Computes a uniform abscissa distribution of points //! 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. //! 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 //! 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 //! where Abscissa is the curvilinear distance between
//! two consecutive points of the distribution. //! two consecutive points of the distribution.
//! The first point of the distribution is either the origin of //! The first point of the distribution is either the origin of
//! curve C or the point of parameter U1. The following //! curve or the point of parameter theU1.
//! points are computed such that the curvilinear //! The following points are computed such that the curvilinear
//! distance between two consecutive points is equal to Abscissa. //! distance between two consecutive points is equal to Abscissa.
//! The last point of the distribution is either the end //! 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 //! However the curvilinear distance between this last
//! point and the point just preceding it in the distribution //! point and the point just preceding it in the distribution is,
//! is, of course, generally not equal to Abscissa. //! of course, generally not equal to Abscissa.
//! Use the function IsDone to verify that the //! Use the function IsDone() to verify that the computation was successful,
//! computation was successful, the function NbPoints //! the function NbPoints() to obtain the number of points of the computed distribution,
//! to obtain the number of points of the computed //! and the function Parameter() to read the parameter of each point.
//! distribution, and the function Parameter to read the //!
//! parameter of each point.
//! Warning //! Warning
//! The roles of U1 and U2 are inverted if U1 > U2 . //! The roles of theU1 and theU2 are inverted if theU1 > theU2.
//! Warning //! Warning
//! C is an adapted curve, that is, an object which is an //! theC is an adapted curve, that is, an object which is an interface between:
//! interface between:
//! - the services provided by either a 2D curve from //! - the services provided by either a 2D curve from
//! the package Geom2d (in the case of an //! the package Geom2d (in the case of an Adaptor2d_Curve2d curve)
//! Adaptor2d_Curve2d curve) or a 3D curve from //! or a 3D curve from the package Geom (in the case of an Adaptor3d_Curve curve),
//! the package Geom (in the case of an Adaptor3d_Curve curve),
//! - and those required on the curve by the computation algorithm. //! - 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); //! @param theC [in] input 3D curve
//! @param theNbPoints [in] defines the number of desired points
//! Initialize the algorithms with <C>, <NbPoints> and //! @param theU1 [in] first parameter on curve
Standard_EXPORT void Initialize (const Adaptor3d_Curve& C, const Standard_Integer NbPoints); //! @param theU2 [in] last parameter on curve
Standard_EXPORT GCPnts_QuasiUniformAbscissa (const Adaptor3d_Curve& theC,
//! Initialize the algorithms with <C>, <Abscissa>, <U1>, const Standard_Integer theNbPoints,
//! <U2>. const Standard_Real theU1, const Standard_Real theU2);
Standard_EXPORT void Initialize (const Adaptor3d_Curve& C, const Standard_Integer NbPoints, const Standard_Real U1, const Standard_Real U2);
//! Initialize the algorithms with 3D curve and target number of points.
//! Computes a uniform abscissa distribution of points on //! @param theC [in] input 3D curve
//! the Curve2d <C>. //! @param theNbPoints [in] defines the number of desired points
//! <NbPoints> defines the nomber of desired points. Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
Standard_EXPORT GCPnts_QuasiUniformAbscissa(const Adaptor2d_Curve2d& C, const Standard_Integer NbPoints); const Standard_Integer theNbPoints);
//! Computes a Uniform abscissa distribution of points //! Initialize the algorithms with 3D curve, target number of points and curve parameter range.
//! on a part of the Curve2d <C>. //! @param theC [in] input 3D curve
Standard_EXPORT GCPnts_QuasiUniformAbscissa(const Adaptor2d_Curve2d& C, const Standard_Integer NbPoints, const Standard_Real U1, const Standard_Real U2); //! @param theNbPoints [in] defines the number of desired points
//! @param theU1 [in] first parameter on curve
//! Initialize the algorithms with <C>, <NbPoints> and //! @param theU2 [in] last parameter on curve
Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Integer NbPoints); Standard_EXPORT void Initialize (const Adaptor3d_Curve& theC,
const Standard_Integer theNbPoints,
//! Initialize the algorithms with <C>, <Abscissa>, <U1>, const Standard_Real theU1, const Standard_Real theU2);
//! <U2>.
Standard_EXPORT void Initialize (const Adaptor2d_Curve2d& C, const Standard_Integer NbPoints, const Standard_Real U1, const Standard_Real U2); //! 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. //! Returns true if the computation was successful.
//! IsDone is a protection against: //! IsDone is a protection against:
//! - non-convergence of the algorithm //! - non-convergence of the algorithm
@ -146,6 +165,15 @@ public:
return myParams->Value (Index); 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: private:
Standard_Boolean myDone; Standard_Boolean myDone;
Standard_Integer myNbPoints; Standard_Integer myNbPoints;

141
src/GCPnts/GCPnts_QuasiUniformAbscissa.pxx
View File

@ -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;
}
}