mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-04-05 18:16:23 +03:00
0025929: Make Approx_ComputeLine algorithm adaptive
Adaptive partition algorithm of WLine is implemented and used in ApproxInt_Approx.gxx file. Refactoring of ApproxInt_Approx class. Test cases are updated to the new behaviour. Filtering algorithm improved.
This commit is contained in:
aml
bugmaster
parent
600f8c7f47
commit
f44aa19760
File diff suppressed because it is too large
Load Diff
613
src/ApproxInt/ApproxInt_KnotTools.cxx
Normal file
613
src/ApproxInt/ApproxInt_KnotTools.cxx
Normal file
@ -0,0 +1,613 @@
|
|||||||
|
// 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 <ApproxInt_KnotTools.hxx>
|
||||||
|
#include <TColgp_Array1OfPnt2d.hxx>
|
||||||
|
#include <TColStd_Array1OfReal.hxx>
|
||||||
|
#include <TColStd_HArray1OfReal.hxx>
|
||||||
|
#include <TColStd_HArray1OfInteger.hxx>
|
||||||
|
#include <math_Vector.hxx>
|
||||||
|
#include <Geom_BSplineCurve.hxx>
|
||||||
|
#include <Geom2d_BSplineCurve.hxx>
|
||||||
|
#include <GeomInt_TheMultiLineOfWLApprox.hxx>
|
||||||
|
#include <NCollection_Sequence.hxx>
|
||||||
|
#include <NCollection_List.hxx>
|
||||||
|
#include <PLib.hxx>
|
||||||
|
#include <Precision.hxx>
|
||||||
|
#include <NCollection_Vector.hxx>
|
||||||
|
#include <TColgp_Array1OfPnt.hxx>
|
||||||
|
|
||||||
|
// (Sqrt(5.0) - 1.0) / 4.0
|
||||||
|
static const Standard_Real aSinCoeff = 0.30901699437494742410229341718282;
|
||||||
|
static const Standard_Integer aMaxPntCoeff = 15;
|
||||||
|
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : EvalCurv
|
||||||
|
//purpose : Evaluate curvature in dim-dimension point.
|
||||||
|
//=======================================================================
|
||||||
|
static Standard_Real EvalCurv(const Standard_Real dim,
|
||||||
|
const Standard_Real* V1,
|
||||||
|
const Standard_Real* V2)
|
||||||
|
{
|
||||||
|
// Really V1 and V2 are arrays of size dim;
|
||||||
|
// V1 is first derivative, V2 is second derivative
|
||||||
|
// of n-dimension curve
|
||||||
|
// Curvature is curv = |V1^V2|/|V1|^3
|
||||||
|
// V1^V2 is outer product of two vectors:
|
||||||
|
// P(i,j) = V1(i)*V2(j) - V1(j)*V2(i);
|
||||||
|
Standard_Real mp = 0.;
|
||||||
|
Standard_Integer i, j;
|
||||||
|
Standard_Real p;
|
||||||
|
for(i = 1; i < dim; ++i)
|
||||||
|
{
|
||||||
|
for(j = 0; j < i; ++j)
|
||||||
|
{
|
||||||
|
p = V1[i]*V2[j] - V1[j]*V2[i];
|
||||||
|
mp += p*p;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
//mp *= 2.; //P(j,i) = -P(i,j);
|
||||||
|
mp = Sqrt(mp);
|
||||||
|
//
|
||||||
|
Standard_Real q = 0.;
|
||||||
|
for(i = 0; i < dim; ++i)
|
||||||
|
{
|
||||||
|
q += V1[i]*V1[i];
|
||||||
|
}
|
||||||
|
q = Sqrt(q);
|
||||||
|
//
|
||||||
|
Standard_Real curv = mp / (q*q*q);
|
||||||
|
|
||||||
|
return curv;
|
||||||
|
}
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : ComputeKnotInds
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
void ApproxInt_KnotTools::ComputeKnotInds(const NCollection_LocalArray<Standard_Real>& theCoords,
|
||||||
|
const Standard_Integer theDim,
|
||||||
|
const math_Vector& thePars,
|
||||||
|
NCollection_Sequence<Standard_Integer>& theInds)
|
||||||
|
{
|
||||||
|
//I: Create discrete curvature.
|
||||||
|
NCollection_Sequence<Standard_Integer> aFeatureInds;
|
||||||
|
TColStd_Array1OfReal aCurv(thePars.Lower(), thePars.Upper());
|
||||||
|
// Arrays are allocated for max theDim = 7: 1 3d curve + 2 2d curves.
|
||||||
|
Standard_Real Val[21], Par[3], Res[21];
|
||||||
|
Standard_Integer i, j, k, l, m, ic;
|
||||||
|
Standard_Real aMaxCurv = 0.;
|
||||||
|
Standard_Integer dim = theDim;
|
||||||
|
//
|
||||||
|
i = aCurv.Lower();
|
||||||
|
for(j = 0; j < 3; ++j)
|
||||||
|
{
|
||||||
|
k = i+j;
|
||||||
|
ic = (k - aCurv.Lower()) * dim;
|
||||||
|
l = dim*j;
|
||||||
|
for(m = 0; m < dim; ++m)
|
||||||
|
{
|
||||||
|
Val[l + m] = theCoords[ic + m];
|
||||||
|
}
|
||||||
|
Par[j] = thePars(k);
|
||||||
|
}
|
||||||
|
PLib::EvalLagrange(Par[0], 2, 2, dim, *Val, *Par, *Res);
|
||||||
|
//
|
||||||
|
aCurv(i) = EvalCurv(dim, &Res[dim], &Res[2*dim]);
|
||||||
|
//
|
||||||
|
if(aCurv(i) > aMaxCurv)
|
||||||
|
{
|
||||||
|
aMaxCurv = aCurv(i);
|
||||||
|
}
|
||||||
|
//
|
||||||
|
for(i = aCurv.Lower()+1; i < aCurv.Upper(); ++i)
|
||||||
|
{
|
||||||
|
for(j = 0; j < 3; ++j)
|
||||||
|
{
|
||||||
|
k = i+j-1;
|
||||||
|
ic = (k - aCurv.Lower()) * dim;
|
||||||
|
l = dim*j;
|
||||||
|
for(m = 0; m < dim; ++m)
|
||||||
|
{
|
||||||
|
Val[l + m] = theCoords[ic + m];
|
||||||
|
}
|
||||||
|
Par[j] = thePars(k);
|
||||||
|
}
|
||||||
|
PLib::EvalLagrange(Par[1], 2, 2, dim, *Val, *Par, *Res);
|
||||||
|
//
|
||||||
|
aCurv(i) = EvalCurv(dim, &Res[dim], &Res[2*dim]);
|
||||||
|
if(aCurv(i) > aMaxCurv)
|
||||||
|
{
|
||||||
|
aMaxCurv = aCurv(i);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
//
|
||||||
|
i = aCurv.Upper();
|
||||||
|
for(j = 0; j < 3; ++j)
|
||||||
|
{
|
||||||
|
k = i+j-2;
|
||||||
|
ic = (k - aCurv.Lower()) * dim;
|
||||||
|
l = dim*j;
|
||||||
|
for(m = 0; m < dim; ++m)
|
||||||
|
{
|
||||||
|
Val[l + m] = theCoords[ic + m];
|
||||||
|
}
|
||||||
|
Par[j] = thePars(k);
|
||||||
|
}
|
||||||
|
PLib::EvalLagrange(Par[2], 2, 2, dim, *Val, *Par, *Res);
|
||||||
|
//
|
||||||
|
aCurv(i) = EvalCurv(dim, &Res[dim], &Res[2*dim]);
|
||||||
|
if(aCurv(i) > aMaxCurv)
|
||||||
|
{
|
||||||
|
aMaxCurv = aCurv(i);
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(APPROXINT_KNOTTOOLS_DEBUG) || defined(OCCT_DEBUG)
|
||||||
|
cout << "Discrete curvature array is" << endl;
|
||||||
|
for(i = aCurv.Lower(); i <= aCurv.Upper(); ++i)
|
||||||
|
{
|
||||||
|
cout << i << " " << aCurv(i) << endl;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
theInds.Append(aCurv.Lower());
|
||||||
|
if(aMaxCurv <= Precision::Confusion())
|
||||||
|
{
|
||||||
|
// Linear case.
|
||||||
|
theInds.Append(aCurv.Upper());
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// II: Find extremas of curvature.
|
||||||
|
// Not used Precision::PConfusion, by different from "param space" eps nature.
|
||||||
|
Standard_Real eps = 1.0e-9,
|
||||||
|
eps1 = 1.0e3 * eps;
|
||||||
|
for(i = aCurv.Lower() + 1; i < aCurv.Upper(); ++i)
|
||||||
|
{
|
||||||
|
Standard_Real d1 = aCurv(i) - aCurv(i - 1),
|
||||||
|
d2 = aCurv(i) - aCurv(i + 1),
|
||||||
|
ad1 = Abs(d1), ad2 = Abs(d2);
|
||||||
|
|
||||||
|
if(d1*d2 > 0. && ad1 > eps && ad2 > eps)
|
||||||
|
{
|
||||||
|
if(i != theInds.Last())
|
||||||
|
{
|
||||||
|
theInds.Append(i);
|
||||||
|
aFeatureInds.Append(i);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if((ad1 < eps && ad2 > eps1) || (ad1 > eps1 && ad2 < eps))
|
||||||
|
{
|
||||||
|
if(i != theInds.Last())
|
||||||
|
{
|
||||||
|
theInds.Append(i);
|
||||||
|
aFeatureInds.Append(i);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if(aCurv(i)*aCurv(i + 1) < 0.0)
|
||||||
|
{
|
||||||
|
if(Abs(aCurv(i)) < Abs(aCurv(i + 1)))
|
||||||
|
{
|
||||||
|
if(i != theInds.Last())
|
||||||
|
{
|
||||||
|
theInds.Append(i);
|
||||||
|
aFeatureInds.Append(i);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if(i+1 != theInds.Last())
|
||||||
|
{
|
||||||
|
theInds.Append(i + 1);
|
||||||
|
aFeatureInds.Append(i + 1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if(aCurv.Upper() != theInds.Last())
|
||||||
|
{
|
||||||
|
theInds.Append(aCurv.Upper());
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(APPROXINT_KNOTTOOLS_DEBUG) || defined(OCCT_DEBUG)
|
||||||
|
{
|
||||||
|
cout << "Feature indices new: " << endl;
|
||||||
|
i;
|
||||||
|
for(i = theInds.Lower(); i <= theInds.Upper(); ++i)
|
||||||
|
{
|
||||||
|
cout << i << " : " << theInds(i) << endl;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
//III: Put knots in monotone intervals of curvature.
|
||||||
|
Standard_Boolean Ok;
|
||||||
|
i = 1;
|
||||||
|
do
|
||||||
|
{
|
||||||
|
i++;
|
||||||
|
//
|
||||||
|
Ok = InsKnotBefI(i, aCurv, theCoords, dim, theInds, Standard_True);
|
||||||
|
if(Ok)
|
||||||
|
{
|
||||||
|
i--;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
while(i < theInds.Length());
|
||||||
|
|
||||||
|
//IV: Cheking feature points.
|
||||||
|
j = 2;
|
||||||
|
for(i = 1; i <= aFeatureInds.Length(); ++i)
|
||||||
|
{
|
||||||
|
Standard_Integer anInd = aFeatureInds(i);
|
||||||
|
for(; j <= theInds.Length() - 1;)
|
||||||
|
{
|
||||||
|
if(theInds(j) == anInd)
|
||||||
|
{
|
||||||
|
Standard_Integer anIndPrev = theInds(j-1);
|
||||||
|
Standard_Integer anIndNext = theInds(j+1);
|
||||||
|
Standard_Real sina;
|
||||||
|
Standard_Integer ici = (anIndPrev - aCurv.Lower()) * theDim,
|
||||||
|
ici1 = (anIndNext - aCurv.Lower()) * theDim,
|
||||||
|
icm = (anInd - aCurv.Lower()) * theDim;
|
||||||
|
NCollection_LocalArray<Standard_Real> V1(theDim), V2(theDim);
|
||||||
|
Standard_Integer k,l;
|
||||||
|
Standard_Real mp = 0., m1 = 0., m2 = 0.;
|
||||||
|
Standard_Real p;
|
||||||
|
for(k = 0; k < theDim; ++k)
|
||||||
|
{
|
||||||
|
V1[k] = theCoords[icm + k] - theCoords[ici + k];
|
||||||
|
m1 += V1[k]*V1[k];
|
||||||
|
V2[k] = theCoords[ici1 + k] - theCoords[icm + k];
|
||||||
|
m2 += V2[k]*V2[k];
|
||||||
|
}
|
||||||
|
for(k = 1; k < theDim; ++k)
|
||||||
|
{
|
||||||
|
for(l = 0; l < k; ++l)
|
||||||
|
{
|
||||||
|
p = V1[k]*V2[l] - V1[l]*V2[k];
|
||||||
|
mp += p*p;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
//mp *= 2.; //P(j,i) = -P(i,j);
|
||||||
|
//
|
||||||
|
sina = mp/(m1*m2);
|
||||||
|
sina = Sqrt(sina);
|
||||||
|
|
||||||
|
if(sina > aSinCoeff)
|
||||||
|
{
|
||||||
|
//Insert new knots
|
||||||
|
Standard_Real d1 = Abs(aCurv(anInd) - aCurv(anIndPrev));
|
||||||
|
Standard_Real d2 = Abs(aCurv(anInd) - aCurv(anIndNext));
|
||||||
|
if(d1 > d2)
|
||||||
|
{
|
||||||
|
Ok = InsKnotBefI(j, aCurv, theCoords, dim, theInds, Standard_False);
|
||||||
|
if(Ok)
|
||||||
|
{
|
||||||
|
j++;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
Ok = InsKnotBefI(j+1, aCurv, theCoords, dim, theInds, Standard_False);
|
||||||
|
if(!Ok)
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
j++;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
j++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
//
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : FilterKnots
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
void ApproxInt_KnotTools::FilterKnots(NCollection_Sequence<Standard_Integer>& theInds,
|
||||||
|
const Standard_Integer theMinNbPnts,
|
||||||
|
NCollection_Vector<Standard_Integer>& theLKnots)
|
||||||
|
{
|
||||||
|
// Maximum number of points per knot interval.
|
||||||
|
Standard_Integer aMaxNbPnts = aMaxPntCoeff*theMinNbPnts;
|
||||||
|
Standard_Integer i = 1;
|
||||||
|
Standard_Integer aMinNbStep = theMinNbPnts / 2;
|
||||||
|
|
||||||
|
// I: Filter too big number of points per knot interval.
|
||||||
|
while(i < theInds.Length())
|
||||||
|
{
|
||||||
|
Standard_Integer nbint = theInds(i + 1) - theInds(i) + 1;
|
||||||
|
if(nbint <= aMaxNbPnts)
|
||||||
|
{
|
||||||
|
++i;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
Standard_Integer ind = theInds(i) + nbint / 2;
|
||||||
|
theInds.InsertAfter(i, ind);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// II: Filter poins with too small amount of points per knot interval.
|
||||||
|
i = 1;
|
||||||
|
theLKnots.Append(theInds(i));
|
||||||
|
Standard_Integer anIndsPrev = theInds(i);
|
||||||
|
for(i = 2; i <= theInds.Length(); ++i)
|
||||||
|
{
|
||||||
|
if(theInds(i) - anIndsPrev <= theMinNbPnts)
|
||||||
|
{
|
||||||
|
if (i != theInds.Length())
|
||||||
|
{
|
||||||
|
Standard_Integer anIdx = i + 1;
|
||||||
|
for( ; anIdx <= theInds.Length(); ++anIdx)
|
||||||
|
{
|
||||||
|
if (theInds(anIdx) - anIndsPrev > theMinNbPnts)
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
anIdx--;
|
||||||
|
|
||||||
|
Standard_Integer aMidIdx = (theInds(anIdx) + anIndsPrev) / 2;
|
||||||
|
if (aMidIdx - anIndsPrev < theMinNbPnts &&
|
||||||
|
aMidIdx - theInds(anIdx) < theMinNbPnts &&
|
||||||
|
theInds(anIdx) - anIndsPrev >= aMinNbStep)
|
||||||
|
{
|
||||||
|
// Bad distribution points merge into one knot interval.
|
||||||
|
theLKnots.Append(theInds(anIdx));
|
||||||
|
anIndsPrev = theInds(anIdx);
|
||||||
|
i = anIdx;
|
||||||
|
}
|
||||||
|
else if (anIdx == theInds.Upper() && // Last point obtained.
|
||||||
|
theLKnots.Length() >= 2) // It is possible to modify last item.
|
||||||
|
{
|
||||||
|
// Current bad interval from i to last.
|
||||||
|
// Trying to add knot to divide sequence on two parts:
|
||||||
|
// Last good index -> Last index - theMinNbPnts -> Last index
|
||||||
|
Standard_Integer aLastGoodIdx = theLKnots.Value(theLKnots.Upper() - 1);
|
||||||
|
if ( theInds.Last() - 2 * theMinNbPnts >= aLastGoodIdx)
|
||||||
|
{
|
||||||
|
theLKnots(theLKnots.Upper()) = theInds.Last() - theMinNbPnts;
|
||||||
|
theLKnots.Append(theInds.Last());
|
||||||
|
anIndsPrev = theInds(anIdx);
|
||||||
|
i = anIdx;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} // if (i != theInds.Length())
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
theLKnots.Append(theInds(i));
|
||||||
|
anIndsPrev = theInds(i);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// III: Fill Last Knot.
|
||||||
|
if(theLKnots.Length() < 2)
|
||||||
|
{
|
||||||
|
theLKnots.Append(theInds.Last());
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
if(theLKnots.Last() < theInds.Last())
|
||||||
|
{
|
||||||
|
theLKnots(theLKnots.Upper()) = theInds.Last();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
//=======================================================================
|
||||||
|
//function : InsKnotBefI
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
Standard_Boolean ApproxInt_KnotTools::InsKnotBefI(const Standard_Integer theI,
|
||||||
|
const TColStd_Array1OfReal& theCurv,
|
||||||
|
const NCollection_LocalArray<Standard_Real>& theCoords,
|
||||||
|
const Standard_Integer theDim,
|
||||||
|
NCollection_Sequence<Standard_Integer>& theInds,
|
||||||
|
const Standard_Boolean ChkCurv)
|
||||||
|
{
|
||||||
|
Standard_Integer anInd1 = theInds(theI);
|
||||||
|
Standard_Integer anInd = theInds(theI - 1);
|
||||||
|
//
|
||||||
|
if((anInd1-anInd) == 1)
|
||||||
|
{
|
||||||
|
return Standard_False;
|
||||||
|
}
|
||||||
|
//
|
||||||
|
Standard_Real curv = 0.5*(theCurv(anInd) + theCurv(anInd1));
|
||||||
|
Standard_Integer mid = 0, j, jj;
|
||||||
|
const Standard_Real aLimitCurvatureChange = 3.0;
|
||||||
|
for(j = anInd+1; j < anInd1; ++j)
|
||||||
|
{
|
||||||
|
mid = 0;
|
||||||
|
|
||||||
|
// I: Curvature change criteria:
|
||||||
|
// Non-null curvature.
|
||||||
|
if (theCurv(j) > Precision::Confusion() &&
|
||||||
|
theCurv(anInd) > Precision::Confusion() )
|
||||||
|
{
|
||||||
|
if (theCurv(j) / theCurv(anInd) > aLimitCurvatureChange ||
|
||||||
|
theCurv(j) / theCurv(anInd) < 1.0 / aLimitCurvatureChange)
|
||||||
|
{
|
||||||
|
// Curvature on current interval changed more than 3 times.
|
||||||
|
mid = j;
|
||||||
|
theInds.InsertBefore(theI, mid);
|
||||||
|
return Standard_True;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// II: Angular criteria:
|
||||||
|
Standard_Real ac = theCurv(j - 1), ac1 = theCurv(j);
|
||||||
|
if((curv >= ac && curv <= ac1) || (curv >= ac1 && curv <= ac))
|
||||||
|
{
|
||||||
|
if(Abs(curv - ac) < Abs(curv - ac1))
|
||||||
|
{
|
||||||
|
mid = j - 1;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
mid = j;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if(mid == anInd)
|
||||||
|
{
|
||||||
|
mid++;
|
||||||
|
}
|
||||||
|
if(mid == anInd1)
|
||||||
|
{
|
||||||
|
mid--;
|
||||||
|
}
|
||||||
|
if(mid > 0)
|
||||||
|
{
|
||||||
|
if(ChkCurv)
|
||||||
|
{
|
||||||
|
Standard_Real sina;
|
||||||
|
Standard_Integer ici = (anInd - theCurv.Lower()) * theDim,
|
||||||
|
ici1 = (anInd1 - theCurv.Lower()) * theDim,
|
||||||
|
icm = (mid - theCurv.Lower()) * theDim;
|
||||||
|
NCollection_LocalArray<Standard_Real> V1(theDim), V2(theDim);
|
||||||
|
Standard_Integer i;
|
||||||
|
Standard_Real mp = 0., m1 = 0., m2 = 0.;
|
||||||
|
Standard_Real p;
|
||||||
|
for(i = 0; i < theDim; ++i)
|
||||||
|
{
|
||||||
|
V1[i] = theCoords[icm + i] - theCoords[ici + i];
|
||||||
|
m1 += V1[i]*V1[i];
|
||||||
|
V2[i] = theCoords[ici1 + i] - theCoords[icm + i];
|
||||||
|
m2 += V2[i]*V2[i];
|
||||||
|
}
|
||||||
|
for(i = 1; i < theDim; ++i)
|
||||||
|
{
|
||||||
|
for(jj = 0; jj < i; ++jj)
|
||||||
|
{
|
||||||
|
p = V1[i]*V2[jj] - V1[jj]*V2[i];
|
||||||
|
mp += p*p;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
//mp *= 2.; //P(j,i) = -P(i,j);
|
||||||
|
//
|
||||||
|
sina = mp/(m1*m2);
|
||||||
|
sina = Sqrt(sina);
|
||||||
|
|
||||||
|
if(sina > aSinCoeff)
|
||||||
|
{
|
||||||
|
theInds.InsertBefore(theI, mid);
|
||||||
|
return Standard_True;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
theInds.InsertBefore(theI, mid);
|
||||||
|
return Standard_True;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return Standard_False;
|
||||||
|
}
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : BuildKnots
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
void ApproxInt_KnotTools::BuildKnots(const TColgp_Array1OfPnt& thePntsXYZ,
|
||||||
|
const TColgp_Array1OfPnt2d& thePntsU1V1,
|
||||||
|
const TColgp_Array1OfPnt2d& thePntsU2V2,
|
||||||
|
const math_Vector& thePars,
|
||||||
|
const Standard_Boolean theApproxXYZ,
|
||||||
|
const Standard_Boolean theApproxU1V1,
|
||||||
|
const Standard_Boolean theApproxU2V2,
|
||||||
|
const Standard_Integer theMinNbPnts,
|
||||||
|
NCollection_Vector<Standard_Integer>& theKnots)
|
||||||
|
{
|
||||||
|
NCollection_Sequence<Standard_Integer> aKnots;
|
||||||
|
Standard_Integer aDim = 0;
|
||||||
|
|
||||||
|
// I: Convert input data to the corresponding format.
|
||||||
|
if(theApproxXYZ)
|
||||||
|
aDim += 3;
|
||||||
|
if(theApproxU1V1)
|
||||||
|
aDim += 2;
|
||||||
|
if(theApproxU2V2)
|
||||||
|
aDim += 2;
|
||||||
|
|
||||||
|
NCollection_LocalArray<Standard_Real> aCoords(thePars.Length()*aDim);
|
||||||
|
Standard_Integer i, j;
|
||||||
|
for(i = thePars.Lower(); i <= thePars.Upper(); ++i)
|
||||||
|
{
|
||||||
|
j = (i - thePars.Lower()) * aDim;
|
||||||
|
if(theApproxXYZ)
|
||||||
|
{
|
||||||
|
aCoords[j] = thePntsXYZ.Value(i).X();
|
||||||
|
++j;
|
||||||
|
aCoords[j] = thePntsXYZ.Value(i).Y();
|
||||||
|
++j;
|
||||||
|
aCoords[j] = thePntsXYZ.Value(i).Z();
|
||||||
|
++j;
|
||||||
|
}
|
||||||
|
if(theApproxU1V1)
|
||||||
|
{
|
||||||
|
aCoords[j] = thePntsU1V1.Value(i).X();
|
||||||
|
++j;
|
||||||
|
aCoords[j] = thePntsU1V1.Value(i).Y();
|
||||||
|
++j;
|
||||||
|
}
|
||||||
|
if(theApproxU2V2)
|
||||||
|
{
|
||||||
|
aCoords[j] = thePntsU2V2.Value(i).X();
|
||||||
|
++j;
|
||||||
|
aCoords[j] = thePntsU2V2.Value(i).Y();
|
||||||
|
++j;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// II: Build draft knot sequence.
|
||||||
|
ComputeKnotInds(aCoords, aDim, thePars, aKnots);
|
||||||
|
|
||||||
|
#if defined(APPROXINT_KNOTTOOLS_DEBUG) || defined(OCCT_DEBUG)
|
||||||
|
cout << "Draft knot sequence: " << endl;
|
||||||
|
for(i = aKnots.Lower(); i <= aKnots.Upper(); ++i)
|
||||||
|
{
|
||||||
|
cout << i << " : " << aKnots(i) << endl;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
// III: Build output knot sequence.
|
||||||
|
FilterKnots(aKnots, theMinNbPnts, theKnots);
|
||||||
|
|
||||||
|
#if defined(APPROXINT_KNOTTOOLS_DEBUG) || defined(OCCT_DEBUG)
|
||||||
|
cout << "Result knot sequence: " << endl;
|
||||||
|
for(i = theKnots.Lower(); i <= theKnots.Upper(); ++i)
|
||||||
|
{
|
||||||
|
cout << i << " : " << theKnots(i) << endl;
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
}
|
||||||
132
src/ApproxInt/ApproxInt_KnotTools.hxx
Normal file
132
src/ApproxInt/ApproxInt_KnotTools.hxx
Normal file
@ -0,0 +1,132 @@
|
|||||||
|
// Copyright (c) 1999-2014 OPEN CASCADE SAS
|
||||||
|
//
|
||||||
|
// This file is part of Open CASCADE Technology software library.
|
||||||
|
//
|
||||||
|
// This library is free software; you can redistribute it and/or modify it under
|
||||||
|
// the terms of the GNU Lesser General Public License version 2.1 as published
|
||||||
|
// by the Free Software Foundation, with special exception defined in the file
|
||||||
|
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
||||||
|
// distribution for complete text of the license and disclaimer of any warranty.
|
||||||
|
//
|
||||||
|
// Alternatively, this file may be used under the terms of Open CASCADE
|
||||||
|
// commercial license or contractual agreement.
|
||||||
|
|
||||||
|
#ifndef _ApproxInt_KnotTools_HeaderFile
|
||||||
|
#define _ApproxInt_KnotTools_HeaderFile
|
||||||
|
|
||||||
|
#ifndef _Standard_HeaderFile
|
||||||
|
#include <Standard.hxx>
|
||||||
|
#endif
|
||||||
|
#ifndef _Standard_DefineAlloc_HeaderFile
|
||||||
|
#include <Standard_DefineAlloc.hxx>
|
||||||
|
#endif
|
||||||
|
#ifndef _Standard_Macro_HeaderFile
|
||||||
|
#include <Standard_Macro.hxx>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#ifndef _Standard_Boolean_HeaderFile
|
||||||
|
#include <Standard_Boolean.hxx>
|
||||||
|
#endif
|
||||||
|
#ifndef _Standard_Real_HeaderFile
|
||||||
|
#include <Standard_Real.hxx>
|
||||||
|
#endif
|
||||||
|
#ifndef _Standard_Integer_HeaderFile
|
||||||
|
#include <Standard_Integer.hxx>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#include <TColgp_Array1OfPnt2d.hxx>
|
||||||
|
#include <TColgp_Array1OfPnt.hxx>
|
||||||
|
#include <TColStd_Array1OfReal.hxx>
|
||||||
|
#include <NCollection_LocalArray.hxx>
|
||||||
|
|
||||||
|
class math_Vector;
|
||||||
|
template <class A> class NCollection_Sequence;
|
||||||
|
template <class A> class NCollection_List;
|
||||||
|
template <class A> class NCollection_Vector;
|
||||||
|
|
||||||
|
// Corresponds for debug information output.
|
||||||
|
// Debug information is also printed when OCCT_DEBUG defined.
|
||||||
|
//#define APPROXINT_KNOTTOOLS_DEBUG
|
||||||
|
|
||||||
|
//! This class intended to build knots sequence on discrete set of points for further approximation into bspline curve.
|
||||||
|
//!
|
||||||
|
//! Short description of algorithm:
|
||||||
|
//! 1) Build discrete curvature on points set.
|
||||||
|
//! 2) According to special rules build draft knots sequence.
|
||||||
|
//! 3) Filter draft sequence to build output sequence.
|
||||||
|
//!
|
||||||
|
//! For more details look at:
|
||||||
|
//! Anshuman Razdan - Knot Placement for B-Spline curve Approximation.
|
||||||
|
class ApproxInt_KnotTools
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
|
||||||
|
DEFINE_STANDARD_ALLOC
|
||||||
|
|
||||||
|
//! Main function to build optimal knot sequence.
|
||||||
|
//! At least one set from (thePntsXYZ, thePntsU1V1, thePntsU2V2) should exist.
|
||||||
|
//! @param thePntsXYZ - Set of 3d points.
|
||||||
|
//! @param thePntsU1V1 - Set of 2d points.
|
||||||
|
//! @param thePntsU2V2 - Set of 2d points.
|
||||||
|
//! @param thePars - Expected parameters assoiated with set.
|
||||||
|
//! @param theApproxXYZ - Flag, existence of 3d set.
|
||||||
|
//! @param theApproxU1V1 - Flag existence of first 2d set.
|
||||||
|
//! @param theApproxU2V2 - Flag existence of second 2d set.
|
||||||
|
//! @param theMinNbPnts - Minimal number of points per knot interval.
|
||||||
|
//! @param theKnots - output knots sequence.
|
||||||
|
Standard_EXPORT static void BuildKnots(const TColgp_Array1OfPnt& thePntsXYZ,
|
||||||
|
const TColgp_Array1OfPnt2d& thePntsU1V1,
|
||||||
|
const TColgp_Array1OfPnt2d& thePntsU2V2,
|
||||||
|
const math_Vector& thePars,
|
||||||
|
const Standard_Boolean theApproxXYZ,
|
||||||
|
const Standard_Boolean theApproxU1V1,
|
||||||
|
const Standard_Boolean theApproxU2V2,
|
||||||
|
const Standard_Integer theMinNbPnts,
|
||||||
|
NCollection_Vector<Standard_Integer>& theKnots);
|
||||||
|
|
||||||
|
private:
|
||||||
|
|
||||||
|
//! Compute indices of knots:
|
||||||
|
//!
|
||||||
|
//! I: Build discrete curvature in points set,
|
||||||
|
//! using outer product of two vectors.
|
||||||
|
//!
|
||||||
|
//! II: Put knots in points which has extremity on discrete curvature.
|
||||||
|
//!
|
||||||
|
//! III: Put knots in monotone intervals of curvature.
|
||||||
|
//!
|
||||||
|
//! IV: Put additional knots near extrema points.
|
||||||
|
static void ComputeKnotInds(const NCollection_LocalArray<Standard_Real>& theCoords,
|
||||||
|
const Standard_Integer theDim,
|
||||||
|
const math_Vector& thePars,
|
||||||
|
NCollection_Sequence<Standard_Integer>& theInds);
|
||||||
|
|
||||||
|
//! Insert knots before index I.
|
||||||
|
//!
|
||||||
|
//! I: Check curvature change:
|
||||||
|
//! if ( maxCurvature / minCurvature ) of current interval greater than
|
||||||
|
//! threshold value, then stop and use upper index as knot.
|
||||||
|
//!
|
||||||
|
//! II: Check midpoint criteria:
|
||||||
|
//! If exist point between two knot indices with angle greater than
|
||||||
|
//! threshold value, then stop and put this index as knot.
|
||||||
|
static Standard_Boolean InsKnotBefI(const Standard_Integer theI,
|
||||||
|
const TColStd_Array1OfReal& theCurv,
|
||||||
|
const NCollection_LocalArray<Standard_Real>& theCoords,
|
||||||
|
const Standard_Integer theDim,
|
||||||
|
NCollection_Sequence<Standard_Integer>& theInds,
|
||||||
|
const Standard_Boolean ChkCurv);
|
||||||
|
|
||||||
|
//! Perform knots filtration.
|
||||||
|
//!
|
||||||
|
//! I: Filter too big number of points per knot interval.
|
||||||
|
//!
|
||||||
|
//! II: Filter poins with too small amount of points per knot interval.
|
||||||
|
//!
|
||||||
|
//! III: Fill Last Knot.
|
||||||
|
static void FilterKnots(NCollection_Sequence<Standard_Integer>& theInds,
|
||||||
|
const Standard_Integer theMinNbPnts,
|
||||||
|
NCollection_Vector<Standard_Integer>& theLKnots);
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif
|
||||||
@ -2,6 +2,8 @@ ApproxInt_Approx.gxx
|
|||||||
ApproxInt_ImpPrmSvSurfaces.gxx
|
ApproxInt_ImpPrmSvSurfaces.gxx
|
||||||
ApproxInt_MultiLine.gxx
|
ApproxInt_MultiLine.gxx
|
||||||
ApproxInt_MultiLineTool.gxx
|
ApproxInt_MultiLineTool.gxx
|
||||||
|
ApproxInt_KnotTools.hxx
|
||||||
|
ApproxInt_KnotTools.cxx
|
||||||
ApproxInt_MultiLineTool.lxx
|
ApproxInt_MultiLineTool.lxx
|
||||||
ApproxInt_PrmPrmSvSurfaces.gxx
|
ApproxInt_PrmPrmSvSurfaces.gxx
|
||||||
ApproxInt_SvSurfaces.cxx
|
ApproxInt_SvSurfaces.cxx
|
||||||
|
|||||||
@ -21,6 +21,7 @@
|
|||||||
#include <Standard_DefineAlloc.hxx>
|
#include <Standard_DefineAlloc.hxx>
|
||||||
#include <Standard_Handle.hxx>
|
#include <Standard_Handle.hxx>
|
||||||
|
|
||||||
|
#include <NCollection_Vector.hxx>
|
||||||
#include <BRepApprox_TheComputeLineOfApprox.hxx>
|
#include <BRepApprox_TheComputeLineOfApprox.hxx>
|
||||||
#include <BRepApprox_TheComputeLineBezierOfApprox.hxx>
|
#include <BRepApprox_TheComputeLineBezierOfApprox.hxx>
|
||||||
#include <Approx_MCurvesToBSpCurve.hxx>
|
#include <Approx_MCurvesToBSpCurve.hxx>
|
||||||
@ -48,6 +49,22 @@ class BRepApprox_TheComputeLineBezierOfApprox;
|
|||||||
class BRepApprox_MyGradientOfTheComputeLineBezierOfApprox;
|
class BRepApprox_MyGradientOfTheComputeLineBezierOfApprox;
|
||||||
class AppParCurves_MultiBSpCurve;
|
class AppParCurves_MultiBSpCurve;
|
||||||
|
|
||||||
|
struct Approx_Data
|
||||||
|
{
|
||||||
|
Approx_Data()
|
||||||
|
{
|
||||||
|
myMinFactorXYZ = 0.0;
|
||||||
|
myMinFactorUV = 0.0;
|
||||||
|
}
|
||||||
|
|
||||||
|
Standard_Boolean myBezierApprox;
|
||||||
|
Standard_Real Xo, Ax, Yo, Ay, Zo, Az,
|
||||||
|
U1o, A1u, V1o, A1v, U2o, A2u, V2o, A2v;
|
||||||
|
Standard_Boolean ApproxXYZ, ApproxU1V1, ApproxU2V2;
|
||||||
|
Standard_Integer indicemin, indicemax, nbpntmax;
|
||||||
|
Approx_ParametrizationType parametrization;
|
||||||
|
Standard_Real myMinFactorXYZ, myMinFactorUV;
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
class BRepApprox_Approx
|
class BRepApprox_Approx
|
||||||
@ -100,12 +117,31 @@ private:
|
|||||||
|
|
||||||
Standard_EXPORT void UpdateTolReached();
|
Standard_EXPORT void UpdateTolReached();
|
||||||
|
|
||||||
|
//! Fill data structure for intersection approximation.
|
||||||
|
Standard_EXPORT void fillData(const Handle(BRepApprox_ApproxLine)& theLine,
|
||||||
|
const Standard_Boolean theApproxXYZ,
|
||||||
|
const Standard_Boolean theApproxU1V1,
|
||||||
|
const Standard_Boolean theApproxU2V2);
|
||||||
|
|
||||||
|
//! Prepare data structure for further computations.
|
||||||
|
Standard_EXPORT void prepareDS(const Standard_Boolean theApproxXYZ,
|
||||||
|
const Standard_Boolean theApproxU1V1,
|
||||||
|
const Standard_Boolean theApproxU2V2,
|
||||||
|
const Standard_Integer indicemin,
|
||||||
|
const Standard_Integer indicemax);
|
||||||
|
|
||||||
|
//! Build knot sequence.
|
||||||
|
Standard_EXPORT void buildKnots(const Handle(BRepApprox_ApproxLine)& theline,
|
||||||
|
const Standard_Address thePtrSVSurf);
|
||||||
|
|
||||||
|
//! Build curve.
|
||||||
|
Standard_EXPORT void buildCurve(const Handle(BRepApprox_ApproxLine)& theline,
|
||||||
|
const Standard_Address thePtrSVSurf);
|
||||||
|
|
||||||
BRepApprox_TheComputeLineOfApprox myComputeLine;
|
BRepApprox_TheComputeLineOfApprox myComputeLine;
|
||||||
BRepApprox_TheComputeLineBezierOfApprox myComputeLineBezier;
|
BRepApprox_TheComputeLineBezierOfApprox myComputeLineBezier;
|
||||||
Approx_MCurvesToBSpCurve myBezToBSpl;
|
Approx_MCurvesToBSpCurve myBezToBSpl;
|
||||||
Standard_Boolean myTolReached;
|
Standard_Boolean myTolReached;
|
||||||
Standard_Boolean myApproxBez;
|
|
||||||
Standard_Boolean myWithTangency;
|
Standard_Boolean myWithTangency;
|
||||||
Standard_Real myTol3d;
|
Standard_Real myTol3d;
|
||||||
Standard_Real myTol2d;
|
Standard_Real myTol2d;
|
||||||
@ -114,11 +150,11 @@ private:
|
|||||||
Standard_Integer myDegMax;
|
Standard_Integer myDegMax;
|
||||||
Standard_Integer myNbPntMax;
|
Standard_Integer myNbPntMax;
|
||||||
Standard_Integer myNbIterMax;
|
Standard_Integer myNbIterMax;
|
||||||
Standard_Real myMinFactorXYZ;
|
|
||||||
Standard_Real myMinFactorUV;
|
|
||||||
Standard_Real myTolReached3d;
|
Standard_Real myTolReached3d;
|
||||||
Standard_Real myTolReached2d;
|
Standard_Real myTolReached2d;
|
||||||
|
Approx_Data myData;
|
||||||
|
Standard_Real myUVRes1, myUVRes2;
|
||||||
|
NCollection_Vector<Standard_Integer> myKnots;
|
||||||
|
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|||||||
@ -21,6 +21,7 @@
|
|||||||
#include <Standard_DefineAlloc.hxx>
|
#include <Standard_DefineAlloc.hxx>
|
||||||
#include <Standard_Handle.hxx>
|
#include <Standard_Handle.hxx>
|
||||||
|
|
||||||
|
#include <NCollection_Vector.hxx>
|
||||||
#include <GeomInt_TheComputeLineOfWLApprox.hxx>
|
#include <GeomInt_TheComputeLineOfWLApprox.hxx>
|
||||||
#include <GeomInt_TheComputeLineBezierOfWLApprox.hxx>
|
#include <GeomInt_TheComputeLineBezierOfWLApprox.hxx>
|
||||||
#include <Approx_MCurvesToBSpCurve.hxx>
|
#include <Approx_MCurvesToBSpCurve.hxx>
|
||||||
@ -48,6 +49,22 @@ class GeomInt_TheComputeLineBezierOfWLApprox;
|
|||||||
class GeomInt_MyGradientOfTheComputeLineBezierOfWLApprox;
|
class GeomInt_MyGradientOfTheComputeLineBezierOfWLApprox;
|
||||||
class AppParCurves_MultiBSpCurve;
|
class AppParCurves_MultiBSpCurve;
|
||||||
|
|
||||||
|
struct Approx_Data
|
||||||
|
{
|
||||||
|
Approx_Data()
|
||||||
|
{
|
||||||
|
myMinFactorXYZ = 0.0;
|
||||||
|
myMinFactorUV = 0.0;
|
||||||
|
}
|
||||||
|
|
||||||
|
Standard_Boolean myBezierApprox;
|
||||||
|
Standard_Real Xo, Ax, Yo, Ay, Zo, Az,
|
||||||
|
U1o, A1u, V1o, A1v, U2o, A2u, V2o, A2v;
|
||||||
|
Standard_Boolean ApproxXYZ, ApproxU1V1, ApproxU2V2;
|
||||||
|
Standard_Integer indicemin, indicemax, nbpntmax;
|
||||||
|
Approx_ParametrizationType parametrization;
|
||||||
|
Standard_Real myMinFactorXYZ, myMinFactorUV;
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
class GeomInt_WLApprox
|
class GeomInt_WLApprox
|
||||||
@ -100,12 +117,31 @@ private:
|
|||||||
|
|
||||||
Standard_EXPORT void UpdateTolReached();
|
Standard_EXPORT void UpdateTolReached();
|
||||||
|
|
||||||
|
//! Fill data structure for intersection approximation.
|
||||||
|
Standard_EXPORT void fillData(const Handle(IntPatch_WLine)& theLine,
|
||||||
|
const Standard_Boolean theApproxXYZ,
|
||||||
|
const Standard_Boolean theApproxU1V1,
|
||||||
|
const Standard_Boolean theApproxU2V2);
|
||||||
|
|
||||||
|
//! Prepare data structure for further computations.
|
||||||
|
Standard_EXPORT void prepareDS(const Standard_Boolean theApproxXYZ,
|
||||||
|
const Standard_Boolean theApproxU1V1,
|
||||||
|
const Standard_Boolean theApproxU2V2,
|
||||||
|
const Standard_Integer indicemin,
|
||||||
|
const Standard_Integer indicemax);
|
||||||
|
|
||||||
|
//! Build knot sequence.
|
||||||
|
Standard_EXPORT void buildKnots(const Handle(IntPatch_WLine)& theline,
|
||||||
|
const Standard_Address thePtrSVSurf);
|
||||||
|
|
||||||
|
//! Build curve.
|
||||||
|
Standard_EXPORT void buildCurve(const Handle(IntPatch_WLine)& theline,
|
||||||
|
const Standard_Address thePtrSVSurf);
|
||||||
|
|
||||||
GeomInt_TheComputeLineOfWLApprox myComputeLine;
|
GeomInt_TheComputeLineOfWLApprox myComputeLine;
|
||||||
GeomInt_TheComputeLineBezierOfWLApprox myComputeLineBezier;
|
GeomInt_TheComputeLineBezierOfWLApprox myComputeLineBezier;
|
||||||
Approx_MCurvesToBSpCurve myBezToBSpl;
|
Approx_MCurvesToBSpCurve myBezToBSpl;
|
||||||
Standard_Boolean myTolReached;
|
Standard_Boolean myTolReached;
|
||||||
Standard_Boolean myApproxBez;
|
|
||||||
Standard_Boolean myWithTangency;
|
Standard_Boolean myWithTangency;
|
||||||
Standard_Real myTol3d;
|
Standard_Real myTol3d;
|
||||||
Standard_Real myTol2d;
|
Standard_Real myTol2d;
|
||||||
@ -114,11 +150,11 @@ private:
|
|||||||
Standard_Integer myDegMax;
|
Standard_Integer myDegMax;
|
||||||
Standard_Integer myNbPntMax;
|
Standard_Integer myNbPntMax;
|
||||||
Standard_Integer myNbIterMax;
|
Standard_Integer myNbIterMax;
|
||||||
Standard_Real myMinFactorXYZ;
|
|
||||||
Standard_Real myMinFactorUV;
|
|
||||||
Standard_Real myTolReached3d;
|
Standard_Real myTolReached3d;
|
||||||
Standard_Real myTolReached2d;
|
Standard_Real myTolReached2d;
|
||||||
|
Approx_Data myData;
|
||||||
|
Standard_Real myUVRes1, myUVRes2;
|
||||||
|
NCollection_Vector<Standard_Integer> myKnots;
|
||||||
|
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|||||||
Loading…
x
Reference in New Issue
Block a user