lili/OCCT
1
0
Fork 0
mirror of https://github.com/Open-Cascade-SAS/OCCT.git synced 2026-05-22 04:37:23 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
478afa4eeaafa797553141e5c319f25ec7b2824b
OCCT/src/Approx/Approx_SweepApproximation.cxx
luzpaz f423143109 Documentation - Fix various typos found in codebase #361 
Found via `codespell -q 3 -S "*.fr" -L aadd,abnd,abord,acount,adn,afile,aline,alo,alocation,alog,als,anc,ane,anid,anormal,anout,ans,anumber,aother,aparent,apoints,aprogram,asender,asign,asnd,ba,bbuild,bloc,bord,bu,caf,cas,childrens,childs,classe,clen,commun,cylindre,don,dout,dum,ede,entites,fo,fonction,guid,hist,identic,ii,indx,inout,invalide,ist,iterm,llength,lod,mape,modeling,methode,mye,myu,nam,nd,nin,normale,normales,ons,parametre,parametres,periode,pres,reste,resul,secont,serie,shs,slin,som,somme,syntaxe,sur,te,thei,theis,ther,theres,thes,thev,thex,thet,tol,transfert,va,vas,verifie,vertexes,weight`
2025-02-11 12:38:56 +00:00

856 lines
27 KiB
C++
Raw Blame History

// Created on: 1997-06-25
// Created by: Philippe MANGIN
// Copyright (c) 1997-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 <AdvApprox_ApproxAFunction.hxx>
#include <AdvApprox_DichoCutting.hxx>
#include <AdvApprox_PrefAndRec.hxx>
#include <Approx_SweepApproximation.hxx>
#include <Approx_SweepFunction.hxx>
#include <BSplCLib.hxx>
#include <Standard_DomainError.hxx>
#include <StdFail_NotDone.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <gp_XYZ.hxx>
//=================================================================================================
class Approx_SweepApproximation_Eval : public AdvApprox_EvaluatorFunction
{
public:
Approx_SweepApproximation_Eval(Approx_SweepApproximation& theTool)
: Tool(theTool)
{
}
virtual void Evaluate(Standard_Integer* Dimension,
Standard_Real StartEnd[2],
Standard_Real* Parameter,
Standard_Integer* DerivativeRequest,
Standard_Real* Result, // [Dimension]
Standard_Integer* ErrorCode);
private:
Approx_SweepApproximation& Tool;
};
void Approx_SweepApproximation_Eval::Evaluate(Standard_Integer*, /*Dimension*/
Standard_Real StartEnd[2],
Standard_Real* Parameter,
Standard_Integer* DerivativeRequest,
Standard_Real* Result, // [Dimension]
Standard_Integer* ErrorCode)
{
*ErrorCode = Tool.Eval(*Parameter, *DerivativeRequest, StartEnd[0], StartEnd[1], Result[0]);
}
Approx_SweepApproximation::Approx_SweepApproximation(const Handle(Approx_SweepFunction)& Func)
{
myFunc = Func;
// Init of variables of control
myParam = 0;
myOrder = -1;
first = 1.e100;
last = -1.e100;
done = Standard_False;
}
void Approx_SweepApproximation::Perform(const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol3d,
const Standard_Real BoundTol,
const Standard_Real Tol2d,
const Standard_Real TolAngular,
const GeomAbs_Shape Continuity,
const Standard_Integer Degmax,
const Standard_Integer Segmax)
{
Standard_Integer NbPolSect, NbKnotSect, ii;
Standard_Real Tol, Tol3dMin = Tol3d, The3D2DTol = 0;
GeomAbs_Shape continuity = Continuity;
// (1) Characteristics of a section
myFunc->SectionShape(NbPolSect, NbKnotSect, udeg);
Num2DSS = myFunc->Nb2dCurves();
tabUKnots = new (TColStd_HArray1OfReal)(1, NbKnotSect);
tabUMults = new (TColStd_HArray1OfInteger)(1, NbKnotSect);
myFunc->Knots(tabUKnots->ChangeArray1());
myFunc->Mults(tabUMults->ChangeArray1());
// (2) Decompositition into sub-spaces
Handle(TColStd_HArray1OfReal) OneDTol, TwoDTol, ThreeDTol;
Num3DSS = NbPolSect;
// (2.1) Tolerance 3d and 1d
OneDTol = new (TColStd_HArray1OfReal)(1, Num3DSS);
ThreeDTol = new (TColStd_HArray1OfReal)(1, Num3DSS);
myFunc->GetTolerance(BoundTol, Tol3d, TolAngular, ThreeDTol->ChangeArray1());
for (ii = 1; ii <= Num3DSS; ii++)
if (ThreeDTol->Value(ii) < Tol3dMin)
Tol3dMin = ThreeDTol->Value(ii);
if (myFunc->IsRational())
{
Standard_Real Size;
Num1DSS = NbPolSect;
TColStd_Array1OfReal Wmin(1, Num1DSS);
myFunc->GetMinimalWeight(Wmin);
Size = myFunc->MaximalSection();
Translation.SetXYZ(myFunc->BarycentreOfSurf().XYZ());
for (ii = 1; ii <= Num3DSS; ii++)
{
Tol = ThreeDTol->Value(ii) / 2; // To take account of the error on the final result.
OneDTol->SetValue(ii, Tol * Wmin(ii) / Size);
Tol *= Wmin(ii); // Factor of projection
ThreeDTol->SetValue(ii, Max(Tol, 1.e-20));
}
}
else
{
Num1DSS = 0;
}
// (2.2) Tolerance and Transformation 2d.
if (Num2DSS == 0)
{
TwoDTol.Nullify();
}
else
{
// for 2d define affinity using resolutions, to
// avoid homogeneous tolerance of approximation (u/v and 2d/3d)
Standard_Real res, tolu, tolv;
TwoDTol = new (TColStd_HArray1OfReal)(1, Num2DSS);
AAffin = new (Approx_HArray1OfGTrsf2d)(1, Num2DSS);
The3D2DTol = 0.9 * BoundTol; // 10% of security
for (ii = 1; ii <= Num2DSS; ii++)
{
myFunc->Resolution(ii, The3D2DTol, tolu, tolv);
if (tolu > tolv)
{
res = tolv;
AAffin->ChangeValue(ii).SetValue(1, 1, tolv / tolu);
}
else
{
res = tolu;
AAffin->ChangeValue(ii).SetValue(2, 2, tolu / tolv);
}
TwoDTol->SetValue(ii, Min(Tol2d, res));
}
}
// (3) Approximation
// Init
myPoles = new (TColgp_HArray1OfPnt)(1, Num3DSS);
myDPoles = new (TColgp_HArray1OfVec)(1, Num3DSS);
myD2Poles = new (TColgp_HArray1OfVec)(1, Num3DSS);
myWeigths = new (TColStd_HArray1OfReal)(1, Num3DSS);
myDWeigths = new (TColStd_HArray1OfReal)(1, Num3DSS);
myD2Weigths = new (TColStd_HArray1OfReal)(1, Num3DSS);
if (Num2DSS > 0)
{
myPoles2d = new (TColgp_HArray1OfPnt2d)(1, Num2DSS);
myDPoles2d = new (TColgp_HArray1OfVec2d)(1, Num2DSS);
myD2Poles2d = new (TColgp_HArray1OfVec2d)(1, Num2DSS);
COnSurfErr = new (TColStd_HArray1OfReal)(1, Num2DSS);
}
else
{
myPoles2d = new TColgp_HArray1OfPnt2d();
myDPoles2d = new TColgp_HArray1OfVec2d();
myD2Poles2d = new TColgp_HArray1OfVec2d();
COnSurfErr = new TColStd_HArray1OfReal();
}
// Checks if myFunc->D2 is implemented
if (continuity >= GeomAbs_C2)
{
Standard_Boolean B;
B = myFunc->D2(First,
First,
Last,
myPoles->ChangeArray1(),
myDPoles->ChangeArray1(),
myD2Poles->ChangeArray1(),
myPoles2d->ChangeArray1(),
myDPoles2d->ChangeArray1(),
myD2Poles2d->ChangeArray1(),
myWeigths->ChangeArray1(),
myDWeigths->ChangeArray1(),
myD2Weigths->ChangeArray1());
if (!B)
continuity = GeomAbs_C1;
}
// Checks if myFunc->D1 is implemented
if (continuity == GeomAbs_C1)
{
Standard_Boolean B;
B = myFunc->D1(First,
First,
Last,
myPoles->ChangeArray1(),
myDPoles->ChangeArray1(),
myPoles2d->ChangeArray1(),
myDPoles2d->ChangeArray1(),
myWeigths->ChangeArray1(),
myDWeigths->ChangeArray1());
if (!B)
continuity = GeomAbs_C0;
}
// So that F was at least 20 times more exact than its approx
myFunc->SetTolerance(Tol3dMin / 20, Tol2d / 20);
Standard_Integer NbIntervalC2 = myFunc->NbIntervals(GeomAbs_C2);
Standard_Integer NbIntervalC3 = myFunc->NbIntervals(GeomAbs_C3);
if (NbIntervalC3 > 1)
{
// (3.1) Approximation with preferential cut
TColStd_Array1OfReal Param_de_decoupeC2(1, NbIntervalC2 + 1);
myFunc->Intervals(Param_de_decoupeC2, GeomAbs_C2);
TColStd_Array1OfReal Param_de_decoupeC3(1, NbIntervalC3 + 1);
myFunc->Intervals(Param_de_decoupeC3, GeomAbs_C3);
AdvApprox_PrefAndRec Preferentiel(Param_de_decoupeC2, Param_de_decoupeC3);
Approx_SweepApproximation_Eval ev(*this);
Approximation(OneDTol,
TwoDTol,
ThreeDTol,
The3D2DTol,
First,
Last,
continuity,
Degmax,
Segmax,
ev,
Preferentiel);
}
else
{
// (3.2) Approximation without preferential cut
AdvApprox_DichoCutting Dichotomie;
Approx_SweepApproximation_Eval ev(*this);
Approximation(OneDTol,
TwoDTol,
ThreeDTol,
The3D2DTol,
First,
Last,
continuity,
Degmax,
Segmax,
ev,
Dichotomie);
}
}
//=================================================================================================
// function : Approximation
// purpose : Call F(t) and store the results
//=================================================================================================
void Approx_SweepApproximation::Approximation(const Handle(TColStd_HArray1OfReal)& OneDTol,
const Handle(TColStd_HArray1OfReal)& TwoDTol,
const Handle(TColStd_HArray1OfReal)& ThreeDTol,
const Standard_Real BoundTol,
const Standard_Real First,
const Standard_Real Last,
const GeomAbs_Shape Continuity,
const Standard_Integer Degmax,
const Standard_Integer Segmax,
const AdvApprox_EvaluatorFunction& TheApproxFunction,
const AdvApprox_Cutting& TheCuttingTool)
{
AdvApprox_ApproxAFunction Approx(Num1DSS,
Num2DSS,
Num3DSS,
OneDTol,
TwoDTol,
ThreeDTol,
First,
Last,
Continuity,
Degmax,
Segmax,
TheApproxFunction,
TheCuttingTool);
done = Approx.HasResult();
if (done)
{
// --> Fill Champs of the surface ----
Standard_Integer ii, jj;
vdeg = Approx.Degree();
// Unfortunately Adv_Approx stores the transposition of the required
// so, writing tabPoles = Approx.Poles() will give an erroneous result
// It is only possible to allocate and recopy term by term...
tabPoles = new (TColgp_HArray2OfPnt)(1, Num3DSS, 1, Approx.NbPoles());
tabWeights = new (TColStd_HArray2OfReal)(1, Num3DSS, 1, Approx.NbPoles());
if (Num1DSS == Num3DSS)
{
Standard_Real wpoid;
gp_Pnt P;
for (ii = 1; ii <= Num3DSS; ii++)
{
for (jj = 1; jj <= Approx.NbPoles(); jj++)
{
P = Approx.Poles()->Value(jj, ii);
wpoid = Approx.Poles1d()->Value(jj, ii);
P.ChangeCoord() /= wpoid; // It is necessary to divide poles by weight
P.Translate(Translation);
tabPoles->SetValue(ii, jj, P);
tabWeights->SetValue(ii, jj, wpoid);
}
}
}
else
{
tabWeights->Init(1);
for (ii = 1; ii <= Num3DSS; ii++)
{
for (jj = 1; jj <= Approx.NbPoles(); jj++)
{
tabPoles->SetValue(ii, jj, Approx.Poles()->Value(jj, ii));
}
}
}
// this is better
tabVKnots = Approx.Knots();
tabVMults = Approx.Multiplicities();
// --> Filling of curves 2D ----------
if (Num2DSS > 0)
{
gp_GTrsf2d TrsfInv;
deg2d = vdeg;
tab2dKnots = Approx.Knots();
tab2dMults = Approx.Multiplicities();
for (ii = 1; ii <= Num2DSS; ii++)
{
TrsfInv = AAffin->Value(ii).Inverted();
Handle(TColgp_HArray1OfPnt2d) P2d = new (TColgp_HArray1OfPnt2d)(1, Approx.NbPoles());
Approx.Poles2d(ii, P2d->ChangeArray1());
// do not forget to apply inverted homothety.
for (jj = 1; jj <= Approx.NbPoles(); jj++)
{
TrsfInv.Transforms(P2d->ChangeValue(jj).ChangeCoord());
}
seqPoles2d.Append(P2d);
}
}
// ---> Filling of errors
MError3d = new (TColStd_HArray1OfReal)(1, Num3DSS);
AError3d = new (TColStd_HArray1OfReal)(1, Num3DSS);
for (ii = 1; ii <= Num3DSS; ii++)
{
MError3d->SetValue(ii, Approx.MaxError(3, ii));
AError3d->SetValue(ii, Approx.AverageError(3, ii));
}
if (myFunc->IsRational())
{
MError1d = new (TColStd_HArray1OfReal)(1, Num3DSS);
AError1d = new (TColStd_HArray1OfReal)(1, Num3DSS);
for (ii = 1; ii <= Num1DSS; ii++)
{
MError1d->SetValue(ii, Approx.MaxError(1, ii));
AError1d->SetValue(ii, Approx.AverageError(1, ii));
}
}
if (Num2DSS > 0)
{
tab2dError = new (TColStd_HArray1OfReal)(1, Num2DSS);
Ave2dError = new (TColStd_HArray1OfReal)(1, Num2DSS);
for (ii = 1; ii <= Num2DSS; ii++)
{
tab2dError->SetValue(ii, Approx.MaxError(2, ii));
Ave2dError->SetValue(ii, Approx.AverageError(2, ii));
COnSurfErr->SetValue(ii, (tab2dError->Value(ii) / TwoDTol->Value(ii)) * BoundTol);
}
}
}
}
Standard_Integer Approx_SweepApproximation::Eval(const Standard_Real Parameter,
const Standard_Integer DerivativeRequest,
const Standard_Real First,
const Standard_Real Last,
Standard_Real& Result)
{
Standard_Integer ier = 0;
switch (DerivativeRequest)
{
case 0:
ier = (!D0(Parameter, First, Last, Result));
break;
case 1:
ier = (!D1(Parameter, First, Last, Result));
break;
case 2:
ier = (!D2(Parameter, First, Last, Result));
break;
default:
ier = 2;
}
return ier;
}
Standard_Boolean Approx_SweepApproximation::D0(const Standard_Real Param,
const Standard_Real First,
const Standard_Real Last,
Standard_Real& Result)
{
Standard_Integer index, ii;
Standard_Boolean Ok = Standard_True;
Standard_Real* LocalResult = &Result;
// Management of limits
if ((first != First) || (Last != last))
{
myFunc->SetInterval(First, Last);
}
if (!((Param == myParam) && (myOrder >= 0) && (first == First) && (Last == last)))
{
// Positioning in case when the last operation is not repeated.
Ok = myFunc->D0(Param,
First,
Last,
myPoles->ChangeArray1(),
myPoles2d->ChangeArray1(),
myWeigths->ChangeArray1());
// poles3d are multiplied by weight after translation.
for (ii = 1; ii <= Num1DSS; ii++)
{
myPoles->ChangeValue(ii).ChangeCoord() -= Translation.XYZ();
myPoles->ChangeValue(ii).ChangeCoord() *= myWeigths->Value(ii);
}
// The transformation is applied to poles 2d.
for (ii = 1; ii <= Num2DSS; ii++)
{
AAffin->Value(ii).Transforms(myPoles2d->ChangeValue(ii).ChangeCoord());
}
// Update variables of control and return
first = First;
last = Last;
myOrder = 0;
myParam = Param;
}
// Extraction of results
index = 0;
for (ii = 1; ii <= Num1DSS; ii++)
{
LocalResult[index] = myWeigths->Value(ii);
index++;
}
for (ii = 1; ii <= Num2DSS; ii++)
{
LocalResult[index] = myPoles2d->Value(ii).X();
LocalResult[index + 1] = myPoles2d->Value(ii).Y();
index += 2;
}
for (ii = 1; ii <= Num3DSS; ii++, index += 3)
{
LocalResult[index] = myPoles->Value(ii).X();
LocalResult[index + 1] = myPoles->Value(ii).Y();
LocalResult[index + 2] = myPoles->Value(ii).Z();
}
return Ok;
}
Standard_Boolean Approx_SweepApproximation::D1(const Standard_Real Param,
const Standard_Real First,
const Standard_Real Last,
Standard_Real& Result)
{
gp_XY Vcoord;
gp_Vec Vaux;
Standard_Integer index, ii;
Standard_Boolean Ok = Standard_True;
Standard_Real* LocalResult = &Result;
if ((first != First) || (Last != last))
{
myFunc->SetInterval(First, Last);
}
if (!((Param == myParam) && (myOrder >= 1) && (first == First) && (Last == last)))
{
// Positioning
Ok = myFunc->D1(Param,
First,
Last,
myPoles->ChangeArray1(),
myDPoles->ChangeArray1(),
myPoles2d->ChangeArray1(),
myDPoles2d->ChangeArray1(),
myWeigths->ChangeArray1(),
myDWeigths->ChangeArray1());
// Take into account the multiplication of poles3d by weights.
// and the translation.
for (ii = 1; ii <= Num1DSS; ii++)
{
// Translation on the section
myPoles->ChangeValue(ii).ChangeCoord() -= Translation.XYZ();
// Homothety on all.
const Standard_Real aWeight = myWeigths->Value(ii);
myDPoles->ChangeValue(ii) *= aWeight;
Vaux.SetXYZ(myPoles->Value(ii).Coord());
myDPoles->ChangeValue(ii) += myDWeigths->Value(ii) * Vaux;
myPoles->ChangeValue(ii).ChangeCoord() *= aWeight; // for the cash
}
// Apply transformation 2d to suitable vectors
for (ii = 1; ii <= Num2DSS; ii++)
{
Vcoord = myDPoles2d->Value(ii).XY();
AAffin->Value(ii).Transforms(Vcoord);
myDPoles2d->ChangeValue(ii).SetXY(Vcoord);
AAffin->Value(ii).Transforms(myPoles2d->ChangeValue(ii).ChangeCoord());
}
// Update control variables and return
first = First;
last = Last;
myOrder = 1;
myParam = Param;
}
// Extraction of results
index = 0;
for (ii = 1; ii <= Num1DSS; ii++)
{
LocalResult[index] = myDWeigths->Value(ii);
index++;
}
for (ii = 1; ii <= Num2DSS; ii++)
{
LocalResult[index] = myDPoles2d->Value(ii).X();
LocalResult[index + 1] = myDPoles2d->Value(ii).Y();
index += 2;
}
for (ii = 1; ii <= Num3DSS; ii++, index += 3)
{
LocalResult[index] = myDPoles->Value(ii).X();
LocalResult[index + 1] = myDPoles->Value(ii).Y();
LocalResult[index + 2] = myDPoles->Value(ii).Z();
}
return Ok;
}
Standard_Boolean Approx_SweepApproximation::D2(const Standard_Real Param,
const Standard_Real First,
const Standard_Real Last,
Standard_Real& Result)
{
gp_XY Vcoord;
gp_Vec Vaux;
Standard_Integer index, ii;
Standard_Boolean Ok = Standard_True;
Standard_Real* LocalResult = &Result;
// management of limits
if ((first != First) || (Last != last))
{
myFunc->SetInterval(First, Last);
}
if (!((Param == myParam) && (myOrder >= 2) && (first == First) && (Last == last)))
{
// Positioning in case when the last operation is not repeated
Ok = myFunc->D2(Param,
First,
Last,
myPoles->ChangeArray1(),
myDPoles->ChangeArray1(),
myD2Poles->ChangeArray1(),
myPoles2d->ChangeArray1(),
myDPoles2d->ChangeArray1(),
myD2Poles2d->ChangeArray1(),
myWeigths->ChangeArray1(),
myDWeigths->ChangeArray1(),
myD2Weigths->ChangeArray1());
// Multiply poles3d by the weight after translations.
for (ii = 1; ii <= Num1DSS; ii++)
{
// First translate
myPoles->ChangeValue(ii).ChangeCoord() -= Translation.XYZ();
// Calculate the second derivative
myD2Poles->ChangeValue(ii) *= myWeigths->Value(ii);
Vaux.SetXYZ(myDPoles->Value(ii).XYZ());
myD2Poles->ChangeValue(ii) += (2 * myDWeigths->Value(ii)) * Vaux;
Vaux.SetXYZ(myPoles->Value(ii).Coord());
myD2Poles->ChangeValue(ii) += myD2Weigths->Value(ii) * Vaux;
// Then the remainder for the cash
myDPoles->ChangeValue(ii) *= myWeigths->Value(ii);
Vaux.SetXYZ(myPoles->Value(ii).Coord());
myDPoles->ChangeValue(ii) += myDWeigths->Value(ii) * Vaux;
myPoles->ChangeValue(ii).ChangeCoord() *= myWeigths->Value(ii);
}
// Apply transformation to poles 2d.
for (ii = 1; ii <= Num2DSS; ii++)
{
Vcoord = myD2Poles2d->Value(ii).XY();
AAffin->Value(ii).Transforms(Vcoord);
myD2Poles2d->ChangeValue(ii).SetXY(Vcoord);
Vcoord = myDPoles2d->Value(ii).XY();
AAffin->Value(ii).Transforms(Vcoord);
myDPoles2d->ChangeValue(ii).SetXY(Vcoord);
AAffin->Value(ii).Transforms(myPoles2d->ChangeValue(ii).ChangeCoord());
}
// Update variables of control and return
first = First;
last = Last;
myOrder = 2;
myParam = Param;
}
// Extraction of results
index = 0;
for (ii = 1; ii <= Num1DSS; ii++)
{
LocalResult[index] = myD2Weigths->Value(ii);
index++;
}
for (ii = 1; ii <= Num2DSS; ii++)
{
LocalResult[index] = myD2Poles2d->Value(ii).X();
LocalResult[index + 1] = myD2Poles2d->Value(ii).Y();
index += 2;
}
for (ii = 1; ii <= Num3DSS; ii++, index += 3)
{
LocalResult[index] = myD2Poles->Value(ii).X();
LocalResult[index + 1] = myD2Poles->Value(ii).Y();
LocalResult[index + 2] = myD2Poles->Value(ii).Z();
}
return Ok;
}
void Approx_SweepApproximation::SurfShape(Standard_Integer& UDegree,
Standard_Integer& VDegree,
Standard_Integer& NbUPoles,
Standard_Integer& NbVPoles,
Standard_Integer& NbUKnots,
Standard_Integer& NbVKnots) const
{
if (!done)
{
throw StdFail_NotDone("Approx_SweepApproximation");
}
UDegree = udeg;
VDegree = vdeg;
NbUPoles = tabPoles->ColLength();
NbVPoles = tabPoles->RowLength();
NbUKnots = tabUKnots->Length();
NbVKnots = tabVKnots->Length();
}
void Approx_SweepApproximation::Surface(TColgp_Array2OfPnt& TPoles,
TColStd_Array2OfReal& TWeights,
TColStd_Array1OfReal& TUKnots,
TColStd_Array1OfReal& TVKnots,
TColStd_Array1OfInteger& TUMults,
TColStd_Array1OfInteger& TVMults) const
{
if (!done)
{
throw StdFail_NotDone("Approx_SweepApproximation");
}
TPoles = tabPoles->Array2();
TWeights = tabWeights->Array2();
TUKnots = tabUKnots->Array1();
TUMults = tabUMults->Array1();
TVKnots = tabVKnots->Array1();
TVMults = tabVMults->Array1();
}
Standard_Real Approx_SweepApproximation::MaxErrorOnSurf() const
{
Standard_Integer ii;
Standard_Real MaxError = 0, err;
if (!done)
{
throw StdFail_NotDone("Approx_SweepApproximation");
}
if (myFunc->IsRational())
{
TColStd_Array1OfReal Wmin(1, Num1DSS);
myFunc->GetMinimalWeight(Wmin);
Standard_Real Size = myFunc->MaximalSection();
for (ii = 1; ii <= Num3DSS; ii++)
{
err = (Size * MError1d->Value(ii) + MError3d->Value(ii)) / Wmin(ii);
if (err > MaxError)
MaxError = err;
}
}
else
{
for (ii = 1; ii <= Num3DSS; ii++)
{
err = MError3d->Value(ii);
if (err > MaxError)
MaxError = err;
}
}
return MaxError;
}
Standard_Real Approx_SweepApproximation::AverageErrorOnSurf() const
{
Standard_Integer ii;
Standard_Real MoyError = 0, err;
if (!done)
{
throw StdFail_NotDone("Approx_SweepApproximation");
}
if (myFunc->IsRational())
{
TColStd_Array1OfReal Wmin(1, Num1DSS);
myFunc->GetMinimalWeight(Wmin);
Standard_Real Size = myFunc->MaximalSection();
for (ii = 1; ii <= Num3DSS; ii++)
{
err = (Size * AError1d->Value(ii) + AError3d->Value(ii)) / Wmin(ii);
MoyError += err;
}
}
else
{
for (ii = 1; ii <= Num3DSS; ii++)
{
err = AError3d->Value(ii);
MoyError += err;
}
}
return MoyError / Num3DSS;
}
void Approx_SweepApproximation::Curves2dShape(Standard_Integer& Degree,
Standard_Integer& NbPoles,
Standard_Integer& NbKnots) const
{
if (!done)
{
throw StdFail_NotDone("Approx_SweepApproximation");
}
if (seqPoles2d.Length() == 0)
{
throw Standard_DomainError("Approx_SweepApproximation");
}
Degree = deg2d;
NbPoles = seqPoles2d(1)->Length();
NbKnots = tab2dKnots->Length();
}
void Approx_SweepApproximation::Curve2d(const Standard_Integer Index,
TColgp_Array1OfPnt2d& TPoles,
TColStd_Array1OfReal& TKnots,
TColStd_Array1OfInteger& TMults) const
{
if (!done)
{
throw StdFail_NotDone("Approx_SweepApproximation");
}
if (seqPoles2d.Length() == 0)
{
throw Standard_DomainError("Approx_SweepApproximation");
}
TPoles = seqPoles2d(Index)->Array1();
TKnots = tab2dKnots->Array1();
TMults = tab2dMults->Array1();
}
Standard_Real Approx_SweepApproximation::Max2dError(const Standard_Integer Index) const
{
if (!done)
{
throw StdFail_NotDone("Approx_SweepApproximation");
}
return tab2dError->Value(Index);
}
Standard_Real Approx_SweepApproximation::Average2dError(const Standard_Integer Index) const
{
if (!done)
{
throw StdFail_NotDone("Approx_SweepApproximation");
}
return Ave2dError->Value(Index);
}
Standard_Real Approx_SweepApproximation::TolCurveOnSurf(const Standard_Integer Index) const
{
if (!done)
{
throw StdFail_NotDone("Approx_SweepApproximation");
}
return COnSurfErr->Value(Index);
}
void Approx_SweepApproximation::Dump(Standard_OStream& o) const
{
o << "Dump of SweepApproximation" << std::endl;
if (done)
{
o << "Error 3d = " << MaxErrorOnSurf() << std::endl;
if (Num2DSS > 0)
{
o << "Error 2d = ";
for (Standard_Integer ii = 1; ii <= Num2DSS; ii++)
{
o << Max2dError(ii);
if (ii < Num2DSS)
o << " , " << std::endl;
}
std::cout << std::endl;
}
o << tabVKnots->Length() - 1 << " Segment(s) of degree " << vdeg << std::endl;
}
else
std::cout << " Not Done " << std::endl;
}
Reference in New Issue View Git Blame Copy Permalink